build: Release v35.1 (bug fix release)

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

.github/workflows/build.yaml

@@ -51,6 +51,9 @@ jobs:
       - name: Build (mshv)
         run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "mshv"  -- -D warnings -D clippy::undocumented_unsafe_blocks
 
+      - name: Build (sev_snp)
+        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "sev_snp"  -- -D warnings -D clippy::undocumented_unsafe_blocks
+
       - name: Build (mshv + kvm)
         run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "mshv,kvm"  -- -D warnings -D clippy::undocumented_unsafe_blocks
 

.github/workflows/quality.yaml

@@ -101,6 +101,14 @@ jobs:
           command: clippy
           args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --examples --features "mshv,kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks
 
+      - name: Clippy (sev_snp)
+        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
+          command: clippy
+          args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --examples --features "sev_snp" -- -D warnings -D clippy::undocumented_unsafe_blocks
+
       - name: Clippy (kvm + tdx)
         if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
         uses: actions-rs/cargo@v1
@@ -111,3 +119,12 @@ jobs:
 
       - name: Check build did not modify any files
         run: test -z "$(git status --porcelain)"
+
+  typos:
+    if: github.event_name == 'pull_request'
+    name: Typos / Spellcheck
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      # Executes "typos ."
+      - uses: crate-ci/typos@v1.16.11

.github/workflows/release.yaml

@@ -28,13 +28,13 @@ jobs:
         with:
           toolchain: "1.67.1"
           command: build
-          args: --all --release --no-default-features --features "kvm,mshv" --target=x86_64-unknown-linux-gnu
+          args: --all --release --features mshv --target=x86_64-unknown-linux-gnu
       - name: Static Build
         uses: actions-rs/cargo@v1
         with:
           toolchain: "1.67.1"
           command: build
-          args: --all --release --no-default-features --features "kvm,mshv" --target=x86_64-unknown-linux-musl
+          args: --all --release --features mshv --target=x86_64-unknown-linux-musl
       - name: Install Rust toolchain (aarch64-unknown-linux-musl)
         uses: actions-rs/toolchain@v1
         with:

.typos.toml

@@ -0,0 +1,21 @@
+# Configuration for https://github.com/crate-ci/typos
+
+[files]
+extend-exclude = [
+    "hypervisor/src/kvm/x86_64/mod.rs",
+    "resources/linux-config-*",
+]
+
+[default.extend-words]
+ba = "ba"
+CLASSE = "CLASSE"
+conectix = "conectix"
+Dake = "Dake"
+EXTINT = "EXTINT"
+INOUT = "INOUT"
+liness = "liness"
+outout = "outout"
+
+[default.extend-identifiers]
+fo = "fo"
+fpr = "fpr"

CONTRIBUTING.md

@@ -5,7 +5,7 @@ License](https://opensource.org/licenses/Apache-2.0) and the [BSD 3
 Clause](https://opensource.org/licenses/BSD-3-Clause) license. Individual files
 contain details of their licensing and changes to that file are under the same
 license unless the contribution changes the license of the file. When importing
-code from a third party project (e.g. Firecracker or CrosVM) please respect the
+code from a third party project (e.g. Firecracker or crosvm) please respect the
 license of those projects.
 
 New code should be under the [Apache v2

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cloud-hypervisor"
-version = "33.0.0"
+version = "35.1.0"
 authors = ["The Cloud Hypervisor Authors"]
 edition = "2021"
 default-run = "cloud-hypervisor"
@@ -29,25 +29,25 @@ strip = false
 debug = true
 
 [dependencies]
-anyhow = "1.0.71"
+anyhow = "1.0.75"
 api_client = { path = "api_client" }
 argh = "0.1.9"
 dhat = { version = "0.3.2", optional = true }
-epoll = "4.3.1"
+epoll = "4.3.3"
 event_monitor = { path = "event_monitor" }
 hypervisor = { path = "hypervisor" }
-libc = "0.2.139"
+libc = "0.2.147"
 log = { version = "0.4.17", features = ["std"] }
 option_parser = { path = "option_parser" }
 seccompiler = "0.3.0"
-serde_json = "1.0.96"
-signal-hook = "0.3.15"
+serde_json = "1.0.107"
+signal-hook = "0.3.17"
 thiserror = "1.0.40"
 tpm = { path = "tpm"}
 tracer = { path = "tracer" }
 vmm = { path = "vmm" }
 vmm-sys-util = "0.11.0"
-vm-memory = "0.11.0"
+vm-memory = "0.12.2"
 zbus = { version = "3.11.1", optional = true }
 
 # List of patched crates
@@ -55,23 +55,24 @@ zbus = { version = "3.11.1", optional = true }
 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" }
-vhost = { git = "https://github.com/rust-vmm/vhost", branch = "main" }
 
 [dev-dependencies]
 dirs = "5.0.0"
 net_util = { path = "net_util" }
-once_cell = "1.17.1"
-serde_json = "1.0.96"
+once_cell = "1.18.0"
+serde_json = "1.0.107"
 test_infra = { path = "test_infra" }
 wait-timeout = "0.2.0"
 
 [features]
-default = ["kvm"]
+default = ["kvm", "io_uring"]
 dbus_api = ["zbus", "vmm/dbus_api"]
 dhat-heap = ["dhat"] # For heap profiling
 guest_debug = ["vmm/guest_debug"]
+io_uring = ["vmm/io_uring"]
 kvm = ["vmm/kvm"]
 mshv = ["vmm/mshv"]
+sev_snp = ["vmm/sev_snp", "mshv"]
 tdx = ["vmm/tdx"]
 tracing = ["vmm/tracing", "tracer/tracing"]
 
@@ -79,7 +80,7 @@ tracing = ["vmm/tracing", "tracer/tracing"]
 members = [
     "api_client",
     "arch",
-    "block_util",
+    "block",
     "devices",
     "event_monitor",
     "hypervisor",
@@ -88,12 +89,10 @@ members = [
     "option_parser",
     "pci",
     "performance-metrics",
-    "qcow",
     "rate_limiter",
     "serial_buffer",
     "test_infra",
     "tracer",
-    "vhdx",
     "vhost_user_block",
     "vhost_user_net",
     "virtio-devices",

Jenkinsfile

@@ -22,7 +22,7 @@ pipeline {
                     steps {
                         script {
                             runWorkers = false
-                            echo 'No changes requring a build'
+                            echo 'No changes requiring a build'
                         }
                     }
                 }
@@ -117,6 +117,63 @@ pipeline {
                         }
                     }
                 }
+                stage('Worker build - AMD') {
+                    agent { node { label 'jammy-amd' } }
+                    when {
+                        beforeAgent true
+                        expression {
+                            return runWorkers
+                        }
+                    }
+                    stages {
+                        stage('Checkout') {
+                            steps {
+                                checkout scm
+                            }
+                        }
+                        stage('Prepare environment') {
+                            steps {
+                                sh 'scripts/prepare_vdpa.sh'
+                            }
+                        }
+                        stage('Run integration tests') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'sudo modprobe openvswitch'
+                                sh 'scripts/dev_cli.sh tests --integration -- -- --skip common_parallel::test_vfio'
+                            }
+                        }
+                        stage('Run live-migration integration tests') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'sudo modprobe openvswitch'
+                                sh 'scripts/dev_cli.sh tests --integration-live-migration'
+                            }
+                        }
+                        stage('Run integration tests for musl') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'sudo modprobe openvswitch'
+                                sh 'scripts/dev_cli.sh tests --integration --libc musl -- -- --skip common_parallel::test_vfio'
+                            }
+                        }
+                        stage('Run live-migration integration tests for musl') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'sudo modprobe openvswitch'
+                                sh 'scripts/dev_cli.sh tests --integration-live-migration --libc musl'
+                            }
+                        }
+                    }
+                }
                 stage('AArch64 worker build') {
                     agent { node { label 'bionic-arm64' } }
                     when {
@@ -150,7 +207,7 @@ pipeline {
                         }
                         stage('Install azure-cli') {
                             steps {
-                                installAzureCli('bionic', 'arm64')
+                                installAzureCli('focal', 'arm64')
                             }
                         }
                         stage('Download Windows image') {

README.md

@@ -78,9 +78,9 @@ The following sections describe how to build and run Cloud Hypervisor.
 
 ## Host OS
 
-For required KVM functionality the minimum host kernel version is 4.11.  For
-adequate performance the minimum recommended host kernel version is 5.6. The
-majority of the CI currently tests with kernel version 5.15.
+For required KVM functionality and adequate performance the recommended host
+kernel version is 5.13. The majority of the CI currently tests with kernel
+version 5.15.
 
 ## Use Pre-built Binaries
 

arch/Cargo.toml

@@ -6,21 +6,22 @@ edition = "2021"
 
 [features]
 default = []
+sev_snp = []
 tdx = []
 
 [dependencies]
-anyhow = "1.0.71"
+anyhow = "1.0.75"
 byteorder = "1.4.3"
 hypervisor = { path = "../hypervisor" }
-libc = "0.2.139"
-linux-loader = { version = "0.9.0", features = ["elf", "bzimage", "pe"] }
+libc = "0.2.147"
+linux-loader = { version = "0.9.1", features = ["elf", "bzimage", "pe"] }
 log = "0.4.17"
-serde = { version = "1.0.164", features = ["rc", "derive"] }
+serde = { version = "1.0.168", features = ["rc", "derive"] }
 thiserror = "1.0.40"
 uuid = "1.3.4"
 versionize = "0.1.10"
 versionize_derive = "0.1.4"
-vm-memory = { version = "0.11.0", features = ["backend-mmap", "backend-bitmap"] }
+vm-memory = { version = "0.12.2", features = ["backend-mmap", "backend-bitmap"] }
 vm-migration = { path = "../vm-migration" }
 vmm-sys-util = { version = "0.11.0", features = ["with-serde"] }
 

arch/src/aarch64/fdt.rs

@@ -98,7 +98,7 @@ pub enum CacheLevel {
     L3 = 3,
 }
 
-/// NOTE: CACHE SIZE file directory example,
+/// NOTE: cache size file directory example,
 /// "/sys/devices/system/cpu/cpu0/cache/index0/size".
 pub fn get_cache_size(cache_level: CacheLevel) -> u32 {
     let mut file_directory: String = "/sys/devices/system/cpu/cpu0/cache".to_string();
@@ -111,7 +111,7 @@ pub fn get_cache_size(cache_level: CacheLevel) -> u32 {
 
     let file_path = Path::new(&file_directory);
     if !file_path.exists() {
-        error!("File: {} not exist.", file_directory);
+        warn!("File: {} does not exist.", file_directory);
         0
     } else {
         info!("File: {} exist.", file_directory);
@@ -132,7 +132,7 @@ pub fn get_cache_size(cache_level: CacheLevel) -> u32 {
     }
 }
 
-/// NOTE: CACHE COHERENCY LINE SIZE file directory example,
+/// NOTE: coherency_line_size file directory example,
 /// "/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size".
 pub fn get_cache_coherency_line_size(cache_level: CacheLevel) -> u32 {
     let mut file_directory: String = "/sys/devices/system/cpu/cpu0/cache".to_string();
@@ -145,7 +145,7 @@ pub fn get_cache_coherency_line_size(cache_level: CacheLevel) -> u32 {
 
     let file_path = Path::new(&file_directory);
     if !file_path.exists() {
-        error!("File: {} not exist.", file_directory);
+        warn!("File: {} does not exist.", file_directory);
         0
     } else {
         info!("File: {} exist.", file_directory);
@@ -155,7 +155,7 @@ pub fn get_cache_coherency_line_size(cache_level: CacheLevel) -> u32 {
     }
 }
 
-/// NOTE: CACHE NUMBER OF SETS file directory example,
+/// NOTE: number_of_sets file directory example,
 /// "/sys/devices/system/cpu/cpu0/cache/index0/number_of_sets".
 pub fn get_cache_number_of_sets(cache_level: CacheLevel) -> u32 {
     let mut file_directory: String = "/sys/devices/system/cpu/cpu0/cache".to_string();
@@ -168,7 +168,7 @@ pub fn get_cache_number_of_sets(cache_level: CacheLevel) -> u32 {
 
     let file_path = Path::new(&file_directory);
     if !file_path.exists() {
-        error!("File: {} not exist.", file_directory);
+        warn!("File: {} does not exist.", file_directory);
         0
     } else {
         info!("File: {} exist.", file_directory);
@@ -178,6 +178,41 @@ pub fn get_cache_number_of_sets(cache_level: CacheLevel) -> u32 {
     }
 }
 
+/// NOTE: shared_cpu_list file directory example,
+/// "/sys/devices/system/cpu/cpu0/cache/index0/shared_cpu_list".
+pub fn get_cache_shared(cache_level: CacheLevel) -> bool {
+    let mut file_directory: String = "/sys/devices/system/cpu/cpu0/cache".to_string();
+    let mut result = true;
+
+    match cache_level {
+        CacheLevel::L1D | CacheLevel::L1I => result = false,
+        CacheLevel::L2 => file_directory += "/index2/shared_cpu_list",
+        CacheLevel::L3 => file_directory += "/index3/shared_cpu_list",
+    }
+
+    if !result {
+        return false;
+    }
+
+    let file_path = Path::new(&file_directory);
+    if !file_path.exists() {
+        warn!("File: {} does not exist.", file_directory);
+        result = false;
+    } else {
+        info!("File: {} exist.", file_directory);
+
+        let src = fs::read_to_string(file_directory).expect("File not exists or file corrupted.");
+        let src = src.trim();
+        if src.is_empty() {
+            result = false;
+        } else {
+            result = src.contains('-') || src.contains(',');
+        }
+    }
+
+    result
+}
+
 /// Creates the flattened device tree for this aarch64 VM.
 #[allow(clippy::too_many_arguments)]
 pub fn create_fdt<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
@@ -255,6 +290,8 @@ fn create_cpu_nodes(
     fdt.property_u32("#size-cells", 0x0)?;
 
     let num_cpus = vcpu_mpidr.len();
+    let (threads_per_core, cores_per_package, packages) = vcpu_topology.unwrap_or((1, 1, 1));
+    let max_cpus: u32 = (threads_per_core * cores_per_package * packages).into();
 
     // Add cache info.
     // L1 Data Cache Info.
@@ -277,10 +314,14 @@ fn create_cpu_nodes(
     let mut l3_cache_line_size: u32 = 0;
     let mut l3_cache_sets: u32 = 0;
 
+    // Cache Shared Info.
+    let mut l2_cache_shared: bool = false;
+    let mut l3_cache_shared: bool = false;
+
     let cache_path = Path::new("/sys/devices/system/cpu/cpu0/cache");
     let cache_exist: bool = cache_path.exists();
     if !cache_exist {
-        error!("cache sysfs system does not exist.");
+        warn!("cache sysfs system does not exist.");
     } else {
         info!("cache sysfs system exists.");
         // L1 Data Cache Info.
@@ -302,6 +343,14 @@ fn create_cpu_nodes(
         l3_cache_size = get_cache_size(CacheLevel::L3);
         l3_cache_line_size = get_cache_coherency_line_size(CacheLevel::L3);
         l3_cache_sets = get_cache_number_of_sets(CacheLevel::L3);
+
+        // Cache Shared Info.
+        if l2_cache_size != 0 {
+            l2_cache_shared = get_cache_shared(CacheLevel::L2);
+        }
+        if l3_cache_size != 0 {
+            l3_cache_shared = get_cache_shared(CacheLevel::L3);
+        }
     }
 
     for (cpu_id, mpidr) in vcpu_mpidr.iter().enumerate().take(num_cpus) {
@@ -318,21 +367,6 @@ fn create_cpu_nodes(
         fdt.property_u32("reg", (mpidr & 0x7FFFFF) as u32)?;
         fdt.property_u32("phandle", cpu_id as u32 + FIRST_VCPU_PHANDLE)?;
 
-        if cache_exist && l1_d_cache_size != 0 && l1_i_cache_size != 0 {
-            // Add cache info.
-            fdt.property_u32("d-cache-size", l1_d_cache_size)?;
-            fdt.property_u32("d-cache-line-size", l1_d_cache_line_size)?;
-            fdt.property_u32("d-cache-sets", l1_d_cache_sets)?;
-
-            fdt.property_u32("i-cache-size", l1_i_cache_size)?;
-            fdt.property_u32("i-cache-line-size", l1_i_cache_line_size)?;
-            fdt.property_u32("i-cache-sets", l1_i_cache_sets)?;
-
-            if l2_cache_size != 0 {
-                fdt.property_u32("next-level-cache", L2_CACHE_PHANDLE)?;
-            }
-        }
-
         // Add `numa-node-id` property if there is any numa config.
         if numa_nodes.len() > 1 {
             for numa_node_idx in 0..numa_nodes.len() {
@@ -343,37 +377,89 @@ fn create_cpu_nodes(
             }
         }
 
+        if cache_exist && l1_d_cache_size != 0 && l1_i_cache_size != 0 {
+            // Add cache info.
+            fdt.property_u32("d-cache-size", l1_d_cache_size)?;
+            fdt.property_u32("d-cache-line-size", l1_d_cache_line_size)?;
+            fdt.property_u32("d-cache-sets", l1_d_cache_sets)?;
+
+            fdt.property_u32("i-cache-size", l1_i_cache_size)?;
+            fdt.property_u32("i-cache-line-size", l1_i_cache_line_size)?;
+            fdt.property_u32("i-cache-sets", l1_i_cache_sets)?;
+
+            if l2_cache_size != 0 && !l2_cache_shared {
+                fdt.property_u32(
+                    "next-level-cache",
+                    cpu_id as u32 + max_cpus + FIRST_VCPU_PHANDLE + L2_CACHE_PHANDLE,
+                )?;
+
+                let l2_cache_name = "l2-cache0";
+                let l2_cache_node = fdt.begin_node(l2_cache_name)?;
+                // PHANDLE is used to mark device node, and PHANDLE is unique. To avoid phandle
+                // conflicts with other device nodes, consider the previous CPU PHANDLE, so the
+                // CPU L2 cache PHANDLE must start from the largest CPU PHANDLE plus 1.
+                fdt.property_u32(
+                    "phandle",
+                    cpu_id as u32 + max_cpus + FIRST_VCPU_PHANDLE + L2_CACHE_PHANDLE,
+                )?;
+
+                fdt.property_string("compatible", "cache")?;
+                fdt.property_u32("cache-size", l2_cache_size)?;
+                fdt.property_u32("cache-line-size", l2_cache_line_size)?;
+                fdt.property_u32("cache-sets", l2_cache_sets)?;
+                fdt.property_u32("cache-level", 2)?;
+
+                if l3_cache_size != 0 && l3_cache_shared {
+                    let package_id: u32 = cpu_id as u32 / cores_per_package as u32;
+                    fdt.property_u32(
+                        "next-level-cache",
+                        package_id
+                            + num_cpus as u32
+                            + max_cpus
+                            + FIRST_VCPU_PHANDLE
+                            + L2_CACHE_PHANDLE
+                            + L3_CACHE_PHANDLE,
+                    )?;
+                }
+
+                fdt.end_node(l2_cache_node)?;
+            }
+            if l2_cache_size != 0 && l2_cache_shared {
+                warn!("L2 cache shared with other cpus");
+            }
+        }
+
         fdt.end_node(cpu_node)?;
     }
 
-    if cache_exist && l2_cache_size != 0 {
-        let l2_cache_name = "l2-cache0";
-        let l2_cache_node = fdt.begin_node(l2_cache_name)?;
-        fdt.property_u32("phandle", L2_CACHE_PHANDLE)?;
-        fdt.property_string("compatible", "cache")?;
-        fdt.property_u32("cache-size", l2_cache_size)?;
-        fdt.property_u32("cache-line-size", l2_cache_line_size)?;
-        fdt.property_u32("cache-sets", l2_cache_sets)?;
-        fdt.property_u32("cache-level", 2)?;
+    if cache_exist && l3_cache_size != 0 && !l2_cache_shared && l3_cache_shared {
+        let mut i: u32 = 0;
+        while i < packages.into() {
+            let l3_cache_name = "l3-cache0";
+            let l3_cache_node = fdt.begin_node(l3_cache_name)?;
+            // ARM L3 cache is generally shared within the package (socket), so the
+            // L3 cache node pointed to by the CPU in the package has the same L3
+            // cache PHANDLE. The L3 cache phandle must start from the largest L2
+            // cache PHANDLE plus 1 to avoid duplication.
+            fdt.property_u32(
+                "phandle",
+                i + num_cpus as u32
+                    + max_cpus
+                    + FIRST_VCPU_PHANDLE
+                    + L2_CACHE_PHANDLE
+                    + L3_CACHE_PHANDLE,
+            )?;
 
-        if l3_cache_size != 0 {
-            fdt.property_u32("next-level-cache", L3_CACHE_PHANDLE)?;
+            fdt.property_string("compatible", "cache")?;
+            fdt.property_null("cache-unified")?;
+            fdt.property_u32("cache-size", l3_cache_size)?;
+            fdt.property_u32("cache-line-size", l3_cache_line_size)?;
+            fdt.property_u32("cache-sets", l3_cache_sets)?;
+            fdt.property_u32("cache-level", 3)?;
+            fdt.end_node(l3_cache_node)?;
+
+            i += 1;
         }
-
-        fdt.end_node(l2_cache_node)?;
-    }
-
-    if cache_exist && l3_cache_size != 0 {
-        let l3_cache_name = "l3-cache0";
-        let l3_cache_node = fdt.begin_node(l3_cache_name)?;
-        fdt.property_u32("phandle", L3_CACHE_PHANDLE)?;
-        fdt.property_string("compatible", "cache")?;
-        fdt.property_null("cache-unified")?;
-        fdt.property_u32("cache-size", l3_cache_size)?;
-        fdt.property_u32("cache-line-size", l3_cache_line_size)?;
-        fdt.property_u32("cache-sets", l3_cache_sets)?;
-        fdt.property_u32("cache-level", 3)?;
-        fdt.end_node(l3_cache_node)?;
     }
 
     if let Some(topology) = vcpu_topology {

arch/src/x86_64/mod.rs

@@ -39,7 +39,6 @@ const MTRR_EDX_BIT: u8 = 12; // Hypervisor ecx bit.
 const INVARIANT_TSC_EDX_BIT: u8 = 8; // Invariant TSC bit on 0x8000_0007 EDX
 
 // KVM feature bits
-const KVM_FEATURE_ASYNC_PF_INT_BIT: u8 = 14;
 #[cfg(feature = "tdx")]
 const KVM_FEATURE_CLOCKSOURCE_BIT: u8 = 0;
 #[cfg(feature = "tdx")]
@@ -61,7 +60,7 @@ pub const _NSIG: i32 = 65;
 /// is to be used to configure the guest initial state.
 pub struct EntryPoint {
     /// Address in guest memory where the guest must start execution
-    pub entry_addr: Option<GuestAddress>,
+    pub entry_addr: GuestAddress,
 }
 
 const E820_RAM: u32 = 1;
@@ -675,14 +674,7 @@ pub fn generate_common_cpuid(
             0x8000_0008 => {
                 entry.eax = (entry.eax & 0xffff_ff00) | (phys_bits as u32 & 0xff);
             }
-            // Disable KVM_FEATURE_ASYNC_PF_INT
-            // This is required until we find out why the asynchronous page
-            // fault is generating unexpected behavior when using interrupt
-            // mechanism.
-            // TODO: Re-enable KVM_FEATURE_ASYNC_PF_INT (#2277)
             0x4000_0001 => {
-                entry.eax &= !(1 << KVM_FEATURE_ASYNC_PF_INT_BIT);
-
                 // These features are not supported by TDX
                 #[cfg(feature = "tdx")]
                 if tdx_enabled {
@@ -819,12 +811,10 @@ pub fn configure_vcpu(
 
     regs::setup_msrs(vcpu).map_err(Error::MsrsConfiguration)?;
     if let Some((kernel_entry_point, guest_memory)) = boot_setup {
-        if let Some(entry_addr) = kernel_entry_point.entry_addr {
-            // Safe to unwrap because this method is called after the VM is configured
-            regs::setup_regs(vcpu, entry_addr.raw_value()).map_err(Error::RegsConfiguration)?;
-            regs::setup_fpu(vcpu).map_err(Error::FpuConfiguration)?;
-            regs::setup_sregs(&guest_memory.memory(), vcpu).map_err(Error::SregsConfiguration)?;
-        }
+        regs::setup_regs(vcpu, kernel_entry_point.entry_addr.raw_value())
+            .map_err(Error::RegsConfiguration)?;
+        regs::setup_fpu(vcpu).map_err(Error::FpuConfiguration)?;
+        regs::setup_sregs(&guest_memory.memory(), vcpu).map_err(Error::SregsConfiguration)?;
     }
     interrupts::set_lint(vcpu).map_err(|e| Error::LocalIntConfiguration(e.into()))?;
     Ok(())
@@ -1015,7 +1005,7 @@ fn configure_pvh(
         }
 
         info!(
-            "create_memmap_entry, start: 0x{:08x}, end: 0x{:08x})",
+            "create_memmap_entry, start: 0x{:08x}, end: 0x{:08x}",
             high_ram_start, first_region_end
         );
 
@@ -1041,7 +1031,7 @@ fn configure_pvh(
         }
 
         info!(
-            "create_memmap_entry, start: 0x{:08x}, end: 0x{:08x})",
+            "create_memmap_entry, start: 0x{:08x}, end: 0x{:08x}",
             ram_64bit_start, second_region_end
         );
         add_memmap_entry(

arch/src/x86_64/tdx/mod.rs

@@ -98,7 +98,7 @@ fn tdvf_descriptor_offset(file: &mut File) -> Result<(SeekFrom, bool), TdvfError
         // We start after the footer GUID and the table length.
         let mut offset = table_size - 18;
 
-        debug!("Parsing GUIDed structure");
+        debug!("Parsing GUID structure");
         while offset >= 18 {
             let entry_uuid = Uuid::from_slice_le(&table[offset - 16..offset])
                 .map_err(TdvfError::UuidCreation)?;

block/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "block"
+version = "0.1.0"
+edition = "2021"
+authors = ["The Cloud Hypervisor Authors", "The Chromium OS Authors"]
+
+[features]
+default = []
+io_uring = ["dep:io-uring"]
+
+[dependencies]
+byteorder = "1.4.3"
+crc32c = "0.6.4"
+io-uring = { version = "0.6.1", optional = true }
+libc = "0.2.147"
+log = "0.4.17"
+remain = "0.2.11"
+smallvec = "1.11.0"
+thiserror = "1.0.40"
+uuid = { version = "1.3.4", features = ["v4"] }
+versionize = "0.1.10"
+versionize_derive = "0.1.4"
+virtio-bindings = { version = "0.2.0", features = ["virtio-v5_0_0"] }
+virtio-queue = "0.9.0"
+vm-memory = { version = "0.12.2", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
+vm-virtio = { path = "../vm-virtio" }
+vmm-sys-util = "0.11.0"

block/src/async_io.rs

@@ -0,0 +1,60 @@
+// Copyright © 2021 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+
+use crate::DiskTopology;
+use thiserror::Error;
+use vmm_sys_util::eventfd::EventFd;
+
+#[derive(Error, Debug)]
+pub enum DiskFileError {
+    /// Failed getting disk file size.
+    #[error("Failed getting disk file size: {0}")]
+    Size(#[source] std::io::Error),
+    /// Failed creating a new AsyncIo.
+    #[error("Failed creating a new AsyncIo: {0}")]
+    NewAsyncIo(#[source] std::io::Error),
+}
+
+pub type DiskFileResult<T> = std::result::Result<T, DiskFileError>;
+
+pub trait DiskFile: Send {
+    fn size(&mut self) -> DiskFileResult<u64>;
+    fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>>;
+    fn topology(&mut self) -> DiskTopology {
+        DiskTopology::default()
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum AsyncIoError {
+    /// Failed vectored reading from file.
+    #[error("Failed vectored reading from file: {0}")]
+    ReadVectored(#[source] std::io::Error),
+    /// Failed vectored writing to file.
+    #[error("Failed vectored writing to file: {0}")]
+    WriteVectored(#[source] std::io::Error),
+    /// Failed synchronizing file.
+    #[error("Failed synchronizing file: {0}")]
+    Fsync(#[source] std::io::Error),
+}
+
+pub type AsyncIoResult<T> = std::result::Result<T, AsyncIoError>;
+
+pub trait AsyncIo: Send {
+    fn notifier(&self) -> &EventFd;
+    fn read_vectored(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+    ) -> AsyncIoResult<()>;
+    fn write_vectored(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+    ) -> AsyncIoResult<()>;
+    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()>;
+    fn next_completed_request(&mut self) -> Option<(u64, i32)>;
+}

block/src/fixed_vhd.rs

@@ -0,0 +1,90 @@
+// Copyright © 2021 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::vhd::VhdFooter;
+use crate::BlockBackend;
+use std::fs::File;
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::os::unix::io::{AsRawFd, RawFd};
+
+#[derive(Debug)]
+pub struct FixedVhd {
+    file: File,
+    size: u64,
+    position: u64,
+}
+
+impl FixedVhd {
+    pub fn new(mut file: File) -> std::io::Result<Self> {
+        let footer = VhdFooter::new(&mut file)?;
+
+        Ok(Self {
+            file,
+            size: footer.current_size(),
+            position: 0,
+        })
+    }
+}
+
+impl AsRawFd for FixedVhd {
+    fn as_raw_fd(&self) -> RawFd {
+        self.file.as_raw_fd()
+    }
+}
+
+impl Read for FixedVhd {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        match self.file.read(buf) {
+            Ok(r) => {
+                self.position = self.position.checked_add(r.try_into().unwrap()).unwrap();
+                Ok(r)
+            }
+            Err(e) => Err(e),
+        }
+    }
+}
+
+impl Write for FixedVhd {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        match self.file.write(buf) {
+            Ok(r) => {
+                self.position = self.position.checked_add(r.try_into().unwrap()).unwrap();
+                Ok(r)
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.file.sync_all()
+    }
+}
+
+impl Seek for FixedVhd {
+    fn seek(&mut self, newpos: SeekFrom) -> std::io::Result<u64> {
+        match self.file.seek(newpos) {
+            Ok(pos) => {
+                self.position = pos;
+                Ok(pos)
+            }
+            Err(e) => Err(e),
+        }
+    }
+}
+
+impl BlockBackend for FixedVhd {
+    fn size(&self) -> std::result::Result<u64, crate::Error> {
+        Ok(self.size)
+    }
+}
+
+impl Clone for FixedVhd {
+    fn clone(&self) -> Self {
+        Self {
+            file: self.file.try_clone().expect("FixedVhd cloning failed"),
+            size: self.size,
+            position: self.position,
+        }
+    }
+}

block/src/fixed_vhd_async.rs

@@ -5,36 +5,29 @@
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
 };
+use crate::fixed_vhd::FixedVhd;
 use crate::raw_async::RawFileAsync;
-use crate::vhd::VhdFooter;
+use crate::BlockBackend;
 use std::fs::File;
 use std::os::unix::io::{AsRawFd, RawFd};
 use vmm_sys_util::eventfd::EventFd;
 
-pub struct FixedVhdDiskAsync {
-    file: File,
-    size: u64,
-}
+pub struct FixedVhdDiskAsync(FixedVhd);
 
 impl FixedVhdDiskAsync {
-    pub fn new(mut file: File) -> std::io::Result<Self> {
-        let footer = VhdFooter::new(&mut file)?;
-
-        Ok(FixedVhdDiskAsync {
-            file,
-            size: footer.current_size(),
-        })
+    pub fn new(file: File) -> std::io::Result<Self> {
+        Ok(Self(FixedVhd::new(file)?))
     }
 }
 
 impl DiskFile for FixedVhdDiskAsync {
     fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self.size)
+        Ok(self.0.size().unwrap())
     }
 
     fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
         Ok(Box::new(
-            FixedVhdAsync::new(self.file.as_raw_fd(), ring_depth, self.size)
+            FixedVhdAsync::new(self.0.as_raw_fd(), ring_depth, self.0.size().unwrap())
                 .map_err(DiskFileError::NewAsyncIo)?,
         ) as Box<dyn AsyncIo>)
     }

block/src/fixed_vhd_sync.rs

@@ -5,36 +5,29 @@
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
 };
+use crate::fixed_vhd::FixedVhd;
 use crate::raw_sync::RawFileSync;
-use crate::vhd::VhdFooter;
+use crate::BlockBackend;
 use std::fs::File;
 use std::os::unix::io::{AsRawFd, RawFd};
 use vmm_sys_util::eventfd::EventFd;
 
-pub struct FixedVhdDiskSync {
-    file: File,
-    size: u64,
-}
+pub struct FixedVhdDiskSync(FixedVhd);
 
 impl FixedVhdDiskSync {
-    pub fn new(mut file: File) -> std::io::Result<Self> {
-        let footer = VhdFooter::new(&mut file)?;
-
-        Ok(FixedVhdDiskSync {
-            file,
-            size: footer.current_size(),
-        })
+    pub fn new(file: File) -> std::io::Result<Self> {
+        Ok(Self(FixedVhd::new(file)?))
     }
 }
 
 impl DiskFile for FixedVhdDiskSync {
     fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self.size)
+        Ok(self.0.size().unwrap())
     }
 
     fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
         Ok(Box::new(
-            FixedVhdSync::new(self.file.as_raw_fd(), self.size)
+            FixedVhdSync::new(self.0.as_raw_fd(), self.0.size().unwrap())
                 .map_err(DiskFileError::NewAsyncIo)?,
         ) as Box<dyn AsyncIo>)
     }

block/src/lib.rs

@@ -12,24 +12,40 @@
 extern crate log;
 
 pub mod async_io;
+pub mod fixed_vhd;
+#[cfg(feature = "io_uring")]
+/// Enabled with the `"io_uring"` feature
 pub mod fixed_vhd_async;
 pub mod fixed_vhd_sync;
+pub mod qcow;
 pub mod qcow_sync;
+#[cfg(feature = "io_uring")]
+/// Async primitives based on `io-uring`
+///
+/// Enabled with the `"io_uring"` feature
 pub mod raw_async;
 pub mod raw_sync;
 pub mod vhd;
+pub mod vhdx;
 pub mod vhdx_sync;
 
 use crate::async_io::{AsyncIo, AsyncIoError, AsyncIoResult};
+use crate::fixed_vhd::FixedVhd;
+use crate::qcow::{QcowFile, RawFile};
+use crate::vhdx::{Vhdx, VhdxError};
+#[cfg(feature = "io_uring")]
 use io_uring::{opcode, IoUring, Probe};
+use libc::{ioctl, S_IFBLK, S_IFMT};
 use smallvec::SmallVec;
 use std::alloc::{alloc_zeroed, dealloc, Layout};
 use std::cmp;
 use std::collections::VecDeque;
 use std::convert::TryInto;
+use std::fmt::Debug;
 use std::fs::File;
 use std::io::{self, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
 use std::os::linux::fs::MetadataExt;
+use std::os::unix::io::AsRawFd;
 use std::path::Path;
 use std::result;
 use std::sync::Arc;
@@ -46,6 +62,7 @@ use vm_memory::{
 };
 use vm_virtio::{AccessPlatform, Translatable};
 use vmm_sys_util::eventfd::EventFd;
+use vmm_sys_util::{ioctl_io_nr, ioctl_ioc_nr};
 
 type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
 
@@ -66,12 +83,22 @@ pub enum Error {
     DescriptorChainTooShort,
     #[error("Guest gave us a descriptor that was too short to use")]
     DescriptorLengthTooSmall,
+    #[error("Failed to detect image type: {0}")]
+    DetectImageType(std::io::Error),
+    #[error("Failure in fixed vhd: {0}")]
+    FixedVhdError(std::io::Error),
     #[error("Getting a block's metadata fails for any reason")]
     GetFileMetadata,
     #[error("The requested operation would cause a seek beyond disk end")]
     InvalidOffset,
+    #[error("Failure in qcow: {0}")]
+    QcowError(qcow::Error),
+    #[error("Failure in raw file: {0}")]
+    RawFileError(std::io::Error),
     #[error("The requested operation does not support multiple descriptors")]
     TooManyDescriptors,
+    #[error("Failure in vhdx: {0}")]
+    VhdxError(VhdxError),
 }
 
 fn build_device_id(disk_path: &Path) -> result::Result<String, Error> {
@@ -89,8 +116,8 @@ fn build_device_id(disk_path: &Path) -> result::Result<String, Error> {
     Ok(device_id)
 }
 
-pub fn build_disk_image_id(disk_path: &Path) -> Vec<u8> {
-    let mut default_disk_image_id = vec![0; VIRTIO_BLK_ID_BYTES as usize];
+pub fn build_serial(disk_path: &Path) -> Vec<u8> {
+    let mut default_serial = vec![0; VIRTIO_BLK_ID_BYTES as usize];
     match build_device_id(disk_path) {
         Err(_) => {
             warn!("Could not generate device id. We'll use a default.");
@@ -100,17 +127,17 @@ pub fn build_disk_image_id(disk_path: &Path) -> Vec<u8> {
             // This will also zero out any leftover bytes.
             let disk_id = m.as_bytes();
             let bytes_to_copy = cmp::min(disk_id.len(), VIRTIO_BLK_ID_BYTES as usize);
-            default_disk_image_id[..bytes_to_copy].clone_from_slice(&disk_id[..bytes_to_copy])
+            default_serial[..bytes_to_copy].clone_from_slice(&disk_id[..bytes_to_copy])
         }
     }
-    default_disk_image_id
+    default_serial
 }
 
 #[derive(Error, Debug)]
 pub enum ExecuteError {
     #[error("Bad request: {0}")]
     BadRequest(Error),
-    #[error("Falied to flush: {0}")]
+    #[error("Failed to flush: {0}")]
     Flush(io::Error),
     #[error("Failed to read: {0}")]
     Read(GuestMemoryError),
@@ -303,7 +330,7 @@ impl Request {
         disk: &mut T,
         disk_nsectors: u64,
         mem: &GuestMemoryMmap,
-        disk_id: &[u8],
+        serial: &[u8],
     ) -> result::Result<u32, ExecuteError> {
         disk.seek(SeekFrom::Start(self.sector << SECTOR_SHIFT))
             .map_err(ExecuteError::Seek)?;
@@ -335,10 +362,10 @@ impl Request {
                 }
                 RequestType::Flush => disk.flush().map_err(ExecuteError::Flush)?,
                 RequestType::GetDeviceId => {
-                    if (*data_len as usize) < disk_id.len() {
+                    if (*data_len as usize) < serial.len() {
                         return Err(ExecuteError::BadRequest(Error::InvalidOffset));
                     }
-                    mem.write_slice(disk_id, *data_addr)
+                    mem.write_slice(serial, *data_addr)
                         .map_err(ExecuteError::Write)?;
                 }
                 RequestType::Unsupported(t) => return Err(ExecuteError::Unsupported(t)),
@@ -352,7 +379,7 @@ impl Request {
         mem: &GuestMemoryMmap,
         disk_nsectors: u64,
         disk_image: &mut dyn AsyncIo,
-        disk_id: &[u8],
+        serial: &[u8],
         user_data: u64,
     ) -> result::Result<bool, ExecuteError> {
         let sector = self.sector;
@@ -379,13 +406,13 @@ impl Request {
             let origin_ptr = mem
                 .get_slice(*data_addr, *data_len as usize)
                 .map_err(ExecuteError::GetHostAddress)?
-                .as_ptr();
+                .ptr_guard();
 
             // Verify the buffer alignment.
             // In case it's not properly aligned, an intermediate buffer is
             // created with the correct alignment, and a copy from/to the
             // origin buffer is performed, depending on the type of operation.
-            let iov_base = if (origin_ptr as u64) % SECTOR_SIZE != 0 {
+            let iov_base = if (origin_ptr.as_ptr() as u64) % SECTOR_SIZE != 0 {
                 let layout =
                     Layout::from_size_align(*data_len as usize, SECTOR_SIZE as usize).unwrap();
                 // SAFETY: layout has non-zero size
@@ -401,15 +428,13 @@ impl Request {
                 if request_type == RequestType::Out {
                     // SAFETY: destination buffer has been allocated with
                     // the proper size.
-                    unsafe {
-                        std::ptr::copy(origin_ptr as *const u8, aligned_ptr, *data_len as usize)
-                    };
+                    unsafe { std::ptr::copy(origin_ptr.as_ptr(), aligned_ptr, *data_len as usize) };
                 }
 
                 // Store both origin and aligned pointers for complete_async()
                 // to process them.
                 self.aligned_operations.push(AlignedOperation {
-                    origin_ptr: origin_ptr as u64,
+                    origin_ptr: origin_ptr.as_ptr() as u64,
                     aligned_ptr: aligned_ptr as u64,
                     size: *data_len as usize,
                     layout,
@@ -417,7 +442,7 @@ impl Request {
 
                 aligned_ptr as *mut libc::c_void
             } else {
-                origin_ptr as *mut libc::c_void
+                origin_ptr.as_ptr() as *mut libc::c_void
             };
 
             let iovec = libc::iovec {
@@ -456,10 +481,10 @@ impl Request {
                 } else {
                     return Err(ExecuteError::BadRequest(Error::TooManyDescriptors));
                 };
-                if (data_len as usize) < disk_id.len() {
+                if (data_len as usize) < serial.len() {
                     return Err(ExecuteError::BadRequest(Error::InvalidOffset));
                 }
-                mem.write_slice(disk_id, data_addr)
+                mem.write_slice(serial, data_addr)
                     .map_err(ExecuteError::Write)?;
                 return Ok(false);
             }
@@ -543,50 +568,59 @@ unsafe impl ByteValued for VirtioBlockGeometry {}
 /// Check if io_uring for block device can be used on the current system, as
 /// it correctly supports the expected io_uring features.
 pub fn block_io_uring_is_supported() -> bool {
-    let error_msg = "io_uring not supported:";
+    #[cfg(not(feature = "io_uring"))]
+    {
+        info!("io_uring is disabled by crate features");
+        false
+    }
 
-    // Check we can create an io_uring instance, which effectively verifies
-    // that io_uring_setup() syscall is supported.
-    let io_uring = match IoUring::new(1) {
-        Ok(io_uring) => io_uring,
-        Err(e) => {
-            info!("{} failed to create io_uring instance: {}", error_msg, e);
+    #[cfg(feature = "io_uring")]
+    {
+        let error_msg = "io_uring not supported:";
+
+        // Check we can create an io_uring instance, which effectively verifies
+        // that io_uring_setup() syscall is supported.
+        let io_uring = match IoUring::new(1) {
+            Ok(io_uring) => io_uring,
+            Err(e) => {
+                info!("{} failed to create io_uring instance: {}", error_msg, e);
+                return false;
+            }
+        };
+
+        let submitter = io_uring.submitter();
+
+        let mut probe = Probe::new();
+
+        // Check we can register a probe to validate supported operations.
+        match submitter.register_probe(&mut probe) {
+            Ok(_) => {}
+            Err(e) => {
+                info!("{} failed to register a probe: {}", error_msg, e);
+                return false;
+            }
+        }
+
+        // Check IORING_OP_FSYNC is supported
+        if !probe.is_supported(opcode::Fsync::CODE) {
+            info!("{} IORING_OP_FSYNC operation not supported", error_msg);
             return false;
         }
-    };
 
-    let submitter = io_uring.submitter();
-
-    let mut probe = Probe::new();
-
-    // Check we can register a probe to validate supported operations.
-    match submitter.register_probe(&mut probe) {
-        Ok(_) => {}
-        Err(e) => {
-            info!("{} failed to register a probe: {}", error_msg, e);
+        // Check IORING_OP_READV is supported
+        if !probe.is_supported(opcode::Readv::CODE) {
+            info!("{} IORING_OP_READV operation not supported", error_msg);
             return false;
         }
-    }
 
-    // Check IORING_OP_FSYNC is supported
-    if !probe.is_supported(opcode::Fsync::CODE) {
-        info!("{} IORING_OP_FSYNC operation not supported", error_msg);
-        return false;
-    }
+        // Check IORING_OP_WRITEV is supported
+        if !probe.is_supported(opcode::Writev::CODE) {
+            info!("{} IORING_OP_WRITEV operation not supported", error_msg);
+            return false;
+        }
 
-    // Check IORING_OP_READV is supported
-    if !probe.is_supported(opcode::Readv::CODE) {
-        info!("{} IORING_OP_READV operation not supported", error_msg);
-        return false;
+        true
     }
-
-    // Check IORING_OP_WRITEV is supported
-    if !probe.is_supported(opcode::Writev::CODE) {
-        info!("{} IORING_OP_WRITEV operation not supported", error_msg);
-        return false;
-    }
-
-    true
 }
 
 pub trait AsyncAdaptor<F>
@@ -695,24 +729,33 @@ pub enum ImageType {
 const QCOW_MAGIC: u32 = 0x5146_49fb;
 const VHDX_SIGN: u64 = 0x656C_6966_7864_6876;
 
+/// Read a block into memory aligned by the source block size (needed for O_DIRECT)
+pub fn read_aligned_block_size(f: &mut File) -> std::io::Result<Vec<u8>> {
+    let blocksize = DiskTopology::probe(f)?.logical_block_size as usize;
+    // SAFETY: We are allocating memory that is naturally aligned (size = alignment) and we meet
+    // requirements for safety from Vec::from_raw_parts() as we are using the global allocator
+    // and transferring ownership of the memory.
+    let mut data = unsafe {
+        Vec::from_raw_parts(
+            alloc_zeroed(Layout::from_size_align_unchecked(blocksize, blocksize)),
+            blocksize,
+            blocksize,
+        )
+    };
+    f.read_exact(&mut data)?;
+    Ok(data)
+}
+
 /// Determine image type through file parsing.
 pub fn detect_image_type(f: &mut File) -> std::io::Result<ImageType> {
-    // We must create a buffer aligned on 512 bytes with a size being a
-    // multiple of 512 bytes as the file might be opened with O_DIRECT flag.
-    #[repr(align(512))]
-    struct Sector {
-        data: [u8; 512],
-    }
-    let mut s = Sector { data: [0; 512] };
-
-    f.read_exact(&mut s.data)?;
+    let block = read_aligned_block_size(f)?;
 
     // Check 4 first bytes to get the header value and determine the image type
-    let image_type = if u32::from_be_bytes(s.data[0..4].try_into().unwrap()) == QCOW_MAGIC {
+    let image_type = if u32::from_be_bytes(block[0..4].try_into().unwrap()) == QCOW_MAGIC {
         ImageType::Qcow2
     } else if vhd::is_fixed_vhd(f)? {
         ImageType::FixedVhd
-    } else if u64::from_le_bytes(s.data[0..8].try_into().unwrap()) == VHDX_SIGN {
+    } else if u64::from_le_bytes(block[0..8].try_into().unwrap()) == VHDX_SIGN {
         ImageType::Vhdx
     } else {
         ImageType::Raw
@@ -720,3 +763,108 @@ pub fn detect_image_type(f: &mut File) -> std::io::Result<ImageType> {
 
     Ok(image_type)
 }
+
+pub trait BlockBackend: Read + Write + Seek + Send + Debug {
+    fn size(&self) -> Result<u64, Error>;
+}
+
+/// Inspect the image file type and create an appropriate disk file to match it.
+pub fn create_disk_file(mut file: File, direct_io: bool) -> Result<Box<dyn BlockBackend>, Error> {
+    let image_type = detect_image_type(&mut file).map_err(Error::DetectImageType)?;
+
+    Ok(match image_type {
+        ImageType::Qcow2 => {
+            Box::new(QcowFile::from(RawFile::new(file, direct_io)).map_err(Error::QcowError)?)
+                as Box<dyn BlockBackend>
+        }
+        ImageType::FixedVhd => {
+            Box::new(FixedVhd::new(file).map_err(Error::FixedVhdError)?) as Box<dyn BlockBackend>
+        }
+        ImageType::Vhdx => {
+            Box::new(Vhdx::new(file).map_err(Error::VhdxError)?) as Box<dyn BlockBackend>
+        }
+        ImageType::Raw => Box::new(RawFile::new(file, direct_io)) as Box<dyn BlockBackend>,
+    })
+}
+
+#[derive(Debug)]
+pub struct DiskTopology {
+    pub logical_block_size: u64,
+    pub physical_block_size: u64,
+    pub minimum_io_size: u64,
+    pub optimal_io_size: u64,
+}
+
+impl Default for DiskTopology {
+    fn default() -> Self {
+        Self {
+            logical_block_size: 512,
+            physical_block_size: 512,
+            minimum_io_size: 512,
+            optimal_io_size: 0,
+        }
+    }
+}
+
+ioctl_io_nr!(BLKSSZGET, 0x12, 104);
+ioctl_io_nr!(BLKPBSZGET, 0x12, 123);
+ioctl_io_nr!(BLKIOMIN, 0x12, 120);
+ioctl_io_nr!(BLKIOOPT, 0x12, 121);
+
+enum BlockSize {
+    LogicalBlock,
+    PhysicalBlock,
+    MinimumIo,
+    OptimalIo,
+}
+
+impl DiskTopology {
+    fn is_block_device(f: &File) -> std::io::Result<bool> {
+        let mut stat = std::mem::MaybeUninit::<libc::stat>::uninit();
+        // SAFETY: FFI call with a valid fd and buffer
+        let ret = unsafe { libc::fstat(f.as_raw_fd(), stat.as_mut_ptr()) };
+        if ret != 0 {
+            return Err(std::io::Error::last_os_error());
+        }
+
+        // SAFETY: stat is valid at this point
+        let is_block = unsafe { (*stat.as_ptr()).st_mode & S_IFMT == S_IFBLK };
+        Ok(is_block)
+    }
+
+    // libc::ioctl() takes different types on different architectures
+    fn query_block_size(f: &File, block_size_type: BlockSize) -> std::io::Result<u64> {
+        let mut block_size = 0;
+        // SAFETY: FFI call with correct arguments
+        let ret = unsafe {
+            ioctl(
+                f.as_raw_fd(),
+                match block_size_type {
+                    BlockSize::LogicalBlock => BLKSSZGET(),
+                    BlockSize::PhysicalBlock => BLKPBSZGET(),
+                    BlockSize::MinimumIo => BLKIOMIN(),
+                    BlockSize::OptimalIo => BLKIOOPT(),
+                } as _,
+                &mut block_size,
+            )
+        };
+        if ret != 0 {
+            return Err(std::io::Error::last_os_error());
+        };
+
+        Ok(block_size)
+    }
+
+    pub fn probe(f: &File) -> std::io::Result<Self> {
+        if !Self::is_block_device(f)? {
+            return Ok(DiskTopology::default());
+        }
+
+        Ok(DiskTopology {
+            logical_block_size: Self::query_block_size(f, BlockSize::LogicalBlock)?,
+            physical_block_size: Self::query_block_size(f, BlockSize::PhysicalBlock)?,
+            minimum_io_size: Self::query_block_size(f, BlockSize::MinimumIo)?,
+            optimal_io_size: Self::query_block_size(f, BlockSize::OptimalIo)?,
+        })
+    }
+}

block/src/qcow/mod.rs

@@ -2,40 +2,45 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
-#[macro_use]
-extern crate log;
-
 mod qcow_raw_file;
 mod raw_file;
 mod refcount;
 mod vec_cache;
 
-use crate::qcow_raw_file::QcowRawFile;
-use crate::refcount::RefCount;
-use crate::vec_cache::{CacheMap, Cacheable, VecCache};
+use crate::qcow::{
+    qcow_raw_file::QcowRawFile,
+    refcount::RefCount,
+    vec_cache::{CacheMap, Cacheable, VecCache},
+};
+use crate::BlockBackend;
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use libc::{EINVAL, ENOSPC, ENOTSUP};
 use remain::sorted;
 use std::cmp::{max, min};
 use std::fmt::{self, Display};
+use std::fs::OpenOptions;
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::mem::size_of;
+use std::str;
 use vmm_sys_util::{
     file_traits::FileSetLen, file_traits::FileSync, seek_hole::SeekHole, write_zeroes::PunchHole,
     write_zeroes::WriteZeroesAt,
 };
 
-pub use crate::raw_file::RawFile;
+pub use crate::qcow::raw_file::RawFile;
 
 #[sorted]
 #[derive(Debug)]
 pub enum Error {
-    BackingFilesNotSupported,
+    BackingFileIo(io::Error),
+    BackingFileOpen(Box<crate::Error>),
+    BackingFileTooLong(usize),
     CompressedBlocksNotSupported,
     EvictingCache(io::Error),
     FileTooBig(u64),
     GettingFileSize(io::Error),
     GettingRefcount(refcount::Error),
+    InvalidBackingFileName(str::Utf8Error),
     InvalidClusterIndex,
     InvalidClusterSize,
     InvalidIndex,
@@ -78,12 +83,17 @@ impl Display for Error {
 
         #[sorted]
         match self {
-            BackingFilesNotSupported => write!(f, "backing files not supported"),
+            BackingFileIo(e) => write!(f, "backing file io error: {}", e),
+            BackingFileOpen(e) => write!(f, "backing file open error: {}", *e),
+            BackingFileTooLong(len) => {
+                write!(f, "backing file name is too long: {} bytes over", len)
+            }
             CompressedBlocksNotSupported => write!(f, "compressed blocks not supported"),
             EvictingCache(e) => write!(f, "failed to evict cache: {e}"),
             FileTooBig(size) => write!(f, "file larger than max of {MAX_QCOW_FILE_SIZE}: {size}"),
             GettingFileSize(e) => write!(f, "failed to get file size: {e}"),
             GettingRefcount(e) => write!(f, "failed to get refcount: {e}"),
+            InvalidBackingFileName(e) => write!(f, "failed to parse filename: {}", e),
             InvalidClusterIndex => write!(f, "invalid cluster index"),
             InvalidClusterSize => write!(f, "invalid cluster size"),
             InvalidIndex => write!(f, "invalid index"),
@@ -153,8 +163,14 @@ const COMPRESSED_FLAG: u64 = 1 << 62;
 const CLUSTER_USED_FLAG: u64 = 1 << 63;
 const COMPATIBLE_FEATURES_LAZY_REFCOUNTS: u64 = 1;
 
+// The format supports a "header extension area", that crosvm does not use.
+const QCOW_EMPTY_HEADER_EXTENSION_SIZE: u32 = 8;
+
+// Defined by the specification
+const MAX_BACKING_FILE_SIZE: u32 = 1023;
+
 /// Contains the information from the header of a qcow file.
-#[derive(Copy, Clone, Debug)]
+#[derive(Clone, Debug)]
 pub struct QcowHeader {
     pub magic: u32,
     pub version: u32,
@@ -181,6 +197,9 @@ pub struct QcowHeader {
     pub autoclear_features: u64,
     pub refcount_order: u32,
     pub header_size: u32,
+
+    // Post-header entries
+    pub backing_file_path: Option<String>,
 }
 
 impl QcowHeader {
@@ -204,7 +223,7 @@ impl QcowHeader {
 
         let version = read_u32_from_file(f)?;
 
-        Ok(QcowHeader {
+        let mut header = QcowHeader {
             magic,
             version,
             backing_file_offset: read_u64_from_file(f)?,
@@ -243,24 +262,58 @@ impl QcowHeader {
             } else {
                 read_u32_from_file(f)?
             },
-        })
+            backing_file_path: None,
+        };
+        if header.backing_file_size > MAX_BACKING_FILE_SIZE {
+            return Err(Error::BackingFileTooLong(header.backing_file_size as usize));
+        }
+        if header.backing_file_offset != 0 {
+            f.seek(SeekFrom::Start(header.backing_file_offset))
+                .map_err(Error::ReadingHeader)?;
+            let mut backing_file_name_bytes = vec![0u8; header.backing_file_size as usize];
+            f.read_exact(&mut backing_file_name_bytes)
+                .map_err(Error::ReadingHeader)?;
+            header.backing_file_path = Some(
+                String::from_utf8(backing_file_name_bytes)
+                    .map_err(|err| Error::InvalidBackingFileName(err.utf8_error()))?,
+            );
+        }
+        Ok(header)
     }
 
-    /// Create a header for the given `size`.
-    pub fn create_for_size(version: u32, size: u64) -> QcowHeader {
+    pub fn create_for_size_and_path(
+        version: u32,
+        size: u64,
+        backing_file: Option<&str>,
+    ) -> Result<QcowHeader> {
+        let header_size = if version == 2 {
+            V2_BARE_HEADER_SIZE
+        } else {
+            V3_BARE_HEADER_SIZE + QCOW_EMPTY_HEADER_EXTENSION_SIZE
+        };
         let cluster_bits: u32 = DEFAULT_CLUSTER_BITS;
         let cluster_size: u32 = 0x01 << cluster_bits;
+        let max_length: usize = (cluster_size - header_size) as usize;
+        if let Some(path) = backing_file {
+            if path.len() > max_length {
+                return Err(Error::BackingFileTooLong(path.len() - max_length));
+            }
+        }
         // L2 blocks are always one cluster long. They contain cluster_size/sizeof(u64) addresses.
         let entries_per_cluster: u32 = cluster_size / size_of::<u64>() as u32;
         let num_clusters: u32 = div_round_up_u64(size, u64::from(cluster_size)) as u32;
         let num_l2_clusters: u32 = div_round_up_u32(num_clusters, entries_per_cluster);
         let l1_clusters: u32 = div_round_up_u32(num_l2_clusters, entries_per_cluster);
         let header_clusters = div_round_up_u32(size_of::<QcowHeader>() as u32, cluster_size);
-        QcowHeader {
+        Ok(QcowHeader {
             magic: QCOW_MAGIC,
             version,
-            backing_file_offset: 0,
-            backing_file_size: 0,
+            backing_file_offset: (if backing_file.is_none() {
+                0
+            } else {
+                header_size
+            }) as u64,
+            backing_file_size: backing_file.map_or(0, |x| x.len()) as u32,
             cluster_bits: DEFAULT_CLUSTER_BITS,
             size,
             crypt_method: 0,
@@ -289,12 +342,9 @@ impl QcowHeader {
             compatible_features: 0,
             autoclear_features: 0,
             refcount_order: DEFAULT_REFCOUNT_ORDER,
-            header_size: if version == 2 {
-                V2_BARE_HEADER_SIZE
-            } else {
-                V3_BARE_HEADER_SIZE
-            },
-        }
+            header_size,
+            backing_file_path: backing_file.map(String::from),
+        })
     }
 
     /// Write the header to `file`.
@@ -324,11 +374,20 @@ impl QcowHeader {
         write_u32_to_file(file, self.refcount_table_clusters)?;
         write_u32_to_file(file, self.nb_snapshots)?;
         write_u64_to_file(file, self.snapshots_offset)?;
-        write_u64_to_file(file, self.incompatible_features)?;
-        write_u64_to_file(file, self.compatible_features)?;
-        write_u64_to_file(file, self.autoclear_features)?;
-        write_u32_to_file(file, self.refcount_order)?;
-        write_u32_to_file(file, self.header_size)?;
+
+        if self.version == 3 {
+            write_u64_to_file(file, self.incompatible_features)?;
+            write_u64_to_file(file, self.compatible_features)?;
+            write_u64_to_file(file, self.autoclear_features)?;
+            write_u32_to_file(file, self.refcount_order)?;
+            write_u32_to_file(file, self.header_size)?;
+            write_u32_to_file(file, 0)?; // header extension type: end of header extension area
+            write_u32_to_file(file, 0)?; // length of header extension data: 0
+        }
+
+        if let Some(backing_file_path) = self.backing_file_path.as_ref() {
+            write!(file, "{}", backing_file_path).map_err(Error::WritingHeader)?;
+        }
 
         // Set the file length by seeking and writing a zero to the last byte. This avoids needing
         // a `File` instead of anything that implements seek as the `file` argument.
@@ -362,8 +421,8 @@ fn max_refcount_clusters(refcount_order: u32, cluster_size: u32, num_clusters: u
 /// # Example
 ///
 /// ```
+/// # use block::qcow::{self, QcowFile, RawFile};
 /// # use std::io::{Read, Seek, SeekFrom};
-/// # use qcow::{self, QcowFile, RawFile};
 /// # fn test(file: std::fs::File) -> std::io::Result<()> {
 ///     let mut raw_img = RawFile::new(file, false);
 ///     let mut q = QcowFile::from(raw_img).expect("Can't open qcow file");
@@ -373,7 +432,7 @@ fn max_refcount_clusters(refcount_order: u32, cluster_size: u32, num_clusters: u
 /// #   Ok(())
 /// # }
 /// ```
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct QcowFile {
     raw_file: QcowRawFile,
     header: QcowHeader,
@@ -386,7 +445,7 @@ pub struct QcowFile {
     // List of unreferenced clusters available to be used. unref clusters become available once the
     // removal of references to them have been synced to disk.
     avail_clusters: Vec<u64>,
-    //TODO(dgreid) Add support for backing files. - backing_file: Option<Box<QcowFile<T>>>,
+    backing_file: Option<Box<dyn BlockBackend>>,
 }
 
 impl QcowFile {
@@ -415,10 +474,20 @@ impl QcowFile {
             return Err(Error::FileTooBig(header.size));
         }
 
-        // No current support for backing files.
-        if header.backing_file_offset != 0 {
-            return Err(Error::BackingFilesNotSupported);
-        }
+        let direct_io = file.is_direct();
+
+        let backing_file = if let Some(backing_file_path) = header.backing_file_path.as_ref() {
+            let path = backing_file_path.clone();
+            let backing_raw_file = OpenOptions::new()
+                .read(true)
+                .open(path)
+                .map_err(Error::BackingFileIo)?;
+            let backing_file = crate::create_disk_file(backing_raw_file, direct_io)
+                .map_err(|e| Error::BackingFileOpen(Box::new(e)))?;
+            Some(backing_file)
+        } else {
+            None
+        };
 
         // Only support two byte refcounts.
         let refcount_bits: u64 = 0x01u64
@@ -433,7 +502,6 @@ impl QcowFile {
         if header.refcount_table_clusters == 0 {
             return Err(Error::NoRefcountClusters);
         }
-        offset_is_cluster_boundary(header.backing_file_offset, header.cluster_bits)?;
         offset_is_cluster_boundary(header.l1_table_offset, header.cluster_bits)?;
         offset_is_cluster_boundary(header.snapshots_offset, header.cluster_bits)?;
         // refcount table must be a cluster boundary, and within the file's virtual or actual size.
@@ -466,7 +534,7 @@ impl QcowFile {
         let mut raw_file =
             QcowRawFile::from(file, cluster_size).ok_or(Error::InvalidClusterSize)?;
         if refcount_rebuild_required {
-            QcowFile::rebuild_refcounts(&mut raw_file, header)?;
+            QcowFile::rebuild_refcounts(&mut raw_file, header.clone())?;
         }
 
         let entries_per_cluster = cluster_size / size_of::<u64>() as u64;
@@ -535,6 +603,7 @@ impl QcowFile {
             current_offset: 0,
             unref_clusters: Vec::new(),
             avail_clusters: Vec::new(),
+            backing_file,
         };
 
         // Check that the L1 and refcount tables fit in a 64bit address space.
@@ -553,8 +622,34 @@ impl QcowFile {
     }
 
     /// Creates a new QcowFile at the given path.
-    pub fn new(mut file: RawFile, version: u32, virtual_size: u64) -> Result<QcowFile> {
-        let header = QcowHeader::create_for_size(version, virtual_size);
+    pub fn new(file: RawFile, version: u32, virtual_size: u64) -> Result<QcowFile> {
+        let header = QcowHeader::create_for_size_and_path(version, virtual_size, None)?;
+        QcowFile::new_from_header(file, header)
+    }
+
+    /// Creates a new QcowFile at the given path.
+    pub fn new_from_backing(
+        file: RawFile,
+        version: u32,
+        backing_file_name: &str,
+    ) -> Result<QcowFile> {
+        let direct_io = file.is_direct();
+        let backing_raw_file = OpenOptions::new()
+            .read(true)
+            .open(backing_file_name)
+            .map_err(Error::BackingFileIo)?;
+        let backing_file = crate::create_disk_file(backing_raw_file, direct_io)
+            .map_err(|e| Error::BackingFileOpen(Box::new(e)))?;
+        let size = backing_file
+            .size()
+            .map_err(|e| Error::BackingFileOpen(Box::new(e)))?;
+        let header = QcowHeader::create_for_size_and_path(version, size, Some(backing_file_name))?;
+        let mut result = QcowFile::new_from_header(file, header)?;
+        result.backing_file = Some(backing_file);
+        Ok(result)
+    }
+
+    fn new_from_header(mut file: RawFile, header: QcowHeader) -> Result<QcowFile> {
         file.rewind().map_err(Error::SeekingFile)?;
         header.write_to(&mut file)?;
 
@@ -578,6 +673,10 @@ impl QcowFile {
         Ok(qcow)
     }
 
+    pub fn set_backing_file(&mut self, backing: Option<Box<dyn BlockBackend>>) {
+        self.backing_file = backing;
+    }
+
     /// Returns the `QcowHeader` for this file.
     pub fn header(&self) -> &QcowHeader {
         &self.header
@@ -890,9 +989,9 @@ impl QcowFile {
 
         // Find all references clusters and rebuild refcounts.
         set_header_refcount(&mut refcounts, cluster_size)?;
-        set_l1_refcounts(&mut refcounts, header, cluster_size)?;
-        set_data_refcounts(&mut refcounts, header, cluster_size, raw_file)?;
-        set_refcount_table_refcounts(&mut refcounts, header, cluster_size)?;
+        set_l1_refcounts(&mut refcounts, header.clone(), cluster_size)?;
+        set_data_refcounts(&mut refcounts, header.clone(), cluster_size, raw_file)?;
+        set_refcount_table_refcounts(&mut refcounts, header.clone(), cluster_size)?;
 
         // Allocate clusters to store the new reference count blocks.
         let ref_table = alloc_refblocks(&mut refcounts, cluster_size, refblock_clusters)?;
@@ -1007,7 +1106,7 @@ impl QcowFile {
             let l2_table = if l2_addr_disk == 0 {
                 // Allocate a new cluster to store the L2 table and update the L1 table to point
                 // to the new table.
-                let new_addr: u64 = self.get_new_cluster()?;
+                let new_addr: u64 = self.get_new_cluster(None)?;
                 // The cluster refcount starts at one meaning it is used but doesn't need COW.
                 set_refcounts.push((new_addr, 1));
                 self.l1_table[l1_index] = new_addr;
@@ -1028,8 +1127,18 @@ impl QcowFile {
 
         let cluster_addr = match self.l2_cache.get(l1_index).unwrap()[l2_index] {
             0 => {
+                let initial_data = if let Some(backing) = self.backing_file.as_mut() {
+                    let cluster_size = self.raw_file.cluster_size();
+                    let cluster_begin = address - (address % cluster_size);
+                    let mut cluster_data = vec![0u8; cluster_size as usize];
+                    backing.seek(SeekFrom::Start(cluster_begin))?;
+                    backing.read_exact(&mut cluster_data)?;
+                    Some(cluster_data)
+                } else {
+                    None
+                };
                 // Need to allocate a data cluster
-                let cluster_addr = self.append_data_cluster()?;
+                let cluster_addr = self.append_data_cluster(initial_data)?;
                 self.update_cluster_addr(l1_index, l2_index, cluster_addr, &mut set_refcounts)?;
                 cluster_addr
             }
@@ -1066,7 +1175,7 @@ impl QcowFile {
             // Allocate a new cluster to store the L2 table and update the L1 table to point
             // to the new table. The cluster will be written when the cache is flushed, no
             // need to copy the data now.
-            let new_addr: u64 = self.get_new_cluster()?;
+            let new_addr: u64 = self.get_new_cluster(None)?;
             // The cluster refcount starts at one indicating it is used but doesn't need
             // COW.
             set_refcounts.push((new_addr, 1));
@@ -1078,15 +1187,22 @@ impl QcowFile {
     }
 
     // Allocate a new cluster and return its offset within the raw file.
-    fn get_new_cluster(&mut self) -> std::io::Result<u64> {
+    fn get_new_cluster(&mut self, initial_data: Option<Vec<u8>>) -> std::io::Result<u64> {
         // First use a pre allocated cluster if one is available.
         if let Some(free_cluster) = self.avail_clusters.pop() {
-            self.raw_file.zero_cluster(free_cluster)?;
+            if let Some(initial_data) = initial_data {
+                self.raw_file.write_cluster(free_cluster, initial_data)?;
+            } else {
+                self.raw_file.zero_cluster(free_cluster)?;
+            }
             return Ok(free_cluster);
         }
 
         let max_valid_cluster_offset = self.refcounts.max_valid_cluster_offset();
         if let Some(new_cluster) = self.raw_file.add_cluster_end(max_valid_cluster_offset)? {
+            if let Some(initial_data) = initial_data {
+                self.raw_file.write_cluster(new_cluster, initial_data)?;
+            }
             Ok(new_cluster)
         } else {
             error!("No free clusters in get_new_cluster()");
@@ -1096,8 +1212,8 @@ impl QcowFile {
 
     // Allocate and initialize a new data cluster. Returns the offset of the
     // cluster in to the file on success.
-    fn append_data_cluster(&mut self) -> std::io::Result<u64> {
-        let new_addr: u64 = self.get_new_cluster()?;
+    fn append_data_cluster(&mut self, initial_data: Option<Vec<u8>>) -> std::io::Result<u64> {
+        let new_addr: u64 = self.get_new_cluster(initial_data)?;
         // The cluster refcount starts at one indicating it is used but doesn't need COW.
         let mut newly_unref = self.set_cluster_refcount(new_addr, 1)?;
         self.unref_clusters.append(&mut newly_unref);
@@ -1331,7 +1447,7 @@ impl QcowFile {
                 }
                 Err(refcount::Error::NeedNewCluster) => {
                     // Allocate the cluster and call set_cluster_refcount again.
-                    let addr = self.get_new_cluster()?;
+                    let addr = self.get_new_cluster(None)?;
                     added_clusters.push(addr);
                     new_cluster = Some((
                         addr,
@@ -1414,6 +1530,9 @@ impl Read for QcowFile {
                 self.raw_file
                     .file_mut()
                     .read_exact(&mut buf[nread..(nread + count)])?;
+            } else if let Some(backing) = self.backing_file.as_mut() {
+                backing.seek(SeekFrom::Start(curr_addr))?;
+                backing.read_exact(&mut buf[nread..(nread + count)])?;
             } else {
                 // Previously unwritten region, return zeros
                 for b in &mut buf[nread..(nread + count)] {
@@ -1556,6 +1675,12 @@ impl SeekHole for QcowFile {
     }
 }
 
+impl BlockBackend for QcowFile {
+    fn size(&self) -> std::result::Result<u64, crate::Error> {
+        Ok(self.virtual_size())
+    }
+}
+
 // Returns an Error if the given offset doesn't align to a cluster boundary.
 fn offset_is_cluster_boundary(offset: u64, cluster_bits: u32) -> Result<()> {
     if offset & ((0x01 << cluster_bits) - 1) != 0 {
@@ -1766,16 +1891,19 @@ mod tests {
         ]
     }
 
-    fn with_basic_file<F>(header: &[u8], mut testfn: F)
-    where
-        F: FnMut(RawFile),
-    {
+    fn basic_file(header: &[u8]) -> RawFile {
         let mut disk_file: RawFile = RawFile::new(TempFile::new().unwrap().into_file(), false);
         disk_file.write_all(header).unwrap();
         disk_file.set_len(0x1_0000_0000).unwrap();
         disk_file.rewind().unwrap();
+        disk_file
+    }
 
-        testfn(disk_file); // File closed when the function exits.
+    fn with_basic_file<F>(header: &[u8], mut testfn: F)
+    where
+        F: FnMut(RawFile),
+    {
+        testfn(basic_file(header)); // File closed when the function exits.
     }
 
     fn with_default_file<F>(file_size: u64, direct: bool, mut testfn: F)
@@ -1788,11 +1916,44 @@ mod tests {
         testfn(qcow_file); // File closed when the function exits.
     }
 
+    #[test]
+    fn write_read_start_backing_v2() {
+        let disk_file = basic_file(&valid_header_v2());
+        let mut backing = QcowFile::from(disk_file).unwrap();
+        backing
+            .write_all(b"test first bytes")
+            .expect("Failed to write test string.");
+        let mut buf = [0u8; 4];
+        let wrapping_disk_file = basic_file(&valid_header_v2());
+        let mut wrapping = QcowFile::from(wrapping_disk_file).unwrap();
+        wrapping.set_backing_file(Some(Box::new(backing)));
+        wrapping.seek(SeekFrom::Start(0)).expect("Failed to seek.");
+        wrapping.read_exact(&mut buf).expect("Failed to read.");
+        assert_eq!(&buf, b"test");
+    }
+
+    #[test]
+    fn write_read_start_backing_v3() {
+        let disk_file = basic_file(&valid_header_v3());
+        let mut backing = QcowFile::from(disk_file).unwrap();
+        backing
+            .write_all(b"test first bytes")
+            .expect("Failed to write test string.");
+        let mut buf = [0u8; 4];
+        let wrapping_disk_file = basic_file(&valid_header_v3());
+        let mut wrapping = QcowFile::from(wrapping_disk_file).unwrap();
+        wrapping.set_backing_file(Some(Box::new(backing)));
+        wrapping.seek(SeekFrom::Start(0)).expect("Failed to seek.");
+        wrapping.read_exact(&mut buf).expect("Failed to read.");
+        assert_eq!(&buf, b"test");
+    }
+
     #[test]
     fn default_header_v2() {
-        let header = QcowHeader::create_for_size(2, 0x10_0000);
+        let header = QcowHeader::create_for_size_and_path(2, 0x10_0000, None);
         let mut disk_file: RawFile = RawFile::new(TempFile::new().unwrap().into_file(), false);
         header
+            .expect("Failed to create header.")
             .write_to(&mut disk_file)
             .expect("Failed to write header to temporary file.");
         disk_file.rewind().unwrap();
@@ -1801,9 +1962,10 @@ mod tests {
 
     #[test]
     fn default_header_v3() {
-        let header = QcowHeader::create_for_size(3, 0x10_0000);
+        let header = QcowHeader::create_for_size_and_path(3, 0x10_0000, None);
         let mut disk_file: RawFile = RawFile::new(TempFile::new().unwrap().into_file(), false);
         header
+            .expect("Failed to create header.")
             .write_to(&mut disk_file)
             .expect("Failed to write header to temporary file.");
         disk_file.rewind().unwrap();
@@ -1826,6 +1988,40 @@ mod tests {
         });
     }
 
+    #[test]
+    fn header_v2_with_backing() {
+        let header = QcowHeader::create_for_size_and_path(2, 0x10_0000, Some("/my/path/to/a/file"))
+            .expect("Failed to create header.");
+        let mut disk_file: RawFile = RawFile::new(TempFile::new().unwrap().into_file(), false);
+        header
+            .write_to(&mut disk_file)
+            .expect("Failed to write header to shm.");
+        disk_file.rewind().unwrap();
+        let read_header = QcowHeader::new(&mut disk_file).expect("Failed to create header.");
+        assert_eq!(
+            header.backing_file_path,
+            Some(String::from("/my/path/to/a/file"))
+        );
+        assert_eq!(read_header.backing_file_path, header.backing_file_path);
+    }
+
+    #[test]
+    fn header_v3_with_backing() {
+        let header = QcowHeader::create_for_size_and_path(3, 0x10_0000, Some("/my/path/to/a/file"))
+            .expect("Failed to create header.");
+        let mut disk_file: RawFile = RawFile::new(TempFile::new().unwrap().into_file(), false);
+        header
+            .write_to(&mut disk_file)
+            .expect("Failed to write header to shm.");
+        disk_file.rewind().unwrap();
+        let read_header = QcowHeader::new(&mut disk_file).expect("Failed to create header.");
+        assert_eq!(
+            header.backing_file_path,
+            Some(String::from("/my/path/to/a/file"))
+        );
+        assert_eq!(read_header.backing_file_path, header.backing_file_path);
+    }
+
     #[test]
     fn invalid_magic() {
         let invalid_header = vec![0x51u8, 0x46, 0x4a, 0xfb];
@@ -1940,6 +2136,26 @@ mod tests {
         });
     }
 
+    #[test]
+    fn write_read_start_backing_overlap() {
+        let disk_file = basic_file(&valid_header_v3());
+        let mut backing = QcowFile::from(disk_file).unwrap();
+        backing
+            .write_all(b"test first bytes")
+            .expect("Failed to write test string.");
+        let wrapping_disk_file = basic_file(&valid_header_v3());
+        let mut wrapping = QcowFile::from(wrapping_disk_file).unwrap();
+        wrapping.set_backing_file(Some(Box::new(backing)));
+        wrapping.seek(SeekFrom::Start(0)).expect("Failed to seek.");
+        wrapping
+            .write_all(b"TEST")
+            .expect("Failed to write second test string.");
+        let mut buf = [0u8; 10];
+        wrapping.seek(SeekFrom::Start(0)).expect("Failed to seek.");
+        wrapping.read_exact(&mut buf).expect("Failed to read.");
+        assert_eq!(&buf, b"TEST first");
+    }
+
     #[test]
     fn offset_write_read() {
         with_basic_file(&valid_header_v3(), |disk_file: RawFile| {

block/src/qcow/qcow_raw_file.rs

@@ -4,7 +4,7 @@
 
 use super::RawFile;
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
-use std::io::{self, BufWriter, Seek, SeekFrom};
+use std::io::{self, BufWriter, Seek, SeekFrom, Write};
 use std::mem::size_of;
 use vmm_sys_util::write_zeroes::WriteZeroes;
 
@@ -137,6 +137,13 @@ impl QcowRawFile {
         self.file.write_zeroes(cluster_size)?;
         Ok(())
     }
+
+    /// Writes
+    pub fn write_cluster(&mut self, address: u64, data: Vec<u8>) -> io::Result<()> {
+        let cluster_size = self.cluster_size as usize;
+        self.file.seek(SeekFrom::Start(address))?;
+        self.file.write_all(&data[0..cluster_size])
+    }
 }
 
 impl Clone for QcowRawFile {

block/src/qcow/raw_file.rs

@@ -8,6 +8,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
+use crate::BlockBackend;
 use libc::c_void;
 use std::alloc::{alloc_zeroed, dealloc, Layout};
 use std::convert::TryInto;
@@ -22,6 +23,7 @@ pub struct RawFile {
     file: File,
     alignment: usize,
     position: u64,
+    direct_io: bool,
 }
 
 const BLK_ALIGNMENTS: [usize; 2] = [512, 4096];
@@ -64,6 +66,7 @@ impl RawFile {
             file,
             alignment,
             position: 0,
+            direct_io,
         }
     }
 
@@ -102,6 +105,7 @@ impl RawFile {
             file: self.file.try_clone().expect("RawFile cloning failed"),
             alignment: self.alignment,
             position: self.position,
+            direct_io: self.direct_io,
         })
     }
 
@@ -112,6 +116,10 @@ impl RawFile {
     pub fn sync_data(&self) -> std::io::Result<()> {
         self.file.sync_data()
     }
+
+    pub fn is_direct(&self) -> bool {
+        self.direct_io
+    }
 }
 
 impl Read for RawFile {
@@ -343,12 +351,19 @@ impl SeekHole for RawFile {
     }
 }
 
+impl BlockBackend for RawFile {
+    fn size(&self) -> std::result::Result<u64, crate::Error> {
+        Ok(self.metadata().map_err(crate::Error::RawFileError)?.len())
+    }
+}
+
 impl Clone for RawFile {
     fn clone(&self) -> Self {
         RawFile {
             file: self.file.try_clone().expect("RawFile cloning failed"),
             alignment: self.alignment,
             position: self.position,
+            direct_io: self.direct_io,
         }
     }
 }

block/src/qcow/refcount.rs

@@ -7,8 +7,10 @@ use std::io;
 
 use libc::EINVAL;
 
-use crate::qcow_raw_file::QcowRawFile;
-use crate::vec_cache::{CacheMap, Cacheable, VecCache};
+use crate::qcow::{
+    qcow_raw_file::QcowRawFile,
+    vec_cache::{CacheMap, Cacheable, VecCache},
+};
 
 #[derive(Debug)]
 pub enum Error {

block/src/qcow_sync.rs

@@ -3,8 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
 use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
+use crate::qcow::{QcowFile, RawFile, Result as QcowResult};
 use crate::AsyncAdaptor;
-use qcow::{QcowFile, RawFile, Result as QcowResult};
 use std::collections::VecDeque;
 use std::fs::File;
 use std::io::{Seek, SeekFrom};

block/src/raw_async.rs

@@ -3,8 +3,9 @@
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
 use crate::async_io::{
-    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult, DiskTopology,
+    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
 };
+use crate::DiskTopology;
 use io_uring::{opcode, squeue, types, IoUring};
 use std::fs::File;
 use std::io::{Seek, SeekFrom};
@@ -36,7 +37,7 @@ impl DiskFile for RawFileDisk {
     }
 
     fn topology(&mut self) -> DiskTopology {
-        if let Ok(topology) = DiskTopology::probe(&mut self.file) {
+        if let Ok(topology) = DiskTopology::probe(&self.file) {
             topology
         } else {
             warn!("Unable to get device topology. Using default topology");
@@ -86,7 +87,7 @@ impl AsyncIo for RawFileAsync {
         let _ = unsafe {
             sq.push(
                 &opcode::Readv::new(types::Fd(self.fd), iovecs.as_ptr(), iovecs.len() as u32)
-                    .offset(offset)
+                    .offset(offset.try_into().unwrap())
                     .build()
                     .flags(squeue::Flags::ASYNC)
                     .user_data(user_data),
@@ -114,7 +115,7 @@ impl AsyncIo for RawFileAsync {
         let _ = unsafe {
             sq.push(
                 &opcode::Writev::new(types::Fd(self.fd), iovecs.as_ptr(), iovecs.len() as u32)
-                    .offset(offset)
+                    .offset(offset.try_into().unwrap())
                     .build()
                     .flags(squeue::Flags::ASYNC)
                     .user_data(user_data),

block/src/raw_sync.rs

@@ -3,8 +3,9 @@
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
 use crate::async_io::{
-    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult, DiskTopology,
+    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
 };
+use crate::DiskTopology;
 use std::collections::VecDeque;
 use std::fs::File;
 use std::io::{Seek, SeekFrom};
@@ -33,7 +34,7 @@ impl DiskFile for RawFileDiskSync {
     }
 
     fn topology(&mut self) -> DiskTopology {
-        if let Ok(topology) = DiskTopology::probe(&mut self.file) {
+        if let Ok(topology) = DiskTopology::probe(&self.file) {
             topology
         } else {
             warn!("Unable to get device topology. Using default topology");
@@ -73,7 +74,7 @@ impl AsyncIo for RawFileSync {
         let result = unsafe {
             libc::preadv(
                 self.fd as libc::c_int,
-                iovecs.as_ptr() as *const libc::iovec,
+                iovecs.as_ptr(),
                 iovecs.len() as libc::c_int,
                 offset,
             )
@@ -98,7 +99,7 @@ impl AsyncIo for RawFileSync {
         let result = unsafe {
             libc::pwritev(
                 self.fd as libc::c_int,
-                iovecs.as_ptr() as *const libc::iovec,
+                iovecs.as_ptr(),
                 iovecs.len() as libc::c_int,
                 offset,
             )

block/src/vhd.rs

@@ -2,9 +2,10 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::{read_aligned_block_size, DiskTopology};
 use std::convert::TryInto;
 use std::fs::File;
-use std::io::{Read, Seek, SeekFrom};
+use std::io::{Seek, SeekFrom};
 
 #[derive(Clone, Copy)]
 pub struct VhdFooter {
@@ -27,37 +28,33 @@ pub struct VhdFooter {
 
 impl VhdFooter {
     pub fn new(file: &mut File) -> std::io::Result<VhdFooter> {
-        // We must create a buffer aligned on 512 bytes with a size being a
-        // multiple of 512 bytes as the file might be opened with O_DIRECT flag.
-        #[repr(align(512))]
-        struct Sector {
-            data: [u8; 512],
-        }
-        let mut s = Sector { data: [0; 512] };
+        let blocksize = DiskTopology::probe(file)?.logical_block_size as usize;
 
-        // Place the cursor 512 bytes before the end of the file, as this is
-        // where the footer starts.
-        file.seek(SeekFrom::End(-512))?;
+        // Place the cursor in the last block of the file
+        file.seek(SeekFrom::End(0 - (blocksize as i64)))?;
+        // Read in the last block
+        let data = read_aligned_block_size(file)?;
 
-        // Fill in the VhdFooter structure
-        file.read_exact(&mut s.data)?;
+        // We only care about the last sector
+        let offset = blocksize - 512;
+        let sector = &data[offset..];
 
         Ok(VhdFooter {
-            cookie: u64::from_be_bytes(s.data[0..8].try_into().unwrap()),
-            features: u32::from_be_bytes(s.data[8..12].try_into().unwrap()),
-            file_format_version: u32::from_be_bytes(s.data[12..16].try_into().unwrap()),
-            data_offset: u64::from_be_bytes(s.data[16..24].try_into().unwrap()),
-            time_stamp: u32::from_be_bytes(s.data[24..28].try_into().unwrap()),
-            creator_application: u32::from_be_bytes(s.data[28..32].try_into().unwrap()),
-            creator_version: u32::from_be_bytes(s.data[32..36].try_into().unwrap()),
-            creator_host_os: u32::from_be_bytes(s.data[36..40].try_into().unwrap()),
-            original_size: u64::from_be_bytes(s.data[40..48].try_into().unwrap()),
-            current_size: u64::from_be_bytes(s.data[48..56].try_into().unwrap()),
-            disk_geometry: u32::from_be_bytes(s.data[56..60].try_into().unwrap()),
-            disk_type: u32::from_be_bytes(s.data[60..64].try_into().unwrap()),
-            checksum: u32::from_be_bytes(s.data[64..68].try_into().unwrap()),
-            unique_id: u128::from_be_bytes(s.data[68..84].try_into().unwrap()),
-            saved_state: u8::from_be_bytes(s.data[84..85].try_into().unwrap()),
+            cookie: u64::from_be_bytes(sector[0..8].try_into().unwrap()),
+            features: u32::from_be_bytes(sector[8..12].try_into().unwrap()),
+            file_format_version: u32::from_be_bytes(sector[12..16].try_into().unwrap()),
+            data_offset: u64::from_be_bytes(sector[16..24].try_into().unwrap()),
+            time_stamp: u32::from_be_bytes(sector[24..28].try_into().unwrap()),
+            creator_application: u32::from_be_bytes(sector[28..32].try_into().unwrap()),
+            creator_version: u32::from_be_bytes(sector[32..36].try_into().unwrap()),
+            creator_host_os: u32::from_be_bytes(sector[36..40].try_into().unwrap()),
+            original_size: u64::from_be_bytes(sector[40..48].try_into().unwrap()),
+            current_size: u64::from_be_bytes(sector[48..56].try_into().unwrap()),
+            disk_geometry: u32::from_be_bytes(sector[56..60].try_into().unwrap()),
+            disk_type: u32::from_be_bytes(sector[60..64].try_into().unwrap()),
+            checksum: u32::from_be_bytes(sector[64..68].try_into().unwrap()),
+            unique_id: u128::from_be_bytes(sector[68..84].try_into().unwrap()),
+            saved_state: u8::from_be_bytes(sector[84..85].try_into().unwrap()),
         })
     }
 

block/src/vhdx/mod.rs

@@ -2,15 +2,31 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhdx_bat::{BatEntry, VhdxBatError};
-use crate::vhdx_header::{self, RegionInfo, RegionTableEntry, VhdxHeader, VhdxHeaderError};
-use crate::vhdx_io::{self, VhdxIoError};
-use crate::vhdx_metadata::{DiskSpec, VhdxMetadataError};
+use crate::vhdx::{
+    vhdx_bat::{BatEntry, VhdxBatError},
+    vhdx_header::{RegionInfo, RegionTableEntry, VhdxHeader, VhdxHeaderError},
+    vhdx_io::VhdxIoError,
+    vhdx_metadata::{DiskSpec, VhdxMetadataError},
+};
+use crate::BlockBackend;
+use byteorder::{BigEndian, ByteOrder};
 use remain::sorted;
 use std::collections::btree_map::BTreeMap;
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom, Write};
 use thiserror::Error;
+use uuid::Uuid;
+
+macro_rules! div_round_up {
+    ($n:expr,$d:expr) => {
+        ($n + $d - 1) / $d
+    };
+}
+
+mod vhdx_bat;
+mod vhdx_header;
+mod vhdx_io;
+mod vhdx_metadata;
 
 #[sorted]
 #[derive(Error, Debug)]
@@ -193,6 +209,12 @@ impl Seek for Vhdx {
     }
 }
 
+impl BlockBackend for Vhdx {
+    fn size(&self) -> std::result::Result<u64, crate::Error> {
+        Ok(self.virtual_disk_size())
+    }
+}
+
 impl Clone for Vhdx {
     fn clone(&self) -> Self {
         Vhdx {
@@ -208,3 +230,15 @@ impl Clone for Vhdx {
         }
     }
 }
+
+pub(crate) fn uuid_from_guid(buf: &[u8]) -> Uuid {
+    // The first 3 fields of UUID are stored in Big Endian format, and
+    // the last 8 bytes are stored as byte array. Therefore, we read the
+    // first 3 fields in Big Endian format instead of Little Endian.
+    Uuid::from_fields_le(
+        BigEndian::read_u32(&buf[0..4]),
+        BigEndian::read_u16(&buf[4..6]),
+        BigEndian::read_u16(&buf[6..8]),
+        buf[8..16].try_into().unwrap(),
+    )
+}

block/src/vhdx/vhdx_bat.rs

@@ -2,8 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhdx_header::RegionTableEntry;
-use crate::vhdx_metadata::DiskSpec;
+use crate::vhdx::{vhdx_header::RegionTableEntry, vhdx_metadata::DiskSpec};
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 use remain::sorted;
 use std::fs::File;

block/src/vhdx/vhdx_header.rs

@@ -81,7 +81,7 @@ pub enum VhdxHeaderError {
     SeekRegionTableEntries(#[source] io::Error),
     #[error("Failed to seek in region table header {0}")]
     SeekRegionTableHeader(#[source] io::Error),
-    #[error("We do not recongize this entry")]
+    #[error("We do not recognize this entry")]
     UnrecognizedRegionEntry,
     #[error("Failed to write header {0}")]
     WriteHeader(#[source] io::Error),
@@ -305,7 +305,7 @@ impl RegionInfo {
 
             if (entry.required & REGION_ENTRY_REQUIRED) == 1 {
                 // This implementation doesn't recognize this field.
-                // Therefore, accoding to the spec, we are throwing an error.
+                // Therefore, according to the spec, we are throwing an error.
                 return Err(VhdxHeaderError::UnrecognizedRegionEntry);
             }
         }
@@ -344,7 +344,7 @@ impl RegionTableEntry {
         // SAFETY: the assertion above makes sure the buffer size is correct.
         let mut region_table_entry = unsafe { *(buffer.as_ptr() as *mut RegionTableEntry) };
 
-        let uuid = crate::uuid_from_guid(buffer);
+        let uuid = crate::vhdx::uuid_from_guid(buffer);
         region_table_entry.guid = uuid;
 
         Ok(region_table_entry)
@@ -444,7 +444,7 @@ impl VhdxHeader {
         }
     }
 
-    // Update the provided headers accoding to the spec
+    // Update the provided headers according to the spec
     fn update_headers(
         f: &mut File,
         header_1: Result<Header>,
@@ -468,7 +468,7 @@ impl VhdxHeader {
     }
 }
 
-/// Calculates the checksum of a buffer that itself containts its checksum
+/// Calculates the checksum of a buffer that itself contains its checksum
 /// Therefore, before calculating, the existing checksum is retrieved and the
 /// corresponding field is made zero. After the calculation, the existing checksum
 /// is put back to the buffer.

block/src/vhdx/vhdx_io.rs

@@ -2,8 +2,10 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhdx_bat::{self, BatEntry, VhdxBatError};
-use crate::vhdx_metadata::{self, DiskSpec};
+use crate::vhdx::{
+    vhdx_bat::{self, BatEntry, VhdxBatError},
+    vhdx_metadata::{self, DiskSpec},
+};
 use remain::sorted;
 use std::fs::File;
 use std::io::{self, Read, Seek, SeekFrom, Write};

block/src/vhdx/vhdx_metadata.rs

@@ -2,7 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhdx_header::RegionTableEntry;
+use crate::vhdx::vhdx_header::RegionTableEntry;
 use byteorder::{LittleEndian, ReadBytesExt};
 use remain::sorted;
 use std::fs::File;
@@ -96,7 +96,7 @@ pub struct DiskSpec {
 }
 
 impl DiskSpec {
-    /// Parse all meatadata from the provided file and store info in DiskSpec
+    /// Parse all metadata from the provided file and store info in DiskSpec
     /// structure.
     pub fn new(f: &mut File, metadata_region: &RegionTableEntry) -> Result<DiskSpec> {
         let mut disk_spec = DiskSpec::default();
@@ -133,7 +133,7 @@ impl DiskSpec {
                     .map_err(VhdxMetadataError::ReadMetadata)?;
 
                 // MUST be at least 1 MiB and not greater than 256 MiB
-                if disk_spec.block_size < BLOCK_SIZE_MIN && disk_spec.block_size > BLOCK_SIZE_MAX {
+                if disk_spec.block_size < BLOCK_SIZE_MIN || disk_spec.block_size > BLOCK_SIZE_MAX {
                     return Err(VhdxMetadataError::InvalidBlockSize);
                 }
 
@@ -303,7 +303,7 @@ impl MetadataTableEntry {
         // SAFETY: the assertion above makes sure the buffer size is correct.
         let mut metadata_table_entry = unsafe { *(buffer.as_ptr() as *mut MetadataTableEntry) };
 
-        let uuid = crate::uuid_from_guid(buffer);
+        let uuid = crate::vhdx::uuid_from_guid(buffer);
         metadata_table_entry.item_id = uuid;
 
         if metadata_table_entry.length > METADATA_LENGTH_MAX {

block/src/vhdx_sync.rs

@@ -3,11 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
+use crate::vhdx::{Result as VhdxResult, Vhdx};
 use crate::AsyncAdaptor;
 use std::collections::VecDeque;
 use std::fs::File;
 use std::sync::{Arc, Mutex, MutexGuard};
-use vhdx::vhdx::{Result as VhdxResult, Vhdx};
 use vmm_sys_util::eventfd::EventFd;
 
 pub struct VhdxDiskSync {

block_util/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "block_util"
-version = "0.1.0"
-authors = ["The Cloud Hypervisor Authors"]
-edition = "2021"
-
-[features]
-default = []
-
-[dependencies]
-io-uring = "0.5.13"
-libc = "0.2.139"
-log = "0.4.17"
-qcow = { path = "../qcow" }
-smallvec = "1.10.0"
-thiserror = "1.0.40"
-versionize = "0.1.10"
-versionize_derive = "0.1.4"
-vhdx = { path = "../vhdx" }
-virtio-bindings = { version = "0.2.0", features = ["virtio-v5_0_0"] }
-virtio-queue = "0.8.0"
-vm-memory = { version = "0.11.0", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
-vm-virtio = { path = "../vm-virtio" }
-vmm-sys-util = "0.11.0"
-

block_util/src/async_io.rs

@@ -1,145 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use libc::{ioctl, S_IFBLK, S_IFMT};
-use std::fs::File;
-use std::os::unix::io::AsRawFd;
-use thiserror::Error;
-use vmm_sys_util::eventfd::EventFd;
-use vmm_sys_util::{ioctl_io_nr, ioctl_ioc_nr};
-
-#[derive(Error, Debug)]
-pub enum DiskFileError {
-    /// Failed getting disk file size.
-    #[error("Failed getting disk file size: {0}")]
-    Size(#[source] std::io::Error),
-    /// Failed creating a new AsyncIo.
-    #[error("Failed creating a new AsyncIo: {0}")]
-    NewAsyncIo(#[source] std::io::Error),
-}
-
-#[derive(Debug)]
-pub struct DiskTopology {
-    pub logical_block_size: u64,
-    pub physical_block_size: u64,
-    pub minimum_io_size: u64,
-    pub optimal_io_size: u64,
-}
-
-impl Default for DiskTopology {
-    fn default() -> Self {
-        Self {
-            logical_block_size: 512,
-            physical_block_size: 512,
-            minimum_io_size: 512,
-            optimal_io_size: 0,
-        }
-    }
-}
-
-ioctl_io_nr!(BLKSSZGET, 0x12, 104);
-ioctl_io_nr!(BLKPBSZGET, 0x12, 123);
-ioctl_io_nr!(BLKIOMIN, 0x12, 120);
-ioctl_io_nr!(BLKIOOPT, 0x12, 121);
-
-enum BlockSize {
-    LogicalBlock,
-    PhysicalBlock,
-    MinimumIo,
-    OptimalIo,
-}
-
-impl DiskTopology {
-    fn is_block_device(f: &mut File) -> std::io::Result<bool> {
-        let mut stat = std::mem::MaybeUninit::<libc::stat>::uninit();
-        // SAFETY: FFI call with a valid fd and buffer
-        let ret = unsafe { libc::fstat(f.as_raw_fd(), stat.as_mut_ptr()) };
-        if ret != 0 {
-            return Err(std::io::Error::last_os_error());
-        }
-
-        // SAFETY: stat is valid at this point
-        let is_block = unsafe { (*stat.as_ptr()).st_mode & S_IFMT == S_IFBLK };
-        Ok(is_block)
-    }
-
-    // libc::ioctl() takes different types on different architectures
-    fn query_block_size(f: &mut File, block_size_type: BlockSize) -> std::io::Result<u64> {
-        let mut block_size = 0;
-        // SAFETY: FFI call with correct arguments
-        let ret = unsafe {
-            ioctl(
-                f.as_raw_fd(),
-                match block_size_type {
-                    BlockSize::LogicalBlock => BLKSSZGET(),
-                    BlockSize::PhysicalBlock => BLKPBSZGET(),
-                    BlockSize::MinimumIo => BLKIOMIN(),
-                    BlockSize::OptimalIo => BLKIOOPT(),
-                } as _,
-                &mut block_size,
-            )
-        };
-        if ret != 0 {
-            return Err(std::io::Error::last_os_error());
-        };
-
-        Ok(block_size)
-    }
-
-    pub fn probe(f: &mut File) -> std::io::Result<Self> {
-        if !Self::is_block_device(f)? {
-            return Ok(DiskTopology::default());
-        }
-
-        Ok(DiskTopology {
-            logical_block_size: Self::query_block_size(f, BlockSize::LogicalBlock)?,
-            physical_block_size: Self::query_block_size(f, BlockSize::PhysicalBlock)?,
-            minimum_io_size: Self::query_block_size(f, BlockSize::MinimumIo)?,
-            optimal_io_size: Self::query_block_size(f, BlockSize::OptimalIo)?,
-        })
-    }
-}
-
-pub type DiskFileResult<T> = std::result::Result<T, DiskFileError>;
-
-pub trait DiskFile: Send {
-    fn size(&mut self) -> DiskFileResult<u64>;
-    fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>>;
-    fn topology(&mut self) -> DiskTopology {
-        DiskTopology::default()
-    }
-}
-
-#[derive(Error, Debug)]
-pub enum AsyncIoError {
-    /// Failed vectored reading from file.
-    #[error("Failed vectored reading from file: {0}")]
-    ReadVectored(#[source] std::io::Error),
-    /// Failed vectored writing to file.
-    #[error("Failed vectored writing to file: {0}")]
-    WriteVectored(#[source] std::io::Error),
-    /// Failed synchronizing file.
-    #[error("Failed synchronizing file: {0}")]
-    Fsync(#[source] std::io::Error),
-}
-
-pub type AsyncIoResult<T> = std::result::Result<T, AsyncIoError>;
-
-pub trait AsyncIo: Send {
-    fn notifier(&self) -> &EventFd;
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()>;
-    fn write_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()>;
-    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()>;
-    fn next_completed_request(&mut self) -> Option<(u64, i32)>;
-}

devices/Cargo.toml

@@ -6,19 +6,22 @@ edition = "2021"
 
 [dependencies]
 acpi_tables = { git = "https://github.com/rust-vmm/acpi_tables", branch = "main"  }
-anyhow = "1.0.71"
+anyhow = "1.0.75"
 arch = { path = "../arch" }
 bitflags = "2.3.3"
 byteorder = "1.4.3"
+event_monitor = { path = "../event_monitor" }
 hypervisor = { path = "../hypervisor" }
-libc = "0.2.139"
+libc = "0.2.147"
 log = "0.4.17"
+pci = { path = "../pci" }
 thiserror = "1.0.40"
 tpm = { path = "../tpm" }
 versionize = "0.1.10"
 versionize_derive = "0.1.4"
+vm-allocator = { path = "../vm-allocator" }
 vm-device = { path = "../vm-device" }
-vm-memory = "0.11.0"
+vm-memory = "0.12.2"
 vm-migration = { path = "../vm-migration" }
 vmm-sys-util = "0.11.0"
 

devices/src/acpi.rs

@@ -5,7 +5,9 @@
 
 use super::AcpiNotificationFlags;
 use acpi_tables::{aml, Aml, AmlSink};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Barrier};
+use std::thread;
 use std::time::Instant;
 use vm_device::interrupt::InterruptSourceGroup;
 use vm_device::BusDevice;
@@ -18,14 +20,20 @@ pub const GED_DEVICE_ACPI_SIZE: usize = 0x1;
 pub struct AcpiShutdownDevice {
     exit_evt: EventFd,
     reset_evt: EventFd,
+    vcpus_kill_signalled: Arc<AtomicBool>,
 }
 
 impl AcpiShutdownDevice {
     /// Constructs a device that will signal the given event when the guest requests it.
-    pub fn new(exit_evt: EventFd, reset_evt: EventFd) -> AcpiShutdownDevice {
+    pub fn new(
+        exit_evt: EventFd,
+        reset_evt: EventFd,
+        vcpus_kill_signalled: Arc<AtomicBool>,
+    ) -> AcpiShutdownDevice {
         AcpiShutdownDevice {
             exit_evt,
             reset_evt,
+            vcpus_kill_signalled,
         }
     }
 }
@@ -43,6 +51,13 @@ impl BusDevice for AcpiShutdownDevice {
             if let Err(e) = self.reset_evt.write(1) {
                 error!("Error triggering ACPI reset event: {}", e);
             }
+            // Spin until we are sure the reset_evt has been handled and that when
+            // we return from the KVM_RUN we will exit rather than re-enter the guest.
+            while !self.vcpus_kill_signalled.load(Ordering::SeqCst) {
+                // This is more effective than thread::yield_now() at
+                // avoiding a priority inversion with the VMM thread
+                thread::sleep(std::time::Duration::from_millis(1));
+            }
         }
         // The ACPI DSDT table specifies the S5 sleep state (shutdown) as value 5
         const S5_SLEEP_VALUE: u8 = 5;
@@ -53,6 +68,13 @@ impl BusDevice for AcpiShutdownDevice {
             if let Err(e) = self.exit_evt.write(1) {
                 error!("Error triggering ACPI shutdown event: {}", e);
             }
+            // Spin until we are sure the reset_evt has been handled and that when
+            // we return from the KVM_RUN we will exit rather than re-enter the guest.
+            while !self.vcpus_kill_signalled.load(Ordering::SeqCst) {
+                // This is more effective than thread::yield_now() at
+                // avoiding a priority inversion with the VMM thread
+                thread::sleep(std::time::Duration::from_millis(1));
+            }
         }
         None
     }
@@ -112,7 +134,7 @@ impl Aml for AcpiGedDevice {
                 &aml::Name::new(
                     "_CRS".into(),
                     &aml::ResourceTemplate::new(vec![&aml::AddressSpace::new_memory(
-                        aml::AddressSpaceCachable::NotCacheable,
+                        aml::AddressSpaceCacheable::NotCacheable,
                         true,
                         self.address.0,
                         self.address.0 + GED_DEVICE_ACPI_SIZE as u64 - 1,

devices/src/gic.rs

@@ -27,7 +27,7 @@ pub const IRQ_LEGACY_BASE: usize = layout::IRQ_BASE as usize;
 pub const IRQ_LEGACY_COUNT: usize = 32;
 pub const GIC_SNAPSHOT_ID: &str = "gic-v3-its";
 
-// Gic (Generic Interupt Controller) struct provides all the functionality of a
+// Gic (Generic Interrupt Controller) struct provides all the functionality of a
 // GIC device. It wraps a hypervisor-emulated GIC device (Vgic) provided by the
 // `hypervisor` crate.
 // Gic struct also implements InterruptController to provide interrupt delivery
@@ -98,9 +98,14 @@ impl Gic {
                     i as InterruptIndex,
                     InterruptSourceConfig::LegacyIrq(config),
                     false,
+                    false,
                 )
                 .map_err(Error::EnableInterrupt)?;
         }
+
+        self.interrupt_source_group
+            .set_gsi()
+            .map_err(Error::EnableInterrupt)?;
         Ok(())
     }
 

devices/src/ioapic.rs

@@ -237,9 +237,14 @@ impl Ioapic {
         if state.is_some() {
             for (irq, entry) in ioapic.used_entries.iter().enumerate() {
                 if *entry {
-                    ioapic.update_entry(irq)?;
+                    ioapic.update_entry(irq, false)?;
                 }
             }
+
+            ioapic
+                .interrupt_source_group
+                .set_gsi()
+                .map_err(Error::UpdateInterrupt)?;
         }
 
         Ok(ioapic)
@@ -278,7 +283,7 @@ impl Ioapic {
                 }
                 // The entry must be updated through the interrupt source
                 // group.
-                if let Err(e) = self.update_entry(index) {
+                if let Err(e) = self.update_entry(index, true) {
                     error!("Failed updating IOAPIC entry: {:?}", e);
                 }
                 // Store the information this IRQ is now being used.
@@ -329,7 +334,7 @@ impl Ioapic {
         }
     }
 
-    fn update_entry(&self, irq: usize) -> Result<()> {
+    fn update_entry(&self, irq: usize, set_gsi: bool) -> Result<()> {
         let entry = self.reg_entries[irq];
 
         // Validate Destination Mode value, and retrieve Destination ID
@@ -386,6 +391,7 @@ impl Ioapic {
                 irq as InterruptIndex,
                 InterruptSourceConfig::MsiIrq(config),
                 interrupt_mask(entry) == 1,
+                set_gsi,
             )
             .map_err(Error::UpdateInterrupt)?;
 

devices/src/legacy/cmos.rs

@@ -5,7 +5,9 @@
 use libc::{clock_gettime, gmtime_r, timespec, tm, CLOCK_REALTIME};
 use std::cmp::min;
 use std::mem;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Barrier};
+use std::thread;
 use vm_device::BusDevice;
 use vmm_sys_util::eventfd::EventFd;
 
@@ -23,13 +25,19 @@ pub struct Cmos {
     index: u8,
     data: [u8; DATA_LEN],
     reset_evt: EventFd,
+    vcpus_kill_signalled: Option<Arc<AtomicBool>>,
 }
 
 impl Cmos {
     /// Constructs a CMOS/RTC device with initial data.
     /// `mem_below_4g` is the size of memory in bytes below the 32-bit gap.
     /// `mem_above_4g` is the size of memory in bytes above the 32-bit gap.
-    pub fn new(mem_below_4g: u64, mem_above_4g: u64, reset_evt: EventFd) -> Cmos {
+    pub fn new(
+        mem_below_4g: u64,
+        mem_above_4g: u64,
+        reset_evt: EventFd,
+        vcpus_kill_signalled: Option<Arc<AtomicBool>>,
+    ) -> Cmos {
         let mut data = [0u8; DATA_LEN];
 
         // Extended memory from 16 MB to 4 GB in units of 64 KB
@@ -50,6 +58,7 @@ impl Cmos {
             index: 0,
             data,
             reset_evt,
+            vcpus_kill_signalled,
         }
     }
 }
@@ -67,6 +76,15 @@ impl BusDevice for Cmos {
                 if self.index == 0x8f && data[0] == 0 {
                     info!("CMOS reset");
                     self.reset_evt.write(1).unwrap();
+                    if let Some(vcpus_kill_signalled) = self.vcpus_kill_signalled.take() {
+                        // Spin until we are sure the reset_evt has been handled and that when
+                        // we return from the KVM_RUN we will exit rather than re-enter the guest.
+                        while !vcpus_kill_signalled.load(Ordering::SeqCst) {
+                            // This is more effective than thread::yield_now() at
+                            // avoiding a priority inversion with the VMM thread
+                            thread::sleep(std::time::Duration::from_millis(1));
+                        }
+                    }
                 } else {
                     self.data[(self.index & INDEX_MASK) as usize] = data[0]
                 }

devices/src/legacy/gpio_pl061.rs

@@ -31,7 +31,7 @@ const GPIOIC: u64 = 0x41c; // Interrupt Clear Register
 const GPIOAFSEL: u64 = 0x420; // Mode Control Select Register
                               // From 0x424 to 0xFDC => reserved space.
                               // From 0xFE0 to 0xFFC => Peripheral and PrimeCell Identification Registers which are Read Only registers.
-                              // Thses registers can conceptually be treated as a 32-bit register, and PartNumber[11:0] is used to identify the peripheral.
+                              // These registers can conceptually be treated as a 32-bit register, and PartNumber[11:0] is used to identify the peripheral.
                               // We are putting the expected values (look at 'Reset value' column from above mentioned document) in an array.
 const GPIO_ID: [u8; 8] = [0x61, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1];
 // ID Margins
@@ -57,7 +57,7 @@ impl fmt::Display for Error {
                 write!(f, "Could not trigger GPIO interrupt: {e}.")
             }
             Error::GpioTriggerKeyFailure(key) => {
-                write!(f, "Invalid GPIO Input key triggerd: {key}.")
+                write!(f, "Invalid GPIO Input key triggered: {key}.")
             }
         }
     }
@@ -361,10 +361,15 @@ mod tests {
             _index: InterruptIndex,
             _config: InterruptSourceConfig,
             _masked: bool,
+            _set_gsi: bool,
         ) -> result::Result<(), std::io::Error> {
             Ok(())
         }
 
+        fn set_gsi(&self) -> result::Result<(), std::io::Error> {
+            Ok(())
+        }
+
         fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
             Some(self.event_fd.try_clone().unwrap())
         }

devices/src/legacy/i8042.rs

@@ -2,19 +2,27 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
-use std::sync::{Arc, Barrier};
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc, Barrier,
+};
+use std::thread;
 use vm_device::BusDevice;
 use vmm_sys_util::eventfd::EventFd;
 
 /// A i8042 PS/2 controller that emulates just enough to shutdown the machine.
 pub struct I8042Device {
     reset_evt: EventFd,
+    vcpus_kill_signalled: Arc<AtomicBool>,
 }
 
 impl I8042Device {
     /// Constructs a i8042 device that will signal the given event when the guest requests it.
-    pub fn new(reset_evt: EventFd) -> I8042Device {
-        I8042Device { reset_evt }
+    pub fn new(reset_evt: EventFd, vcpus_kill_signalled: Arc<AtomicBool>) -> I8042Device {
+        I8042Device {
+            reset_evt,
+            vcpus_kill_signalled,
+        }
     }
 }
 
@@ -38,6 +46,13 @@ impl BusDevice for I8042Device {
             if let Err(e) = self.reset_evt.write(1) {
                 error!("Error triggering i8042 reset event: {}", e);
             }
+            // Spin until we are sure the reset_evt has been handled and that when
+            // we return from the KVM_RUN we will exit rather than re-enter the guest.
+            while !self.vcpus_kill_signalled.load(Ordering::SeqCst) {
+                // This is more effective than thread::yield_now() at
+                // avoiding a priority inversion with the VMM thread
+                thread::sleep(std::time::Duration::from_millis(1));
+            }
         }
 
         None

devices/src/legacy/rtc_pl031.rs

@@ -413,10 +413,15 @@ mod tests {
             _index: InterruptIndex,
             _config: InterruptSourceConfig,
             _masked: bool,
+            _set_gsi: bool,
         ) -> result::Result<(), std::io::Error> {
             Ok(())
         }
 
+        fn set_gsi(&self) -> result::Result<(), std::io::Error> {
+            Ok(())
+        }
+
         fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
             Some(self.event_fd.try_clone().unwrap())
         }

devices/src/legacy/serial.rs

@@ -365,9 +365,13 @@ mod tests {
             _index: InterruptIndex,
             _config: InterruptSourceConfig,
             _masked: bool,
+            _set_gsi: bool,
         ) -> result::Result<(), std::io::Error> {
             Ok(())
         }
+        fn set_gsi(&self) -> result::Result<(), std::io::Error> {
+            Ok(())
+        }
         fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
             Some(self.event_fd.try_clone().unwrap())
         }

devices/src/legacy/uart_pl011.rs

@@ -485,9 +485,13 @@ mod tests {
             _index: InterruptIndex,
             _config: InterruptSourceConfig,
             _masked: bool,
+            _set_gsi: bool,
         ) -> result::Result<(), std::io::Error> {
             Ok(())
         }
+        fn set_gsi(&self) -> result::Result<(), std::io::Error> {
+            Ok(())
+        }
         fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
             Some(self.event_fd.try_clone().unwrap())
         }

devices/src/lib.rs

@@ -10,6 +10,8 @@
 #[macro_use]
 extern crate bitflags;
 #[macro_use]
+extern crate event_monitor;
+#[macro_use]
 extern crate log;
 
 pub mod acpi;
@@ -19,9 +21,11 @@ pub mod interrupt_controller;
 #[cfg(target_arch = "x86_64")]
 pub mod ioapic;
 pub mod legacy;
+pub mod pvpanic;
 pub mod tpm;
 
 pub use self::acpi::{AcpiGedDevice, AcpiPmTimerDevice, AcpiShutdownDevice};
+pub use self::pvpanic::{PvPanicDevice, PVPANIC_DEVICE_MMIO_SIZE};
 
 bitflags! {
     pub struct AcpiNotificationFlags: u8 {

devices/src/pvpanic.rs

@@ -0,0 +1,272 @@
+// Copyright © 2023 Tencent Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+use anyhow::anyhow;
+use pci::{
+    BarReprogrammingParams, PciBarConfiguration, PciBarPrefetchable, PciBarRegionType,
+    PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType, PciSubclass,
+    PCI_CONFIGURATION_ID,
+};
+use std::any::Any;
+use std::result;
+use std::sync::{Arc, Barrier, Mutex};
+use thiserror::Error;
+use versionize::{VersionMap, Versionize, VersionizeResult};
+use versionize_derive::Versionize;
+use vm_allocator::{AddressAllocator, SystemAllocator};
+use vm_device::{BusDevice, Resource};
+use vm_memory::{Address, GuestAddress};
+use vm_migration::{
+    Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable, VersionMapped,
+};
+
+const PVPANIC_VENDOR_ID: u16 = 0x1b36;
+const PVPANIC_DEVICE_ID: u16 = 0x0011;
+
+pub const PVPANIC_DEVICE_MMIO_SIZE: u64 = 0x2;
+pub const PVPANIC_DEVICE_MMIO_ALIGNMENT: u64 = 0x10;
+
+const PVPANIC_PANICKED: u8 = 1 << 0;
+const PVPANIC_CRASH_LOADED: u8 = 1 << 1;
+
+#[derive(Debug, Error)]
+pub enum PvPanicError {
+    #[error("Failed creating PvPanicDevice: {0}")]
+    CreatePvPanicDevice(#[source] anyhow::Error),
+    #[error("Failed to retrieve PciConfigurationState: {0}")]
+    RetrievePciConfigurationState(#[source] anyhow::Error),
+}
+
+#[derive(Copy, Clone)]
+enum PvPanicSubclass {
+    Other = 0x80,
+}
+
+impl PciSubclass for PvPanicSubclass {
+    fn get_register_value(&self) -> u8 {
+        *self as u8
+    }
+}
+
+/// A device for handling guest panic event
+pub struct PvPanicDevice {
+    id: String,
+    events: u8,
+
+    // PCI configuration registers.
+    configuration: PciConfiguration,
+    bar_regions: Vec<PciBarConfiguration>,
+}
+
+#[derive(Versionize)]
+pub struct PvPanicDeviceState {
+    events: u8,
+}
+
+impl VersionMapped for PvPanicDeviceState {}
+
+impl PvPanicDevice {
+    pub fn new(id: String, snapshot: Option<Snapshot>) -> Result<Self, PvPanicError> {
+        let pci_configuration_state =
+            vm_migration::versioned_state_from_id(snapshot.as_ref(), PCI_CONFIGURATION_ID)
+                .map_err(|e| {
+                    PvPanicError::RetrievePciConfigurationState(anyhow!(
+                        "Failed to get PciConfigurationState from Snapshot: {}",
+                        e
+                    ))
+                })?;
+
+        let mut configuration = PciConfiguration::new(
+            PVPANIC_VENDOR_ID,
+            PVPANIC_DEVICE_ID,
+            0x1, // modern pci devices
+            PciClassCode::BaseSystemPeripheral,
+            &PvPanicSubclass::Other,
+            None,
+            PciHeaderType::Device,
+            0,
+            0,
+            None,
+            pci_configuration_state,
+        );
+
+        let command: [u8; 2] = [0x03, 0x01];
+        configuration.write_config_register(1, 0, &command);
+
+        let state: Option<PvPanicDeviceState> = snapshot
+            .as_ref()
+            .map(|s| s.to_versioned_state())
+            .transpose()
+            .map_err(|e| {
+                PvPanicError::CreatePvPanicDevice(anyhow!(
+                    "Failed to get PvPanicDeviceState from Snapshot: {}",
+                    e
+                ))
+            })?;
+        let events = if let Some(state) = state {
+            state.events
+        } else {
+            PVPANIC_PANICKED | PVPANIC_CRASH_LOADED
+        };
+
+        let pvpanic_device = PvPanicDevice {
+            id,
+            events,
+            configuration,
+            bar_regions: vec![],
+        };
+
+        Ok(pvpanic_device)
+    }
+
+    pub fn event_to_string(&self, event: u8) -> String {
+        if event == PVPANIC_PANICKED {
+            "panic".to_string()
+        } else if event == PVPANIC_CRASH_LOADED {
+            "crash_loaded".to_string()
+        } else {
+            "unknown_event".to_string()
+        }
+    }
+
+    fn state(&self) -> PvPanicDeviceState {
+        PvPanicDeviceState {
+            events: self.events,
+        }
+    }
+
+    pub fn config_bar_addr(&self) -> u64 {
+        self.configuration.get_bar_addr(0)
+    }
+}
+
+impl BusDevice for PvPanicDevice {
+    fn read(&mut self, base: u64, offset: u64, data: &mut [u8]) {
+        self.read_bar(base, offset, data)
+    }
+
+    fn write(&mut self, _base: u64, _offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
+        let event = self.event_to_string(data[0]);
+        info!("pvpanic got guest event {}", event);
+        event!("guest", "panic", "event", &event);
+        None
+    }
+}
+
+impl PciDevice for PvPanicDevice {
+    fn write_config_register(
+        &mut self,
+        reg_idx: usize,
+        offset: u64,
+        data: &[u8],
+    ) -> Option<Arc<Barrier>> {
+        self.configuration
+            .write_config_register(reg_idx, offset, data);
+        None
+    }
+
+    fn read_config_register(&mut self, reg_idx: usize) -> u32 {
+        self.configuration.read_reg(reg_idx)
+    }
+
+    fn detect_bar_reprogramming(
+        &mut self,
+        reg_idx: usize,
+        data: &[u8],
+    ) -> Option<BarReprogrammingParams> {
+        self.configuration.detect_bar_reprogramming(reg_idx, data)
+    }
+
+    fn allocate_bars(
+        &mut self,
+        allocator: &Arc<Mutex<SystemAllocator>>,
+        _mmio_allocator: &mut AddressAllocator,
+        resources: Option<Vec<Resource>>,
+    ) -> std::result::Result<Vec<PciBarConfiguration>, PciDeviceError> {
+        let mut bars = Vec::new();
+        let region_type = PciBarRegionType::Memory32BitRegion;
+        let bar_id = 0;
+        let region_size = PVPANIC_DEVICE_MMIO_SIZE;
+        let restoring = resources.is_some();
+        let bar_addr = allocator
+            .lock()
+            .unwrap()
+            .allocate_mmio_hole_addresses(None, region_size, Some(PVPANIC_DEVICE_MMIO_ALIGNMENT))
+            .ok_or(PciDeviceError::IoAllocationFailed(region_size))?;
+
+        let bar = PciBarConfiguration::default()
+            .set_index(bar_id as usize)
+            .set_address(bar_addr.raw_value())
+            .set_size(region_size)
+            .set_region_type(region_type)
+            .set_prefetchable(PciBarPrefetchable::NotPrefetchable);
+
+        debug!("pvpanic bar address 0x{:x}", bar_addr.0);
+        if !restoring {
+            self.configuration
+                .add_pci_bar(&bar)
+                .map_err(|e| PciDeviceError::IoRegistrationFailed(bar_addr.raw_value(), e))?;
+        }
+
+        bars.push(bar);
+        self.bar_regions = bars.clone();
+
+        Ok(bars)
+    }
+
+    fn free_bars(
+        &mut self,
+        allocator: &mut SystemAllocator,
+        _mmio_allocator: &mut AddressAllocator,
+    ) -> std::result::Result<(), PciDeviceError> {
+        for bar in self.bar_regions.drain(..) {
+            allocator.free_mmio_hole_addresses(GuestAddress(bar.addr()), bar.size());
+        }
+
+        Ok(())
+    }
+
+    fn move_bar(&mut self, old_base: u64, new_base: u64) -> result::Result<(), std::io::Error> {
+        for bar in self.bar_regions.iter_mut() {
+            if bar.addr() == old_base {
+                *bar = bar.set_address(new_base);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn read_bar(&mut self, _base: u64, _offset: u64, data: &mut [u8]) {
+        data[0] = self.events;
+    }
+
+    fn as_any(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    fn id(&self) -> Option<String> {
+        Some(self.id.clone())
+    }
+}
+
+impl Pausable for PvPanicDevice {}
+
+impl Snapshottable for PvPanicDevice {
+    fn id(&self) -> String {
+        self.id.clone()
+    }
+
+    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
+        let mut snapshot = Snapshot::new_from_versioned_state(&self.state())?;
+
+        // Snapshot PciConfiguration
+        snapshot.add_snapshot(self.configuration.id(), self.configuration.snapshot()?);
+
+        Ok(snapshot)
+    }
+}
+
+impl Transportable for PvPanicDevice {}
+impl Migratable for PvPanicDevice {}

docs/amd_sev_snp.md

@@ -0,0 +1,38 @@
+# AMD SEV-SNP
+
+### WARNING
+This feature is only currently supported on MSHV.
+
+AMD Secure Encrypted Virtualization & Secure Nested Paging (SEV-SNP) is an AMD
+technology designed to add strong memory integrity protection to help prevent
+malicious hypervisor-based attacks like data replay, memory-remapping and more
+in order to create an isolated execution environment. Here are some useful
+links:
+
+* [SNP Homepage] (https://www.amd.com/en/processors/amd-secure-encrypted-virtualization)
+more information about SEV-SNP technical aspects, design and specification.
+
+## Cloud Hypervisor support
+
+It is required to use a machine which has enabled support for AMD SEV-SNP in
+the BIOS.
+
+On the Cloud Hypervisor side, all you need is to build the project with the
+`sev_snp` feature enabled:
+
+```bash
+cargo build --no-default-features --features "sev_snp"
+```
+
+**Note**
+Please note that `sev_snp` cannot be enabled in conjunction with `tdx` feature flag.
+
+You can run a SEV-SNP VM using the following command:
+
+```bash
+./cloud-hypervisor \
+     --platform sev_snp=on \
+     --cpus boot=1 \
+     --memory size=1G \
+     --disk path=ubuntu.img
+```

docs/api.md

@@ -206,11 +206,14 @@ curl --unix-socket /tmp/cloud-hypervisor.sock -i -X PUT 'http://localhost/api/v1
 
 ### D-Bus API
 
-Cloud Hypervisor offers a D-Bus API as an alternative to its REST API. As of
-writing this document, the D-Bus API mirrors the functionality of the REST
-API and shares the same set of endpoints, meaning that it supports every call
-that is supported by the REST API and can be a drop-in replacement since it
-also consumes/produces JSON.
+Cloud Hypervisor offers a D-Bus API as an alternative to its REST API. This
+D-Bus API fully reflects the functionality of the REST API, exposing the
+same group of endpoints. It can be a drop-in replacement since it also
+consumes/produces JSON.
+
+In addition, the D-Bus API also exposes events from `event-monitor` in the
+form of a D-Bus signal to which users can subscribe. For more information,
+see [D-Bus API Interface](#d-bus-api-interface).
 
 #### D-Bus API Location and availability
 
@@ -245,8 +248,23 @@ which in turn can be used to control and manage Cloud Hypervisor.
 
 #### D-Bus API Interface
 
-Please refer to the [REST API](#rest-api) documentation. As previously
-mentioned, the D-Bus API currently mirrors the behaviour of the REST API.
+Please refer to the [REST API](#rest-api) documentation for everything that
+is in common with the REST API. As previously mentioned, the D-Bus API can
+be used as a drop-in replacement for the [REST API](#rest-api).
+
+The D-Bus interface also exposes a signal, named `Event`, which is emitted
+whenever a new event is published from the `event-monitor` crate. Here is its
+definition in XML format:
+
+```xml
+<node>
+  <interface name="org.cloudhypervisor.DBusApi1">
+    <signal name="Event">
+      <arg name="event" type="s"/>
+    </signal>
+  </interface>
+</node>
+```
 
 ### Command Line Interface
 

docs/intel_tdx.md

@@ -47,12 +47,15 @@ The custom Linux kernel for the guest can be built with the [TDX Tools](https://
 The firmware can be built as follows:
 
 ```bash
+sudo apt-get update
+sudo apt-get install uuid-dev nasm iasl build-essential python3-distutils git
+
 git clone https://github.com/tianocore/edk2.git
 cd edk2
 git checkout 13b97736c876919b9786055829caaa4fa46984b7
-git submodule update --init --recursive
-make -C BaseTools
 source ./edksetup.sh
+git submodule update --init --recursive
+make -C BaseTools -j `nproc`
 build -p OvmfPkg/IntelTdx/IntelTdxX64.dsc -a X64 -t GCC5 -b RELEASE
 ```
 

docs/logging.md

@@ -7,13 +7,13 @@ The target audience of this document is both:
 
 ## Control
 
-The number of `-v` parameters passed to the `cloud-hypervisor` binary will determine the log level. Currenly the default is log messages up to `WARN:` (`warn!`) are included by default. The `--log-file` allows the log to be sent to a location other than `stderr`.
+The number of `-v` parameters passed to the `cloud-hypervisor` binary will determine the log level. Currently the default is log messages up to `WARN:` (`warn!`) are included by default. The `--log-file` allows the log to be sent to a location other than `stderr`.
 
 ## Levels
 
 ### `error!()`
 
-For immediate, unrecoverable errors where it does not make sense for the execution to continue as the behaviour of the VM is considerablely impacted.
+For immediate, unrecoverable errors where it does not make sense for the execution to continue as the behaviour of the VM is considerably impacted.
 
 Cloud Hypervisor should exit shortly after reporting this error (with a non-zero exit code). Generally this should be used during initial construction of the VM state before the virtual CPUs have begun running code.
 
@@ -23,7 +23,7 @@ Users should react to this error by checking their initial VM configuration.
 
 ### `warn!()`
 
-A serious problem has occured but the execution of the VM can continue although some functionality might be impacted.
+A serious problem has occurred but the execution of the VM can continue although some functionality might be impacted.
 
 A typical example of where this level of message should be generated is during an API call request that cannot be fulfilled.
 

docs/memory.md

@@ -222,7 +222,7 @@ struct MemoryZoneConfig {
 --memory-zone <memory-zone>	User defined memory zone parameters "size=<guest_memory_region_size>,file=<backing_file>,shared=on|off,hugepages=on|off,hugepage_size=<hugepage_size>,host_numa_node=<node_id>,id=<zone_identifier>,hotplug_size=<hotpluggable_memory_size>,hotplugged_size=<hotplugged_memory_size>,prefault=on|off"
 ```
 
-This parameter expects one or more occurences, allowing for a list of memory
+This parameter expects one or more occurrences, allowing for a list of memory
 zones to be defined. It must be used with `--memory size=0`, clearly indicating
 that the memory will be described through advanced parameters.
 

docs/tracing.md

@@ -1,6 +1,6 @@
 # Tracing
 
-Cloud Hypervisor has a basic tracing infrastucture, particularly focussed on
+Cloud Hypervisor has a basic tracing infrastructure, particularly focussed on
 the tracing of the initial VM setup.
 
 ## Usage

docs/windows.md

@@ -135,7 +135,7 @@ This section illustrates the Windows specific aspects of the VM network configur
 
 ### Basic Networking
 
-As the simplest option, using `--net tap=` in the Cloud Hypervisor command line will create a `vmtapX` device on the host with the default IPv4 adress `192.168.249.1`. After SAC becomes available, the guest configuration can be set with
+As the simplest option, using `--net tap=` in the Cloud Hypervisor command line will create a `vmtapX` device on the host with the default IPv4 address `192.168.249.1`. After SAC becomes available, the guest configuration can be set with
 
 <pre>
 SAC>i 10 192.168.249.2 255.255.255.0 192.168.249.1
@@ -203,13 +203,13 @@ The Windows guest debugging process relies heavily on QEMU and [socat](http://ww
 
 The connection between both guests happens over TCP, whereby on the guest side it is automatically translated to a COM port. Because the VMs are connected through TCP, the debugging infrastructure can be distributed over the network. The serial port, while slowly transferring data, is common enough to support a wide range of cases and tools.
 
-In this excercise, [WinDbg](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/) is used. Any other debugger of choice with the ability to use serial connection can be used instead. 
+In this exercise, [WinDbg](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/) is used. Any other debugger of choice with the ability to use serial connection can be used instead. 
 
 ### Debugger and Debuggee
 
 #### WinDbg VM
 
-For simplicity, the debugger VM is supposed to be only running under QEMU. It will require VGA and doesn't neccessarily depend on UEFI. As an OS, it can carry any supported Windows OS where the debugger of choice can be installed. The simplest way is to follow the image preparation instructions from the previous chapter, but avoid using the OVMF firmware. It is also not required to use VirtIO drivers, whereby it might be useful in some case. Though, while creating the image file for the debugger VM, be sure to choose a sufficient disk size that counts in the need to save the corresponding debug symbols and sources.
+For simplicity, the debugger VM is supposed to be only running under QEMU. It will require VGA and doesn't necessarily depend on UEFI. As an OS, it can carry any supported Windows OS where the debugger of choice can be installed. The simplest way is to follow the image preparation instructions from the previous chapter, but avoid using the OVMF firmware. It is also not required to use VirtIO drivers, whereby it might be useful in some case. Though, while creating the image file for the debugger VM, be sure to choose a sufficient disk size that counts in the need to save the corresponding debug symbols and sources.
 
 To create the debugger Windows VM, the following command can be used:
 
@@ -244,7 +244,7 @@ This will configure the debugging to be enabled and instruct to use the serial p
 bcdedit /dbgsettings serial debugport:1 baudrate:115200
 ```
 
-##### Turn On Kernel Debuging
+##### Turn On Kernel Debugging
 
 ```cmd
 bcdedit /debug on

event_monitor/Cargo.toml

@@ -5,6 +5,8 @@ authors = ["The Cloud Hypervisor Authors"]
 edition = "2021"
 
 [dependencies]
-libc = "0.2.139"
-serde = { version = "1.0.164", features = ["rc", "derive"] }
-serde_json = "1.0.96"
+flume = "0.10.14"
+libc = "0.2.147"
+once_cell = "1.18.0"
+serde = { version = "1.0.168", features = ["rc", "derive"] }
+serde_json = "1.0.107"

event_monitor/src/lib.rs

@@ -3,37 +3,17 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+use once_cell::sync::OnceCell;
 use serde::Serialize;
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fs::File;
-use std::io::Write;
+use std::io;
 use std::os::unix::io::AsRawFd;
+use std::sync::Arc;
 use std::time::{Duration, Instant};
 
-static mut MONITOR: Option<(File, Instant)> = None;
-
-/// This function must only be called once from the main process before any threads
-/// are created to avoid race conditions
-pub fn set_monitor(file: File) -> Result<(), std::io::Error> {
-    // SAFETY: there is only one caller of this function, so MONITOR is written to only once
-    assert!(unsafe { MONITOR.is_none() });
-    let fd = file.as_raw_fd();
-    // SAFETY: FFI call to configure the fd
-    let ret = unsafe {
-        let mut flags = libc::fcntl(fd, libc::F_GETFL);
-        flags |= libc::O_NONBLOCK;
-        libc::fcntl(fd, libc::F_SETFL, flags)
-    };
-    if ret < 0 {
-        return Err(std::io::Error::last_os_error());
-    }
-    // SAFETY: MONITOR is None. Nobody else can hold a reference to it.
-    unsafe {
-        MONITOR = Some((file, Instant::now()));
-    };
-    Ok(())
-}
+static MONITOR: OnceCell<MonitorHandle> = OnceCell::new();
 
 #[derive(Serialize)]
 struct Event<'a> {
@@ -43,19 +23,88 @@ struct Event<'a> {
     properties: Option<&'a HashMap<Cow<'a, str>, Cow<'a, str>>>,
 }
 
+pub struct Monitor {
+    pub rx: flume::Receiver<String>,
+    pub file: Option<File>,
+    pub broadcast: Vec<flume::Sender<Arc<String>>>,
+}
+
+impl Monitor {
+    pub fn new(rx: flume::Receiver<String>, file: Option<File>) -> Self {
+        Self {
+            rx,
+            file,
+            broadcast: vec![],
+        }
+    }
+
+    pub fn subscribe(&mut self) -> flume::Receiver<Arc<String>> {
+        let (tx, rx) = flume::unbounded();
+        self.broadcast.push(tx);
+        rx
+    }
+}
+
+struct MonitorHandle {
+    tx: flume::Sender<String>,
+    start: Instant,
+}
+
+fn set_file_nonblocking(file: &File) -> io::Result<()> {
+    let fd = file.as_raw_fd();
+
+    // SAFETY: FFI call to configure the fd
+    let ret = unsafe {
+        let mut flags = libc::fcntl(fd, libc::F_GETFL);
+        flags |= libc::O_NONBLOCK;
+        libc::fcntl(fd, libc::F_SETFL, flags)
+    };
+
+    if ret < 0 {
+        Err(io::Error::last_os_error())
+    } else {
+        Ok(())
+    }
+}
+
+/// This function must only be called once from the main thread before any threads
+/// are created to avoid race conditions.
+pub fn set_monitor(file: Option<File>) -> io::Result<Monitor> {
+    // There is only one caller of this function, so MONITOR is written to only once
+    assert!(MONITOR.get().is_none());
+
+    if let Some(ref file) = file {
+        set_file_nonblocking(file)?;
+    }
+
+    let (tx, rx) = flume::unbounded();
+    let monitor = Monitor::new(rx, file);
+
+    MONITOR.get_or_init(|| MonitorHandle {
+        tx,
+        start: Instant::now(),
+    });
+
+    Ok(monitor)
+}
+
 pub fn event_log(source: &str, event: &str, properties: Option<&HashMap<Cow<str>, Cow<str>>>) {
-    // SAFETY: MONITOR is always in a valid state (None or Some).
-    if let Some((file, start)) = unsafe { MONITOR.as_ref() } {
-        let e = Event {
-            timestamp: start.elapsed(),
+    // `MONITOR` is always in a valid state (None or Some), because it is set
+    // only once before any threads are spawned, and it's not mutated
+    // afterwards. This function only creates immutable references to `MONITOR`.
+    // Because `MONITOR.tx` is `Sync`, it's safe to share `MONITOR` across
+    // threads, making this function thread-safe.
+    if let Some(monitor_handle) = MONITOR.get().as_ref() {
+        let event = Event {
+            timestamp: monitor_handle.start.elapsed(),
             source,
             event,
             properties,
         };
-        serde_json::to_writer_pretty(file, &e).ok();
 
-        let mut file = file;
-        file.write_all(b"\n\n").ok();
+        if let Ok(event) = serde_json::to_string_pretty(&event) {
+            monitor_handle.tx.send(event).ok();
+        }
     }
 }
 
@@ -79,5 +128,4 @@ macro_rules! event {
             $crate::event_log($source, $event, Some(&properties))
         }
      };
-
 }

fuzz/Cargo.lock

@@ -5,16 +5,16 @@ version = 3
 [[package]]
 name = "acpi_tables"
 version = "0.1.0"
-source = "git+https://github.com/rust-vmm/acpi_tables?branch=main#05a609136387cc1cc9b499cee4320020325c263f"
+source = "git+https://github.com/rust-vmm/acpi_tables?branch=main#1029d22777f07b04849234bbe756da34a6df2913"
 dependencies = [
  "zerocopy",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.71"
+version = "1.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
 
 [[package]]
 name = "api_client"
@@ -59,9 +59,9 @@ dependencies = [
 
 [[package]]
 name = "argh"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab257697eb9496bf75526f0217b5ed64636a9cfafa78b8365c71bd283fcef93e"
+checksum = "7af5ba06967ff7214ce4c7419c7d185be7ecd6cc4965a8f6e1d8ce0398aad219"
 dependencies = [
  "argh_derive",
  "argh_shared",
@@ -69,21 +69,30 @@ dependencies = [
 
 [[package]]
 name = "argh_derive"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b382dbd3288e053331f03399e1db106c9fb0d8562ad62cb04859ae926f324fa6"
+checksum = "56df0aeedf6b7a2fc67d06db35b09684c3e8da0c95f8f27685cb17e08413d87a"
 dependencies = [
  "argh_shared",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.23",
 ]
 
 [[package]]
 name = "argh_shared"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64cb94155d965e3d37ffbbe7cc5b82c3dd79dd33bd48e536f73d2cfb8d85506f"
+checksum = "5693f39141bda5760ecc4111ab08da40565d1771038c4a0250f03457ec707531"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "bincode"
@@ -102,23 +111,25 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.3.2"
+version = "2.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dbe3c979c178231552ecba20214a8272df4e09f232a87aef4320cf06539aded"
+checksum = "630be753d4e58660abd17930c71b647fe46c27ea6b63cc59e1e3851406972e42"
 
 [[package]]
-name = "block_util"
+name = "block"
 version = "0.1.0"
 dependencies = [
+ "byteorder",
+ "crc32c",
  "io-uring",
  "libc",
  "log",
- "qcow",
+ "remain",
  "smallvec",
  "thiserror",
+ "uuid",
  "versionize",
  "versionize_derive",
- "vhdx",
  "virtio-bindings",
  "virtio-queue",
  "vm-memory",
@@ -126,6 +137,12 @@ dependencies = [
  "vmm-sys-util",
 ]
 
+[[package]]
+name = "bumpalo"
+version = "3.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
+
 [[package]]
 name = "byteorder"
 version = "1.4.3"
@@ -134,11 +151,12 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "cc"
-version = "1.0.79"
+version = "1.0.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
 dependencies = [
  "jobserver",
+ "libc",
 ]
 
 [[package]]
@@ -149,7 +167,7 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "cloud-hypervisor"
-version = "32.0.0"
+version = "34.0.0"
 dependencies = [
  "anyhow",
  "api_client",
@@ -175,7 +193,7 @@ dependencies = [
 name = "cloud-hypervisor-fuzz"
 version = "0.0.0"
 dependencies = [
- "block_util",
+ "block",
  "cloud-hypervisor",
  "devices",
  "epoll",
@@ -185,9 +203,7 @@ dependencies = [
  "micro_http",
  "net_util",
  "once_cell",
- "qcow",
  "seccompiler",
- "vhdx",
  "virtio-devices",
  "virtio-queue",
  "vm-device",
@@ -199,9 +215,9 @@ dependencies = [
 
 [[package]]
 name = "crc32c"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dfea2db42e9927a3845fb268a10a72faed6d416065f77873f05e411457c363e"
+checksum = "d8f48d60e5b4d2c53d5c2b1d8a58c849a70ae5e5509b08a48d047e3b65714a74"
 dependencies = [
  "rustc_version",
 ]
@@ -214,9 +230,9 @@ checksum = "55626594feae15d266d52440b26ff77de0e22230cf0c113abe619084c1ddc910"
 
 [[package]]
 name = "darling"
-version = "0.20.1"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0558d22a7b463ed0241e993f76f09f30b126687447751a8638587b864e4b3944"
+checksum = "0209d94da627ab5605dcccf08bb18afa5009cfbef48d8a8b7d7bdbc79be25c5e"
 dependencies = [
  "darling_core",
  "darling_macro",
@@ -224,27 +240,27 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.20.1"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab8bfa2e259f8ee1ce5e97824a3c55ec4404a0d772ca7fa96bf19f0752a046eb"
+checksum = "177e3443818124b357d8e76f53be906d60937f0d3a90773a664fa63fa253e621"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.15",
+ "syn 2.0.23",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.20.1"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29a358ff9f12ec09c3e61fef9b5a9902623a695a46a917b07f269bff1445611a"
+checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.23",
 ]
 
 [[package]]
@@ -254,15 +270,18 @@ dependencies = [
  "acpi_tables",
  "anyhow",
  "arch",
- "bitflags 2.3.2",
+ "bitflags 2.3.3",
  "byteorder",
+ "event_monitor",
  "hypervisor",
  "libc",
  "log",
+ "pci",
  "thiserror",
  "tpm",
  "versionize",
  "versionize_derive",
+ "vm-allocator",
  "vm-device",
  "vm-memory",
  "vm-migration",
@@ -271,11 +290,11 @@ dependencies = [
 
 [[package]]
 name = "epoll"
-version = "4.3.1"
+version = "4.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20df693c700404f7e19d4d6fae6b15215d2913c27955d2b9d6f2c0f537511cd0"
+checksum = "74351c3392ea1ff6cd2628e0042d268ac2371cb613252ff383b6dfa50d22fa79"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.3.3",
  "libc",
 ]
 
@@ -283,7 +302,9 @@ dependencies = [
 name = "event_monitor"
 version = "0.1.0"
 dependencies = [
+ "flume",
  "libc",
+ "once_cell",
  "serde",
  "serde_json",
 ]
@@ -294,12 +315,37 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "784a4df722dc6267a04af36895398f59d21d07dce47232adf31ec0ff2fa45e67"
 
+[[package]]
+name = "flume"
+version = "0.10.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1657b4441c3403d9f7b3409e47575237dac27b1b5726df654a6ecbf92f0f7577"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "nanorand",
+ "pin-project",
+ "spin",
+]
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "futures-core"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+
+[[package]]
+name = "futures-sink"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
+
 [[package]]
 name = "getrandom"
 version = "0.2.10"
@@ -307,8 +353,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "wasi",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -317,7 +365,6 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "byteorder",
- "iced-x86",
  "kvm-bindings",
  "kvm-ioctls",
  "libc",
@@ -330,15 +377,6 @@ dependencies = [
  "vmm-sys-util",
 ]
 
-[[package]]
-name = "iced-x86"
-version = "1.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7cc8d38244d84278262c8ebe6930cc44283d194cbabae2651f6112103802fb5"
-dependencies = [
- "lazy_static",
-]
-
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -347,9 +385,9 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
 [[package]]
 name = "io-uring"
-version = "0.5.13"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd1e1a01cfb924fd8c5c43b6827965db394f5a3a16c599ce03452266e1cf984c"
+checksum = "460648e47a07a43110fbfa2e0b14afb2be920093c31e5dccc50e49568e099762"
 dependencies = [
  "bitflags 1.3.2",
  "libc",
@@ -357,9 +395,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.6"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
 
 [[package]]
 name = "jobserver"
@@ -370,6 +408,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "js-sys"
+version = "0.3.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
+dependencies = [
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "kvm-bindings"
 version = "0.6.0"
@@ -391,23 +438,17 @@ dependencies = [
  "vmm-sys-util",
 ]
 
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
 [[package]]
 name = "libc"
-version = "0.2.147"
+version = "0.2.148"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
+checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b"
 
 [[package]]
 name = "libfuzzer-sys"
-version = "0.4.6"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "beb09950ae85a0a94b27676cccf37da5ff13f27076aa1adbc6545dd0d0e1bd4e"
+checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7"
 dependencies = [
  "arbitrary",
  "cc",
@@ -416,28 +457,47 @@ dependencies = [
 
 [[package]]
 name = "linux-loader"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d3adb7b28e189741eca3b1a4a27de0bf15e0907c9d4b0c74bd2d7d84ef72e08"
+checksum = "1db6a725c8000971f83fa93ed7ee1b600e55a1471a2a653379d3c84f72effdcf"
 dependencies = [
  "vm-memory",
 ]
 
 [[package]]
-name = "log"
-version = "0.4.19"
+name = "lock_api"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b06a4cde4c0f271a446782e3eff8de789548ce57dbc8eca9292c27f4a42004b4"
+checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
 
 [[package]]
 name = "micro_http"
 version = "0.1.0"
-source = "git+https://github.com/firecracker-microvm/micro-http?branch=main#b538bf89e50be83b6fa9ab1896727ff61e02fa13"
+source = "git+https://github.com/firecracker-microvm/micro-http?branch=main#0d0fdcd50ea10c1b4777f9a958873fc848a5b7bb"
 dependencies = [
  "libc",
  "vmm-sys-util",
 ]
 
+[[package]]
+name = "nanorand"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a51313c5820b0b02bd422f4b44776fbf47961755c74ce64afc73bfad10226c3"
+dependencies = [
+ "getrandom",
+]
+
 [[package]]
 name = "net_gen"
 version = "0.1.0"
@@ -500,30 +560,39 @@ dependencies = [
 ]
 
 [[package]]
-name = "proc-macro2"
-version = "1.0.63"
+name = "pin-project"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b368fba921b0dce7e60f5e04ec15e565b3303972b42bcfde1d0713b881959eb"
+checksum = "fda4ed1c6c173e3fc7a83629421152e01d7b1f9b7f65fb301e490e8cfc656422"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.23",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
 dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "qcow"
-version = "0.1.0"
-dependencies = [
- "byteorder",
- "libc",
- "log",
- "remain",
- "vmm-sys-util",
-]
-
 [[package]]
 name = "quote"
-version = "1.0.28"
+version = "1.0.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9ab9c7eadfd8df19006f1cf1a4aed13540ed5cbc047010ece5826e10825488"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
 dependencies = [
  "proc-macro2",
 ]
@@ -539,13 +608,13 @@ dependencies = [
 
 [[package]]
 name = "remain"
-version = "0.2.8"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13cca257d068dd3a390d04b2c3009a3fad2ee5048dfa8f239d048372810470c"
+checksum = "bce3a7139d2ee67d07538ee5dba997364fbc243e7e7143e96eb830c74bfaa082"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.23",
 ]
 
 [[package]]
@@ -559,9 +628,15 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.13"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "seccompiler"
@@ -574,35 +649,35 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.17"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
+checksum = "b0293b4b29daaf487284529cc2f5675b8e57c61f70167ba415a463651fd6a918"
 
 [[package]]
 name = "serde"
-version = "1.0.164"
+version = "1.0.168"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e8c8cf938e98f769bc164923b06dce91cea1751522f46f8466461af04c9027d"
+checksum = "d614f89548720367ded108b3c843be93f3a341e22d5674ca0dd5cd57f34926af"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.164"
+version = "1.0.168"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9735b638ccc51c28bf6914d90a2e9725b377144fc612c49a611fddd1b631d68"
+checksum = "d4fe589678c688e44177da4f27152ee2d190757271dc7f1d5b6b9f68d869d641"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.23",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.99"
+version = "1.0.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46266871c240a00b8f503b877622fe33430b3c7d963bdc0f2adc511e54a1eae3"
+checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65"
 dependencies = [
  "itoa",
  "ryu",
@@ -611,9 +686,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.0.0"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f02d8aa6e3c385bf084924f660ce2a3a6bd333ba55b35e8590b321f35d88513"
+checksum = "1ca3b16a3d82c4088f343b7480a93550b3eabe1a358569c2dfe38bbcead07237"
 dependencies = [
  "serde",
  "serde_with_macros",
@@ -621,14 +696,14 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.0.0"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edc7d5d3932fb12ce722ee5e64dd38c504efba37567f0c402f6ca728c3b8b070"
+checksum = "2e6be15c453eb305019bfa438b1593c731f36a289a7853f7707ee29e870b3b3c"
 dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.23",
 ]
 
 [[package]]
@@ -637,9 +712,9 @@ version = "0.1.0"
 
 [[package]]
 name = "signal-hook"
-version = "0.3.15"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "732768f1176d21d09e076c23a93123d40bba92d50c4058da34d45c8de8e682b9"
+checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
 dependencies = [
  "libc",
  "signal-hook-registry",
@@ -656,9 +731,18 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.10.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a"
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]
 
 [[package]]
 name = "strsim"
@@ -679,9 +763,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.15"
+version = "2.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a34fcf3e8b60f57e6a14301a2e916d323af98b0ea63c599441eec8558660c822"
+checksum = "59fb7d6d8281a51045d62b8eb3a7d1ce347b76f312af50cd3dc0af39c87c1737"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -690,22 +774,22 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.40"
+version = "1.0.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978c9a314bd8dc99be594bc3c175faaa9794be04a5a5e153caba6915336cebac"
+checksum = "9d6d7a740b8a666a7e828dd00da9c0dc290dff53154ea77ac109281de90589b7"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.40"
+version = "1.0.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f"
+checksum = "49922ecae66cc8a249b77e68d1d0623c1b2c514f0060c27cdc68bd62a1219d35"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.23",
 ]
 
 [[package]]
@@ -734,15 +818,15 @@ dependencies = [
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.9"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15811caf2415fb889178633e7724bad2509101cde276048e013b9def5e51fa0"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
 name = "uuid"
-version = "1.3.4"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa2982af2eec27de306107c027578ff7f423d65f7250e40ce0fea8f45248b81"
+checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d"
 dependencies = [
  "getrandom",
 ]
@@ -777,7 +861,7 @@ dependencies = [
 [[package]]
 name = "vfio-bindings"
 version = "0.4.0"
-source = "git+https://github.com/rust-vmm/vfio?branch=main#89f8e77dd1a2829197ecde65b686bafcc8a1def4"
+source = "git+https://github.com/rust-vmm/vfio?branch=main#847b0aa504ac6367efe42ba7e96a2d050737d4f0"
 dependencies = [
  "vmm-sys-util",
 ]
@@ -785,7 +869,7 @@ dependencies = [
 [[package]]
 name = "vfio-ioctls"
 version = "0.2.0"
-source = "git+https://github.com/rust-vmm/vfio?branch=main#89f8e77dd1a2829197ecde65b686bafcc8a1def4"
+source = "git+https://github.com/rust-vmm/vfio?branch=main#847b0aa504ac6367efe42ba7e96a2d050737d4f0"
 dependencies = [
  "byteorder",
  "kvm-bindings",
@@ -801,7 +885,7 @@ dependencies = [
 [[package]]
 name = "vfio_user"
 version = "0.1.0"
-source = "git+https://github.com/rust-vmm/vfio-user?branch=main#eef6bec4d421f08ed1688fe67c5ea33aabbf5069"
+source = "git+https://github.com/rust-vmm/vfio-user?branch=main#2d96b90a7279547356ad8f83aaa3115ad5497302"
 dependencies = [
  "bitflags 1.3.2",
  "libc",
@@ -815,24 +899,11 @@ dependencies = [
  "vmm-sys-util",
 ]
 
-[[package]]
-name = "vhdx"
-version = "0.1.0"
-dependencies = [
- "byteorder",
- "crc32c",
- "libc",
- "log",
- "remain",
- "thiserror",
- "uuid",
-]
-
 [[package]]
 name = "vhost"
-version = "0.7.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84f81f436bca4541f4d33172e1202882c9d437db34ed17fc6d84c8ff2bde21f5"
+checksum = "61957aeb36daf0b00b87fff9c10dd28a161bd35ab157553d340d183b3d8756e6"
 dependencies = [
  "bitflags 1.3.2",
  "libc",
@@ -842,9 +913,9 @@ dependencies = [
 
 [[package]]
 name = "virtio-bindings"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9084faf91b9aa9676ae2cac8f1432df2839d9566e6f19f29dbc13a8b831dff"
+checksum = "c18d7b74098a946470ea265b5bacbbf877abc3373021388454de0d47735a5b98"
 
 [[package]]
 name = "virtio-devices"
@@ -852,11 +923,10 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "arc-swap",
- "block_util",
+ "block",
  "byteorder",
  "epoll",
  "event_monitor",
- "io-uring",
  "libc",
  "log",
  "net_gen",
@@ -883,9 +953,9 @@ dependencies = [
 
 [[package]]
 name = "virtio-queue"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91aebb1df33db33cbf04d4c2445e4f78d0b0c8e65acfd16a4ee95ef63ca252f8"
+checksum = "35aca00da06841bd99162c381ec65893cace23ca0fb89254302cfe4bec4c300f"
 dependencies = [
  "log",
  "virtio-bindings",
@@ -922,12 +992,13 @@ source = "git+https://github.com/rust-vmm/vm-fdt?branch=main#c5a99ab71b130435927
 
 [[package]]
 name = "vm-memory"
-version = "0.11.0"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d6ea57fe00f9086c59eeeb68e102dd611686bc3c28520fa465996d4d4bdce07"
+checksum = "9dc276f0d00c17b9aeb584da0f1e1c673df0d183cc2539e3636ec8cbc5eae99b"
 dependencies = [
  "arc-swap",
  "libc",
+ "thiserror",
  "winapi",
 ]
 
@@ -961,11 +1032,13 @@ dependencies = [
  "anyhow",
  "arc-swap",
  "arch",
- "bitflags 2.3.2",
- "block_util",
+ "bitflags 2.3.3",
+ "block",
+ "cfg-if",
  "devices",
  "epoll",
  "event_monitor",
+ "flume",
  "hypervisor",
  "libc",
  "linux-loader",
@@ -975,7 +1048,6 @@ dependencies = [
  "once_cell",
  "option_parser",
  "pci",
- "qcow",
  "seccompiler",
  "serde",
  "serde_json",
@@ -988,7 +1060,6 @@ dependencies = [
  "versionize_derive",
  "vfio-ioctls",
  "vfio_user",
- "vhdx",
  "virtio-devices",
  "virtio-queue",
  "vm-allocator",
@@ -1002,9 +1073,9 @@ dependencies = [
 
 [[package]]
 name = "vmm-sys-util"
-version = "0.11.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd64fe09d8e880e600c324e7d664760a17f56e9672b7495a86381b49e4f72f46"
+checksum = "48b7b084231214f7427041e4220d77dfe726897a6d41fddee450696e66ff2a29"
 dependencies = [
  "bitflags 1.3.2",
  "libc",
@@ -1018,6 +1089,60 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.23",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.23",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -1042,9 +1167,9 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "zerocopy"
-version = "0.6.1"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "332f188cc1bcf1fe1064b8c58d150f497e697f49774aa846f2dc949d9a25f236"
+checksum = "20707b61725734c595e840fb3704378a0cd2b9c74cc9e6e20724838fc6a1e2f9"
 dependencies = [
  "byteorder",
  "zerocopy-derive",
@@ -1052,11 +1177,11 @@ dependencies = [
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.3.2"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6505e6815af7de1746a08f69c69606bb45695a17149517680f3b2149713b19a3"
+checksum = "56097d5b91d711293a42be9289403896b68654625021732067eac7a4ca388a1f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.23",
 ]

fuzz/Cargo.toml

@@ -9,23 +9,21 @@ edition = "2021"
 cargo-fuzz = true
 
 [dependencies]
-block_util = { path = "../block_util" }
+block = { path = "../block" }
 devices = { path = "../devices" }
 epoll = "4.3.1"
-libc = "0.2.147"
-libfuzzer-sys = "0.4.6"
-linux-loader = { version = "0.9.0", features = ["elf", "bzimage", "pe"] }
+libc = "0.2.148"
+libfuzzer-sys = "0.4.7"
+linux-loader = { version = "0.9.1", features = ["elf", "bzimage", "pe"] }
 micro_http = { git = "https://github.com/firecracker-microvm/micro-http", branch = "main" }
 net_util = { path = "../net_util" }
 once_cell = "1.18.0"
-qcow = { path = "../qcow" }
 seccompiler = "0.3.0"
-vhdx = { path = "../vhdx" }
 virtio-devices = { path = "../virtio-devices" }
-virtio-queue = "0.8.0"
+virtio-queue = "0.9.0"
 vmm = { path = "../vmm" }
-vmm-sys-util = "0.11.1"
-vm-memory = "0.11.0"
+vmm-sys-util = "0.11.2"
+vm-memory = "0.12.2"
 vm-device = { path = "../vm-device" }
 vm-virtio = { path = "../vm-virtio" }
 

fuzz/fuzz_targets/balloon.rs

@@ -24,7 +24,7 @@ const QUEUE_NUM: usize = 3;
 const QUEUE_SIZE: u16 = 64;
 // Descriptor table alignment
 const DESC_TABLE_ALIGN_SIZE: u64 = 16;
-// Avalable ring alignment
+// Available ring alignment
 const AVAIL_RING_ALIGN_SIZE: u64 = 2;
 // Used ring alignment
 const USED_RING_ALIGN_SIZE: u64 = 4;

fuzz/fuzz_targets/block.rs

@@ -8,7 +8,7 @@
 
 #![no_main]
 
-use block_util::{async_io::DiskFile, raw_sync::RawFileDiskSync};
+use block::{async_io::DiskFile, raw_sync::RawFileDiskSync};
 use libfuzzer_sys::fuzz_target;
 use seccompiler::SeccompAction;
 use std::ffi;
@@ -57,6 +57,7 @@ fuzz_target!(|bytes| {
         false,
         2,
         256,
+        None,
         SeccompAction::Allow,
         None,
         EventFd::new(EFD_NONBLOCK).unwrap(),

fuzz/fuzz_targets/cmos.rs

@@ -6,6 +6,8 @@
 use devices::legacy::Cmos;
 use libc::EFD_NONBLOCK;
 use libfuzzer_sys::fuzz_target;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
 use vm_device::BusDevice;
 use vmm_sys_util::eventfd::EventFd;
 
@@ -25,6 +27,7 @@ fuzz_target!(|bytes| {
         u64::from_le_bytes(below_4g),
         u64::from_le_bytes(above_4g),
         EventFd::new(EFD_NONBLOCK).unwrap(),
+        None,
     );
 
     let mut i = 16;

fuzz/fuzz_targets/iommu.rs

@@ -30,7 +30,7 @@ const IOVA_SPACE_SIZE: usize = (0xfeef_ffff - 0xfee0_0000) + 1;
 const QUEUE_SIZE: u16 = 256;
 // Descriptor table alignment
 const DESC_TABLE_ALIGN_SIZE: u64 = 16;
-// Avalable ring alignment
+// Available ring alignment
 const AVAIL_RING_ALIGN_SIZE: u64 = 2;
 // Used ring alignment
 const USED_RING_ALIGN_SIZE: u64 = 4;

fuzz/fuzz_targets/mem.rs

@@ -33,7 +33,7 @@ const VIRTIO_MEM_REGION_ADDRESS: u64 = 0;
 const QUEUE_SIZE: u16 = 64;
 // Descriptor table alignment
 const DESC_TABLE_ALIGN_SIZE: u64 = 16;
-// Avalable ring alignment
+// Available ring alignment
 const AVAIL_RING_ALIGN_SIZE: u64 = 2;
 // Used ring alignment
 const USED_RING_ALIGN_SIZE: u64 = 4;

fuzz/fuzz_targets/qcow.rs

@@ -4,7 +4,7 @@
 
 #![no_main]
 use libfuzzer_sys::fuzz_target;
-use qcow::{QcowFile, RawFile};
+use block::qcow::{QcowFile, RawFile};
 use std::ffi;
 use std::fs::File;
 use std::io::{self, Cursor, Read, Seek, SeekFrom, Write};

fuzz/fuzz_targets/rng.rs

@@ -28,7 +28,7 @@ const MEM_SIZE: usize = 1 * 1024 * 1024;
 const QUEUE_SIZE: u16 = 256;
 // Descriptor table alignment
 const DESC_TABLE_ALIGN_SIZE: u64 = 16;
-// Avalable ring alignment
+// Available ring alignment
 const AVAIL_RING_ALIGN_SIZE: u64 = 2;
 // Used ring alignment
 const USED_RING_ALIGN_SIZE: u64 = 4;

fuzz/fuzz_targets/serial.rs

@@ -59,9 +59,13 @@ impl InterruptSourceGroup for TestInterrupt {
         _index: InterruptIndex,
         _config: InterruptSourceConfig,
         _masked: bool,
+        _set_gsi: bool,
     ) -> Result<(), std::io::Error> {
         Ok(())
     }
+    fn set_gsi(&self) -> Result<(), std::io::Error> {
+        Ok(())
+    }
     fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
         Some(self.event_fd.try_clone().unwrap())
     }

fuzz/fuzz_targets/vhdx.rs

@@ -8,7 +8,7 @@ use std::ffi;
 use std::fs::File;
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::os::unix::io::{FromRawFd, RawFd};
-use vhdx::vhdx::Vhdx;
+use block::vhdx::Vhdx;
 
 // Populate the corpus directory with a test file:
 // truncate -s 16M /tmp/source

hypervisor/Cargo.toml

@@ -7,26 +7,28 @@ license = "Apache-2.0 OR BSD-3-Clause"
 
 [features]
 kvm = ["kvm-ioctls", "kvm-bindings", "vfio-ioctls/kvm"]
-mshv = ["mshv-ioctls", "mshv-bindings", "vfio-ioctls/mshv"]
+mshv = ["mshv-ioctls", "mshv-bindings", "vfio-ioctls/mshv", "iced-x86"]
+sev_snp = []
 tdx = []
 
 [dependencies]
-anyhow = "1.0.71"
+anyhow = "1.0.75"
 byteorder = "1.4.3"
 thiserror = "1.0.40"
-libc = "0.2.139"
+libc = "0.2.147"
 log = "0.4.17"
 kvm-ioctls = { version = "0.13.0", optional = true }
 kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.6.0-tdx", features = ["with-serde", "fam-wrappers"], optional  = true }
 mshv-bindings = { git = "https://github.com/rust-vmm/mshv", branch = "main", features = ["with-serde", "fam-wrappers"], optional  = true }
 mshv-ioctls = { git = "https://github.com/rust-vmm/mshv", branch = "main", optional  = true}
-serde = { version = "1.0.164", features = ["rc", "derive"] }
+serde = { version = "1.0.168", features = ["rc", "derive"] }
 serde_with = { version = "3.0.0", default-features = false, features = ["macros"] }
 vfio-ioctls = { git = "https://github.com/rust-vmm/vfio", branch = "main", default-features = false }
-vm-memory = { version = "0.11.0", features = ["backend-mmap", "backend-atomic"] }
+vm-memory = { version = "0.12.2", features = ["backend-mmap", "backend-atomic"] }
 vmm-sys-util = { version = "0.11.0", features = ["with-serde"] }
 
 [target.'cfg(target_arch = "x86_64")'.dependencies.iced-x86]
+optional = true
 version = "1.19.0"
 default-features = false
 features = ["std", "decoder", "op_code_info", "instr_info", "fast_fmt"]

hypervisor/src/arch/x86/emulator/instructions/cmp.rs

@@ -18,7 +18,7 @@ use crate::arch::x86::Exception;
 // CMP affects OF, SF, ZF, AF, PF and CF
 const FLAGS_MASK: u64 = CF | PF | AF | ZF | SF | OF;
 
-// TODO: Switch to inline asm when that's stable. Executing CMP (or any arthimetic instructions)
+// TODO: Switch to inline asm when that's stable. Executing CMP (or any arithmetic instructions)
 // natively and extracting RFLAGS will be much faster and make the code simpler.
 fn calc_rflags_cpazso(op0: u64, op1: u64, op_size: usize) -> u64 {
     let op_bits = op_size * 8;

hypervisor/src/arch/x86/emulator/instructions/mod.rs

@@ -18,8 +18,8 @@ fn get_op<T: CpuStateManager>(
     insn: &Instruction,
     op_index: u32,
     op_size: usize,
-    state: &mut T,
-    platform: &mut dyn PlatformEmulator<CpuState = T>,
+    state: &T,
+    platform: &dyn PlatformEmulator<CpuState = T>,
 ) -> Result<u64, PlatformError> {
     if insn.op_count() < op_index + 1 {
         return Err(PlatformError::InvalidOperand(anyhow!(
@@ -124,7 +124,7 @@ fn memory_operand_address<T: CpuStateManager>(
         address += index;
     }
 
-    address += insn.memory_displacement64();
+    address = address.wrapping_add(insn.memory_displacement64());
 
     // Translate to a linear address.
     state.linearize(insn.memory_segment(), address, write)

hypervisor/src/arch/x86/emulator/instructions/mov.rs

@@ -239,6 +239,36 @@ impl<T: CpuStateManager> InstructionHandler<T> for Movzx_r64_rm16 {
     movzx!(u64, u16);
 }
 
+pub struct Mov_moffs16_AX;
+impl<T: CpuStateManager> InstructionHandler<T> for Mov_moffs16_AX {
+    movzx!(u16, u16);
+}
+
+pub struct Mov_AX_moffs16;
+impl<T: CpuStateManager> InstructionHandler<T> for Mov_AX_moffs16 {
+    movzx!(u16, u16);
+}
+
+pub struct Mov_moffs32_EAX;
+impl<T: CpuStateManager> InstructionHandler<T> for Mov_moffs32_EAX {
+    movzx!(u32, u32);
+}
+
+pub struct Mov_EAX_moffs32;
+impl<T: CpuStateManager> InstructionHandler<T> for Mov_EAX_moffs32 {
+    movzx!(u32, u32);
+}
+
+pub struct Mov_moffs64_RAX;
+impl<T: CpuStateManager> InstructionHandler<T> for Mov_moffs64_RAX {
+    movzx!(u64, u64);
+}
+
+pub struct Mov_RAX_moffs64;
+impl<T: CpuStateManager> InstructionHandler<T> for Mov_RAX_moffs64 {
+    movzx!(u64, u64);
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(unused_mut)]
@@ -617,4 +647,123 @@ mod tests {
             .unwrap();
         assert_eq!(eax, value as u64);
     }
+
+    #[test]
+    // movabs ax, ds:0x1337
+    // movabs eax, ds:0x1337
+    // movabs rax, ds:0x1337
+    fn test_mov_memoff_ax() {
+        let test_inputs: [(Register, &[u8]); 3] = [
+            (Register::AX, &[0x66, 0xa1]),
+            (Register::EAX, &[0xa1]),
+            (Register::RAX, &[0x48, 0xa1]),
+        ];
+
+        // Constructs the instruction with the provided inputs and emulates it.
+        fn helper(register: Register, instruction_prefix: &[u8]) {
+            let mem_addr: u64 = 0x1337;
+            let mem_value: u64 = 0x13371337deadbeef;
+            let ip: u64 = 0x1000;
+            let cpu_id = 0;
+
+            let mut instruction_bytes = Vec::new();
+            // instruction prefix with specified register
+            instruction_bytes.extend(instruction_prefix);
+            // 64-bit memory operand
+            instruction_bytes.extend([
+                mem_addr.to_le_bytes()[0],
+                mem_addr.to_le_bytes()[1],
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+            ]);
+
+            let memory: [u8; 8] = mem_value.to_le_bytes();
+            let mut vmm = MockVmm::new(ip, vec![], Some((mem_addr, &memory)));
+            assert!(vmm.emulate_first_insn(cpu_id, &instruction_bytes).is_ok());
+
+            let ax: u64 = vmm.cpu_state(cpu_id).unwrap().read_reg(register).unwrap();
+
+            match register {
+                Register::AX => {
+                    assert_eq!(ax as u16, mem_value as u16);
+                }
+                Register::EAX => {
+                    assert_eq!(ax as u32, mem_value as u32);
+                }
+                Register::RAX => {
+                    assert_eq!(ax, mem_value);
+                }
+                _ => panic!(),
+            }
+        }
+
+        for (register, instruction_prefix) in test_inputs {
+            helper(register, instruction_prefix)
+        }
+    }
+
+    #[test]
+    // movabs ds:0x1337, ax
+    // movabs ds:0x1337, eax
+    // movabs ds:0x1337, rax
+    fn test_mov_ax_memoff() {
+        let test_inputs: [(Register, &[u8]); 3] = [
+            (Register::AX, &[0x66, 0xa3]),
+            (Register::EAX, &[0xa3]),
+            (Register::RAX, &[0x48, 0xa3]),
+        ];
+
+        // Constructs the instruction with the provided inputs and emulates it.
+        fn helper(register: Register, instruction_prefix: &[u8]) {
+            let mem_addr: u64 = 0x1337;
+            let ax: u64 = 0x13371337deadbeef;
+            let ip: u64 = 0x1000;
+            let cpu_id = 0;
+
+            let mut instruction_bytes = Vec::new();
+            // instruction prefix with specified register
+            instruction_bytes.extend(instruction_prefix);
+            // 64-bit memory operand
+            instruction_bytes.extend([
+                mem_addr.to_le_bytes()[0],
+                mem_addr.to_le_bytes()[1],
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+            ]);
+
+            let mut vmm = MockVmm::new(ip, vec![(Register::RAX, ax)], None);
+            assert!(vmm.emulate_first_insn(cpu_id, &instruction_bytes).is_ok());
+
+            match register {
+                Register::AX => {
+                    let mut memory: [u8; 2] = [0; 2];
+                    vmm.read_memory(mem_addr, &mut memory).unwrap();
+                    assert_eq!(u16::from_le_bytes(memory), ax as u16);
+                }
+                Register::EAX => {
+                    let mut memory: [u8; 4] = [0; 4];
+                    vmm.read_memory(mem_addr, &mut memory).unwrap();
+                    assert_eq!(u32::from_le_bytes(memory), ax as u32);
+                }
+                Register::RAX => {
+                    let mut memory: [u8; 8] = [0; 8];
+                    vmm.read_memory(mem_addr, &mut memory).unwrap();
+                    assert_eq!(u64::from_le_bytes(memory), ax);
+                }
+                _ => panic!(),
+            }
+        }
+
+        for (register, instruction_prefix) in test_inputs {
+            helper(register, instruction_prefix)
+        }
+    }
 }

hypervisor/src/arch/x86/emulator/mod.rs

@@ -524,6 +524,13 @@ impl<'a, T: CpuStateManager> Emulator<'a, T> {
             (mov, Movzx_r64_rm8),
             (mov, Movzx_r32_rm16),
             (mov, Movzx_r64_rm16),
+            // MOV MOFFS
+            (mov, Mov_moffs16_AX),
+            (mov, Mov_AX_moffs16),
+            (mov, Mov_moffs32_EAX),
+            (mov, Mov_EAX_moffs32),
+            (mov, Mov_moffs64_RAX),
+            (mov, Mov_RAX_moffs64),
             // MOVS
             (movs, Movsd_m32_m32),
             (movs, Movsw_m16_m16),

hypervisor/src/arch/x86/mod.rs

@@ -11,6 +11,7 @@
 // Copyright © 2020, Microsoft Corporation
 //
 
+#[cfg(all(feature = "mshv", target_arch = "x86_64"))]
 pub mod emulator;
 pub mod gdt;
 #[allow(non_camel_case_types)]

hypervisor/src/cpu.rs

@@ -242,7 +242,7 @@ pub enum HypervisorCpuError {
     UnknownTdxVmCall,
     #[cfg(target_arch = "aarch64")]
     ///
-    /// Failed to intialize PMU
+    /// Failed to initialize PMU
     ///
     #[error("Failed to initialize PMU")]
     InitializePmu,
@@ -252,6 +252,11 @@ pub enum HypervisorCpuError {
     ///
     #[error("Failed to get TSC frequency: {0}")]
     GetTscKhz(#[source] anyhow::Error),
+    ///
+    /// Error setting TSC frequency
+    ///
+    #[error("Failed to set TSC frequency: {0}")]
+    SetTscKhz(#[source] anyhow::Error),
 }
 
 #[derive(Debug)]
@@ -447,6 +452,7 @@ pub trait Vcpu: Send + Sync {
     /// Return the list of initial MSR entries for a VCPU
     ///
     fn boot_msr_entries(&self) -> Vec<MsrEntry>;
+
     #[cfg(target_arch = "x86_64")]
     ///
     /// Get the frequency of the TSC if available
@@ -454,4 +460,11 @@ pub trait Vcpu: Send + Sync {
     fn tsc_khz(&self) -> Result<Option<u32>> {
         Ok(None)
     }
+    #[cfg(target_arch = "x86_64")]
+    ///
+    /// Set the frequency of the TSC if available
+    ///
+    fn set_tsc_khz(&self, _freq: u32) -> Result<()> {
+        Ok(())
+    }
 }

hypervisor/src/hypervisor.rs

@@ -84,6 +84,11 @@ pub enum HypervisorError {
     ///
     #[error("Unsupported CPU:{0}")]
     UnsupportedCpu(#[source] anyhow::Error),
+    ///
+    /// Launching a VM with unsupported VM Type
+    ///
+    #[error("Unsupported VmType")]
+    UnsupportedVmType(),
 }
 
 ///

hypervisor/src/kvm/mod.rs

@@ -1205,7 +1205,7 @@ impl cpu::Vcpu for KvmVcpu {
             off += std::mem::size_of::<u64>();
         }
 
-        // Now moving on to floting point registers which are stored in the user_fpsimd_state in the kernel:
+        // Now moving on to floating point registers which are stored in the user_fpsimd_state in the kernel:
         // https://elixir.free-electrons.com/linux/v4.9.62/source/arch/arm64/include/uapi/asm/kvm.h#L53
         let mut off = offset_of!(kvm_regs, fp_regs) + offset_of!(user_fpsimd_state, vregs);
         for i in 0..32 {
@@ -1890,6 +1890,7 @@ impl cpu::Vcpu for KvmVcpu {
         };
 
         let vcpu_events = self.get_vcpu_events()?;
+        let tsc_khz = self.tsc_khz()?;
 
         Ok(VcpuKvmState {
             cpuid,
@@ -1902,6 +1903,7 @@ impl cpu::Vcpu for KvmVcpu {
             xsave,
             xcrs,
             mp_state,
+            tsc_khz,
         }
         .into())
     }
@@ -2004,6 +2006,10 @@ impl cpu::Vcpu for KvmVcpu {
         self.set_lapic(&state.lapic_state)?;
         self.set_fpu(&state.fpu)?;
 
+        if let Some(freq) = state.tsc_khz {
+            self.set_tsc_khz(freq)?;
+        }
+
         // Try to set all MSRs previously stored.
         // If the number of MSRs set from SET_MSRS is different from the
         // expected amount, we fallback onto a slower method by setting MSRs
@@ -2186,6 +2192,23 @@ impl cpu::Vcpu for KvmVcpu {
             Ok(v) => Ok(Some(v)),
         }
     }
+
+    #[cfg(target_arch = "x86_64")]
+    ///
+    /// Set the frequency of the TSC if available
+    ///
+    fn set_tsc_khz(&self, freq: u32) -> cpu::Result<()> {
+        match self.fd.set_tsc_khz(freq) {
+            Err(e) => {
+                if e.errno() == libc::EIO {
+                    Ok(())
+                } else {
+                    Err(cpu::HypervisorCpuError::SetTscKhz(e.into()))
+                }
+            }
+            Ok(_) => Ok(()),
+        }
+    }
 }
 
 impl KvmVcpu {

hypervisor/src/kvm/x86_64/mod.rs

@@ -67,6 +67,7 @@ pub struct VcpuKvmState {
     pub xsave: Xsave,
     pub xcrs: ExtendedControlRegisters,
     pub mp_state: MpState,
+    pub tsc_khz: Option<u32>,
 }
 
 impl From<StandardRegisters> for kvm_regs {

hypervisor/src/lib.rs

@@ -36,7 +36,7 @@ pub mod kvm;
 #[cfg(all(feature = "mshv", target_arch = "x86_64"))]
 pub mod mshv;
 
-/// Hypevisor related module
+/// Hypervisor related module
 mod hypervisor;
 
 /// Vm related module
@@ -140,7 +140,7 @@ pub enum MpState {
     #[cfg(feature = "kvm")]
     Kvm(kvm_bindings::kvm_mp_state),
     #[cfg(all(feature = "mshv", target_arch = "x86_64"))]
-    Mshv, /* MSHV does not supprt MpState yet */
+    Mshv, /* MSHV does not support MpState yet */
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -164,7 +164,7 @@ pub enum ClockData {
     #[cfg(feature = "kvm")]
     Kvm(kvm_bindings::kvm_clock_data),
     #[cfg(feature = "mshv")]
-    Mshv, /* MSHV does not supprt ClockData yet */
+    Mshv, /* MSHV does not support ClockData yet */
 }
 
 #[cfg(target_arch = "x86_64")]

hypervisor/src/mshv/mod.rs

@@ -14,7 +14,7 @@ use crate::vec_with_array_field;
 use crate::vm::{self, InterruptSourceConfig, VmOps};
 use crate::HypervisorType;
 pub use mshv_bindings::*;
-use mshv_ioctls::{set_registers_64, Mshv, NoDatamatch, VcpuFd, VmFd};
+use mshv_ioctls::{set_registers_64, Mshv, NoDatamatch, VcpuFd, VmFd, VmType};
 use std::any::Any;
 use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
@@ -38,9 +38,7 @@ use std::fs::File;
 use std::os::unix::io::AsRawFd;
 
 #[cfg(target_arch = "x86_64")]
-use crate::arch::x86::{
-    CpuIdEntry, FpuState, LapicState, MsrEntry, SpecialRegisters, StandardRegisters,
-};
+use crate::arch::x86::{CpuIdEntry, FpuState, MsrEntry};
 
 const DIRTY_BITMAP_CLEAR_DIRTY: u64 = 0x4;
 const DIRTY_BITMAP_SET_DIRTY: u64 = 0x8;
@@ -212,21 +210,15 @@ impl hypervisor::Hypervisor for MshvHypervisor {
     fn hypervisor_type(&self) -> HypervisorType {
         HypervisorType::Mshv
     }
-    /// Create a mshv vm object and return the object as Vm trait object
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate hypervisor;
-    /// # use hypervisor::mshv::MshvHypervisor;
-    /// use hypervisor::mshv::MshvVm;
-    /// let hypervisor = MshvHypervisor::new().unwrap();
-    /// let vm = hypervisor.create_vm().unwrap();
-    /// ```
-    fn create_vm(&self) -> hypervisor::Result<Arc<dyn vm::Vm>> {
+
+    fn create_vm_with_type(&self, vm_type: u64) -> hypervisor::Result<Arc<dyn crate::Vm>> {
+        let mshv_vm_type: VmType = match VmType::try_from(vm_type) {
+            Ok(vm_type) => vm_type,
+            Err(_) => return Err(hypervisor::HypervisorError::UnsupportedVmType()),
+        };
         let fd: VmFd;
         loop {
-            match self.mshv.create_vm() {
+            match self.mshv.create_vm_with_type(mshv_vm_type) {
                 Ok(res) => fd = res,
                 Err(e) => {
                     if e.errno() == libc::EINTR {
@@ -273,6 +265,22 @@ impl hypervisor::Hypervisor for MshvHypervisor {
             dirty_log_slots: Arc::new(RwLock::new(HashMap::new())),
         }))
     }
+
+    /// Create a mshv vm object and return the object as Vm trait object
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate hypervisor;
+    /// # use hypervisor::mshv::MshvHypervisor;
+    /// use hypervisor::mshv::MshvVm;
+    /// let hypervisor = MshvHypervisor::new().unwrap();
+    /// let vm = hypervisor.create_vm().unwrap();
+    /// ```
+    fn create_vm(&self) -> hypervisor::Result<Arc<dyn vm::Vm>> {
+        let vm_type = 0;
+        self.create_vm_with_type(vm_type)
+    }
     ///
     /// Get the supported CpuID
     ///
@@ -314,7 +322,7 @@ impl cpu::Vcpu for MshvVcpu {
     ///
     /// Returns the vCPU general purpose registers.
     ///
-    fn get_regs(&self) -> cpu::Result<StandardRegisters> {
+    fn get_regs(&self) -> cpu::Result<crate::arch::x86::StandardRegisters> {
         Ok(self
             .fd
             .get_regs()
@@ -325,7 +333,7 @@ impl cpu::Vcpu for MshvVcpu {
     ///
     /// Sets the vCPU general purpose registers.
     ///
-    fn set_regs(&self, regs: &StandardRegisters) -> cpu::Result<()> {
+    fn set_regs(&self, regs: &crate::arch::x86::StandardRegisters) -> cpu::Result<()> {
         let regs = (*regs).into();
         self.fd
             .set_regs(&regs)
@@ -335,7 +343,7 @@ impl cpu::Vcpu for MshvVcpu {
     ///
     /// Returns the vCPU special registers.
     ///
-    fn get_sregs(&self) -> cpu::Result<SpecialRegisters> {
+    fn get_sregs(&self) -> cpu::Result<crate::arch::x86::SpecialRegisters> {
         Ok(self
             .fd
             .get_sregs()
@@ -346,7 +354,7 @@ impl cpu::Vcpu for MshvVcpu {
     ///
     /// Sets the vCPU special registers.
     ///
-    fn set_sregs(&self, sregs: &SpecialRegisters) -> cpu::Result<()> {
+    fn set_sregs(&self, sregs: &crate::arch::x86::SpecialRegisters) -> cpu::Result<()> {
         let sregs = (*sregs).into();
         self.fd
             .set_sregs(&sregs)
@@ -564,6 +572,18 @@ impl cpu::Vcpu for MshvVcpu {
                     debug!("Exception Info {:?}", { info.exception_vector });
                     Ok(cpu::VmExit::Ignore)
                 }
+                hv_message_type_HVMSG_X64_APIC_EOI => {
+                    let info = x.to_apic_eoi_info().unwrap();
+                    // The kernel should dispatch the EOI to the correct thread.
+                    // Check the VP index is the same as the one we have.
+                    assert!(info.vp_index == self.vp_index as u32);
+                    // The interrupt vector in info is u32, but x86 only supports 256 vectors.
+                    // There is no good way to recover from this if the hypervisor messes around.
+                    // Just unwrap.
+                    Ok(cpu::VmExit::IoapicEoi(
+                        info.interrupt_vector.try_into().unwrap(),
+                    ))
+                }
                 exit => Err(cpu::HypervisorCpuError::RunVcpu(anyhow!(
                     "Unhandled VCPU exit {:?}",
                     exit
@@ -603,7 +623,7 @@ impl cpu::Vcpu for MshvVcpu {
     ///
     /// Returns the state of the LAPIC (Local Advanced Programmable Interrupt Controller).
     ///
-    fn get_lapic(&self) -> cpu::Result<LapicState> {
+    fn get_lapic(&self) -> cpu::Result<crate::arch::x86::LapicState> {
         Ok(self
             .fd
             .get_lapic()
@@ -614,7 +634,7 @@ impl cpu::Vcpu for MshvVcpu {
     ///
     /// Sets the state of the LAPIC (Local Advanced Programmable Interrupt Controller).
     ///
-    fn set_lapic(&self, lapic: &LapicState) -> cpu::Result<()> {
+    fn set_lapic(&self, lapic: &crate::arch::x86::LapicState) -> cpu::Result<()> {
         let lapic: mshv_bindings::LapicState = (*lapic).clone().into();
         self.fd
             .set_lapic(&lapic)

hypervisor/src/vm.rs

@@ -325,7 +325,7 @@ pub trait Vm: Send + Sync + Any {
     /// Get dirty pages bitmap
     fn get_dirty_log(&self, slot: u32, base_gpa: u64, memory_size: u64) -> Result<Vec<u64>>;
     #[cfg(feature = "tdx")]
-    /// Initalize TDX on this VM
+    /// Initialize TDX on this VM
     fn tdx_init(&self, _cpuid: &[CpuIdEntry], _max_vcpus: u32) -> Result<()> {
         unimplemented!()
     }
@@ -335,7 +335,7 @@ pub trait Vm: Send + Sync + Any {
         unimplemented!()
     }
     #[cfg(feature = "tdx")]
-    /// Initalize a TDX memory region for this VM
+    /// Initialize a TDX memory region for this VM
     fn tdx_init_memory_region(
         &self,
         _host_address: u64,

net_util/Cargo.toml

@@ -5,24 +5,24 @@ authors = ["The Chromium OS Authors"]
 edition = "2021"
 
 [dependencies]
-epoll = "4.3.1"
-getrandom = "0.2.8"
-libc = "0.2.139"
+epoll = "4.3.3"
+getrandom = "0.2.10"
+libc = "0.2.147"
 log = "0.4.17"
 net_gen = { path = "../net_gen" }
 rate_limiter = { path = "../rate_limiter" }
-serde = "1.0.164"
+serde = "1.0.168"
 thiserror = "1.0.40"
 versionize = "0.1.10"
 versionize_derive = "0.1.4"
 virtio-bindings = "0.2.0"
-virtio-queue = "0.8.0"
-vm-memory = { version = "0.11.0", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
+virtio-queue = "0.9.0"
+vm-memory = { version = "0.12.2", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
 vm-virtio = { path = "../vm-virtio" }
 vmm-sys-util = "0.11.0"
 
 [dev-dependencies]
-once_cell = "1.17.1"
-pnet = "0.33.0"
-pnet_datalink = "0.33.0"
-serde_json = "1.0.96"
+once_cell = "1.18.0"
+pnet = "0.34.0"
+pnet_datalink = "0.34.0"
+serde_json = "1.0.107"

net_util/src/queue_pair.rs

@@ -38,7 +38,7 @@ impl TxVirtio {
     pub fn process_desc_chain(
         &mut self,
         mem: &GuestMemoryMmap,
-        tap: &mut Tap,
+        tap: &Tap,
         queue: &mut Queue,
         rate_limiter: &mut Option<RateLimiter>,
         access_platform: Option<&Arc<dyn AccessPlatform>>,
@@ -64,9 +64,9 @@ impl TxVirtio {
                         .memory()
                         .get_slice(desc_addr, desc.len() as usize)
                         .map_err(NetQueuePairError::GuestMemory)?
-                        .as_ptr();
+                        .ptr_guard_mut();
                     let iovec = libc::iovec {
-                        iov_base: buf as *mut libc::c_void,
+                        iov_base: buf.as_ptr() as *mut libc::c_void,
                         iov_len: desc.len() as libc::size_t,
                     };
                     iovecs.push(iovec);
@@ -87,7 +87,7 @@ impl TxVirtio {
                 let result = unsafe {
                     libc::writev(
                         tap.as_raw_fd() as libc::c_int,
-                        iovecs.as_ptr() as *const libc::iovec,
+                        iovecs.as_ptr(),
                         iovecs.len() as libc::c_int,
                     )
                 };
@@ -164,7 +164,7 @@ impl RxVirtio {
     pub fn process_desc_chain(
         &mut self,
         mem: &GuestMemoryMmap,
-        tap: &mut Tap,
+        tap: &Tap,
         queue: &mut Queue,
         rate_limiter: &mut Option<RateLimiter>,
         access_platform: Option<&Arc<dyn AccessPlatform>>,
@@ -203,9 +203,9 @@ impl RxVirtio {
                         .memory()
                         .get_slice(desc_addr, desc.len() as usize)
                         .map_err(NetQueuePairError::GuestMemory)?
-                        .as_ptr();
+                        .ptr_guard_mut();
                     let iovec = libc::iovec {
-                        iov_base: buf as *mut libc::c_void,
+                        iov_base: buf.as_ptr() as *mut libc::c_void,
                         iov_len: desc.len() as libc::size_t,
                     };
                     iovecs.push(iovec);
@@ -226,7 +226,7 @@ impl RxVirtio {
                 let result = unsafe {
                     libc::readv(
                         tap.as_raw_fd() as libc::c_int,
-                        iovecs.as_ptr() as *const libc::iovec,
+                        iovecs.as_ptr(),
                         iovecs.len() as libc::c_int,
                     )
                 };
@@ -357,7 +357,7 @@ impl NetQueuePair {
     ) -> Result<bool, NetQueuePairError> {
         let tx_tap_retry = self.tx.process_desc_chain(
             mem,
-            &mut self.tap,
+            &self.tap,
             queue,
             &mut self.tx_rate_limiter,
             self.access_platform.as_ref(),
@@ -407,7 +407,7 @@ impl NetQueuePair {
     ) -> Result<bool, NetQueuePairError> {
         self.rx_desc_avail = !self.rx.process_desc_chain(
             mem,
-            &mut self.tap,
+            &self.tap,
             queue,
             &mut self.rx_rate_limiter,
             self.access_platform.as_ref(),

net_util/src/tap.rs

@@ -203,7 +203,7 @@ impl Tap {
         let mut ifreq: net_gen::ifreq = Default::default();
 
         // Get current config including name
-        // SAFETY: IOCTL with correct arugments
+        // SAFETY: IOCTL with correct arguments
         unsafe { Self::ioctl_with_mut_ref(&tap_file, net_gen::TUNGETIFF(), &mut ifreq)? };
 
         // SAFETY: We only access one field of the ifru union

pci/Cargo.toml

@@ -10,7 +10,7 @@ kvm = ["vfio-ioctls/kvm"]
 mshv = ["vfio-ioctls/mshv"]
 
 [dependencies]
-anyhow = "1.0.71"
+anyhow = "1.0.75"
 byteorder = "1.4.3"
 hypervisor = { path = "../hypervisor" }
 vfio-bindings = { git = "https://github.com/rust-vmm/vfio", branch = "main", features = ["fam-wrappers"] }
@@ -18,13 +18,13 @@ vfio-ioctls = { git = "https://github.com/rust-vmm/vfio", branch = "main", defau
 vfio_user = { git = "https://github.com/rust-vmm/vfio-user", branch = "main" }
 
 vmm-sys-util = "0.11.0"
-libc = "0.2.139"
+libc = "0.2.147"
 log = "0.4.17"
-serde = { version = "1.0.164", features = ["derive"] }
+serde = { version = "1.0.168", features = ["derive"] }
 thiserror = "1.0.40"
 versionize = "0.1.10"
 versionize_derive = "0.1.4"
 vm-allocator = { path = "../vm-allocator" }
 vm-device = { path = "../vm-device" }
-vm-memory = { version = "0.11.0", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
+vm-memory = { version = "0.12.2", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
 vm-migration = { path = "../vm-migration" }

pci/src/configuration.rs

@@ -265,10 +265,10 @@ pub enum PciExpressCapabilityId {
     VendorSpecificExtendedCapability = 0x000b,
     ConfigurationAccessCorrelation = 0x000c,
     AccessControlServices = 0x000d,
-    AlternativeRoutingIdentificationIntepretation = 0x000e,
+    AlternativeRoutingIdentificationInterpretation = 0x000e,
     AddressTranslationServices = 0x000f,
     SingleRootIoVirtualization = 0x0010,
-    DeprecatedMultiRootIoVirtualzation = 0x0011,
+    DeprecatedMultiRootIoVirtualization = 0x0011,
     Multicast = 0x0012,
     PageRequestInterface = 0x0013,
     ReservedForAmd = 0x0014,
@@ -279,7 +279,7 @@ pub enum PciExpressCapabilityId {
     SecondaryPciExpress = 0x0019,
     ProtocolMultiplexing = 0x001a,
     ProcessAddressSpaceId = 0x001b,
-    LnRequestor = 0x001c,
+    LnRequester = 0x001c,
     DownstreamPortContainment = 0x001d,
     L1PmSubstates = 0x001e,
     PrecisionTimeMeasurement = 0x001f,
@@ -319,10 +319,10 @@ impl From<u16> for PciExpressCapabilityId {
             0x000b => PciExpressCapabilityId::VendorSpecificExtendedCapability,
             0x000c => PciExpressCapabilityId::ConfigurationAccessCorrelation,
             0x000d => PciExpressCapabilityId::AccessControlServices,
-            0x000e => PciExpressCapabilityId::AlternativeRoutingIdentificationIntepretation,
+            0x000e => PciExpressCapabilityId::AlternativeRoutingIdentificationInterpretation,
             0x000f => PciExpressCapabilityId::AddressTranslationServices,
             0x0010 => PciExpressCapabilityId::SingleRootIoVirtualization,
-            0x0011 => PciExpressCapabilityId::DeprecatedMultiRootIoVirtualzation,
+            0x0011 => PciExpressCapabilityId::DeprecatedMultiRootIoVirtualization,
             0x0012 => PciExpressCapabilityId::Multicast,
             0x0013 => PciExpressCapabilityId::PageRequestInterface,
             0x0014 => PciExpressCapabilityId::ReservedForAmd,
@@ -333,7 +333,7 @@ impl From<u16> for PciExpressCapabilityId {
             0x0019 => PciExpressCapabilityId::SecondaryPciExpress,
             0x001a => PciExpressCapabilityId::ProtocolMultiplexing,
             0x001b => PciExpressCapabilityId::ProcessAddressSpaceId,
-            0x001c => PciExpressCapabilityId::LnRequestor,
+            0x001c => PciExpressCapabilityId::LnRequester,
             0x001d => PciExpressCapabilityId::DownstreamPortContainment,
             0x001e => PciExpressCapabilityId::L1PmSubstates,
             0x001f => PciExpressCapabilityId::PrecisionTimeMeasurement,

pci/src/msi.rs

@@ -205,10 +205,15 @@ impl MsiConfig {
                             idx as InterruptIndex,
                             InterruptSourceConfig::MsiIrq(config),
                             state.cap.vector_masked(idx),
+                            false,
                         )
                         .map_err(Error::UpdateInterruptRoute)?;
                 }
 
+                interrupt_source_group
+                    .set_gsi()
+                    .map_err(Error::EnableInterruptRoute)?;
+
                 interrupt_source_group
                     .enable()
                     .map_err(Error::EnableInterruptRoute)?;
@@ -262,6 +267,7 @@ impl MsiConfig {
                     idx as InterruptIndex,
                     InterruptSourceConfig::MsiIrq(config),
                     self.cap.vector_masked(idx),
+                    true,
                 ) {
                     error!("Failed updating vector: {:?}", e);
                 }

pci/src/msix.rs

@@ -107,6 +107,7 @@ impl MsixConfig {
                             idx as InterruptIndex,
                             InterruptSourceConfig::MsiIrq(config),
                             state.masked,
+                            true,
                         )
                         .map_err(Error::UpdateInterruptRoute)?;
 
@@ -182,6 +183,7 @@ impl MsixConfig {
                         idx as InterruptIndex,
                         InterruptSourceConfig::MsiIrq(config),
                         table_entry.masked(),
+                        true,
                     ) {
                         error!("Failed updating vector: {:?}", e);
                     }
@@ -320,6 +322,7 @@ impl MsixConfig {
                 index as InterruptIndex,
                 InterruptSourceConfig::MsiIrq(config),
                 table_entry.masked(),
+                true,
             ) {
                 error!("Failed updating vector: {:?}", e);
             }

pci/src/vfio.rs

@@ -502,27 +502,31 @@ 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.
+    /// In case msix table offset is not page size aligned, we need do some fixup to achieve it.
+    /// Because 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;
+        if let Some(msix) = self.interrupt.msix.as_mut() {
+            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;
+            // 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
+        } else {
+            // MSI-X not supported for this device
+            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(
@@ -907,7 +911,7 @@ impl VfioCommon {
             let cap_next: u16 = ((ext_cap_hdr >> 20) & 0xfff) as u16;
 
             match PciExpressCapabilityId::from(cap_id) {
-                PciExpressCapabilityId::AlternativeRoutingIdentificationIntepretation
+                PciExpressCapabilityId::AlternativeRoutingIdentificationInterpretation
                 | PciExpressCapabilityId::ResizeableBar
                 | PciExpressCapabilityId::SingleRootIoVirtualization => {
                     let reg_idx = (current_offset / 4) as usize;
@@ -1407,7 +1411,7 @@ impl VfioPciDevice {
                     // 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. If these region don't align
-                    // with pagesize, we can achive it by enlarging its range.
+                    // with pagesize, we can achieve 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.

performance-metrics/Cargo.toml

@@ -8,8 +8,8 @@ build = "../build.rs"
 [dependencies]
 argh = "0.1.9"
 dirs = "5.0.0"
-serde = { version = "1.0.164", features = ["rc", "derive"] }
-serde_json = "1.0.96"
+serde = { version = "1.0.168", features = ["rc", "derive"] }
+serde_json = "1.0.107"
 test_infra = { path = "../test_infra" }
 thiserror = "1.0.40"
 wait-timeout = "0.2.0"

qcow/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "qcow"
-version = "0.1.0"
-authors = ["The Chromium OS Authors"]
-edition = "2021"
-license = "BSD-3-Clause"
-
-[lib]
-path = "src/qcow.rs"
-
-[dependencies]
-byteorder = "1.4.3"
-libc = "0.2.139"
-log = "0.4.17"
-remain = "0.2.6"
-vmm-sys-util = "0.11.0"

rate_limiter/Cargo.toml

@@ -4,6 +4,6 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-libc = "0.2.139"
+libc = "0.2.147"
 log = "0.4.17"
 vmm-sys-util = "0.11.0"

rate_limiter/src/lib.rs

@@ -46,9 +46,11 @@
 #[macro_use]
 extern crate log;
 
+use std::io;
 use std::os::unix::io::{AsRawFd, RawFd};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Mutex;
 use std::time::{Duration, Instant};
-use std::{fmt, io};
 use vmm_sys_util::timerfd::TimerFd;
 
 #[derive(Debug)]
@@ -271,27 +273,27 @@ pub enum BucketUpdate {
 /// implementation. These events are meant to be consumed by the user of this struct.
 /// On each such event, the user must call the `event_handler()` method.
 pub struct RateLimiter {
+    inner: Mutex<RateLimiterInner>,
+
+    // Internal flag that quickly determines timer state.
+    timer_active: AtomicBool,
+}
+
+struct RateLimiterInner {
     bandwidth: Option<TokenBucket>,
     ops: Option<TokenBucket>,
 
     timer_fd: TimerFd,
-    // Internal flag that quickly determines timer state.
-    timer_active: bool,
 }
 
-impl PartialEq for RateLimiter {
-    fn eq(&self, other: &RateLimiter) -> bool {
-        self.bandwidth == other.bandwidth && self.ops == other.ops
-    }
-}
-
-impl fmt::Debug for RateLimiter {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "RateLimiter {{ bandwidth: {:?}, ops: {:?} }}",
-            self.bandwidth, self.ops
-        )
+impl RateLimiterInner {
+    // Arm the timer of the rate limiter with the provided `Duration` (which will fire only once).
+    fn activate_timer(&mut self, dur: Duration, flag: &AtomicBool) {
+        // Panic when failing to arm the timer (same handling in crate TimerFd::set_state())
+        self.timer_fd
+            .reset(dur, None)
+            .expect("Can't arm the timer (unexpected 'timerfd_settime' failure).");
+        flag.store(true, Ordering::Relaxed)
     }
 }
 
@@ -355,35 +357,28 @@ impl RateLimiter {
         }
 
         Ok(RateLimiter {
-            bandwidth: bytes_token_bucket,
-            ops: ops_token_bucket,
-            timer_fd,
-            timer_active: false,
+            inner: Mutex::new(RateLimiterInner {
+                bandwidth: bytes_token_bucket,
+                ops: ops_token_bucket,
+                timer_fd,
+            }),
+            timer_active: AtomicBool::new(false),
         })
     }
 
-    // Arm the timer of the rate limiter with the provided `Duration` (which will fire only once).
-    fn activate_timer(&mut self, dur: Duration) {
-        // Panic when failing to arm the timer (same handling in crate TimerFd::set_state())
-        self.timer_fd
-            .reset(dur, None)
-            .expect("Can't arm the timer (unexpected 'timerfd_settime' failure).");
-        self.timer_active = true;
-    }
-
     /// Attempts to consume tokens and returns whether that is possible.
     ///
     /// If rate limiting is disabled on provided `token_type`, this function will always succeed.
-    pub fn consume(&mut self, tokens: u64, token_type: TokenType) -> bool {
+    pub fn consume(&self, tokens: u64, token_type: TokenType) -> bool {
         // If the timer is active, we can't consume tokens from any bucket and the function fails.
-        if self.timer_active {
+        if self.is_blocked() {
             return false;
         }
-
+        let mut guard = self.inner.lock().unwrap();
         // Identify the required token bucket.
         let token_bucket = match token_type {
-            TokenType::Bytes => self.bandwidth.as_mut(),
-            TokenType::Ops => self.ops.as_mut(),
+            TokenType::Bytes => guard.bandwidth.as_mut(),
+            TokenType::Ops => guard.ops.as_mut(),
         };
         // Try to consume from the token bucket.
         if let Some(bucket) = token_bucket {
@@ -393,8 +388,8 @@ impl RateLimiter {
                 // register a timer to replenish the bucket and resume processing;
                 // make sure there is only one running timer for this limiter.
                 BucketReduction::Failure => {
-                    if !self.timer_active {
-                        self.activate_timer(TIMER_REFILL_DUR);
+                    if !self.is_blocked() {
+                        guard.activate_timer(TIMER_REFILL_DUR, &self.timer_active);
                     }
                     false
                 }
@@ -409,7 +404,10 @@ impl RateLimiter {
                     // order to enforce the bandwidth limit we need to prevent
                     // further calls to the rate limiter for
                     // `ratio * refill_time` milliseconds.
-                    self.activate_timer(Duration::from_millis((ratio * refill_time as f64) as u64));
+                    guard.activate_timer(
+                        Duration::from_millis((ratio * refill_time as f64) as u64),
+                        &self.timer_active,
+                    );
                     true
                 }
             }
@@ -424,11 +422,12 @@ impl RateLimiter {
     ///
     /// Can be used to *manually* add tokens to a bucket. Useful for reverting a
     /// `consume()` if needed.
-    pub fn manual_replenish(&mut self, tokens: u64, token_type: TokenType) {
+    pub fn manual_replenish(&self, tokens: u64, token_type: TokenType) {
+        let mut guard = self.inner.lock().unwrap();
         // Identify the required token bucket.
         let token_bucket = match token_type {
-            TokenType::Bytes => self.bandwidth.as_mut(),
-            TokenType::Ops => self.ops.as_mut(),
+            TokenType::Bytes => guard.bandwidth.as_mut(),
+            TokenType::Ops => guard.ops.as_mut(),
         };
         // Add tokens to the token bucket.
         if let Some(bucket) = token_bucket {
@@ -442,7 +441,7 @@ impl RateLimiter {
     /// budget for it.
     /// An event will be generated on the exported FD when the limiter 'unblocks'.
     pub fn is_blocked(&self) -> bool {
-        self.timer_active
+        self.timer_active.load(Ordering::Relaxed)
     }
 
     /// This function needs to be called every time there is an event on the
@@ -451,11 +450,12 @@ impl RateLimiter {
     /// # Errors
     ///
     /// If the rate limiter is disabled or is not blocked, an error is returned.
-    pub fn event_handler(&mut self) -> Result<(), Error> {
+    pub fn event_handler(&self) -> Result<(), Error> {
+        let mut guard = self.inner.lock().unwrap();
         loop {
             // Note: As we manually added the `O_NONBLOCK` flag to the FD, the following
             // `timer_fd::wait()` won't block (which is different from its default behavior.)
-            match self.timer_fd.wait() {
+            match guard.timer_fd.wait() {
                 Err(e) => {
                     let err: std::io::Error = e.into();
                     match err.kind() {
@@ -469,7 +469,7 @@ impl RateLimiter {
                     }
                 }
                 _ => {
-                    self.timer_active = false;
+                    self.timer_active.store(false, Ordering::Relaxed);
                     return Ok(());
                 }
             }
@@ -479,27 +479,18 @@ impl RateLimiter {
     /// Updates the parameters of the token buckets associated with this RateLimiter.
     // TODO: Please note that, right now, the buckets become full after being updated.
     pub fn update_buckets(&mut self, bytes: BucketUpdate, ops: BucketUpdate) {
+        let mut guard = self.inner.lock().unwrap();
         match bytes {
-            BucketUpdate::Disabled => self.bandwidth = None,
-            BucketUpdate::Update(tb) => self.bandwidth = Some(tb),
+            BucketUpdate::Disabled => guard.bandwidth = None,
+            BucketUpdate::Update(tb) => guard.bandwidth = Some(tb),
             BucketUpdate::None => (),
         };
         match ops {
-            BucketUpdate::Disabled => self.ops = None,
-            BucketUpdate::Update(tb) => self.ops = Some(tb),
+            BucketUpdate::Disabled => guard.ops = None,
+            BucketUpdate::Update(tb) => guard.ops = Some(tb),
             BucketUpdate::None => (),
         };
     }
-
-    /// Returns an immutable view of the inner bandwidth token bucket.
-    pub fn bandwidth(&self) -> Option<&TokenBucket> {
-        self.bandwidth.as_ref()
-    }
-
-    /// Returns an immutable view of the inner ops token bucket.
-    pub fn ops(&self) -> Option<&TokenBucket> {
-        self.ops.as_ref()
-    }
 }
 
 impl AsRawFd for RateLimiter {
@@ -510,7 +501,8 @@ impl AsRawFd for RateLimiter {
     /// Will return a negative value if rate limiting is disabled on both
     /// token types.
     fn as_raw_fd(&self) -> RawFd {
-        self.timer_fd.as_raw_fd()
+        let guard = self.inner.lock().unwrap();
+        guard.timer_fd.as_raw_fd()
     }
 }
 
@@ -525,6 +517,7 @@ impl Default for RateLimiter {
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
+    use std::fmt;
     use std::thread;
     use std::time::Duration;
 
@@ -557,11 +550,33 @@ pub(crate) mod tests {
     }
 
     impl RateLimiter {
-        fn get_token_bucket(&self, token_type: TokenType) -> Option<&TokenBucket> {
-            match token_type {
-                TokenType::Bytes => self.bandwidth.as_ref(),
-                TokenType::Ops => self.ops.as_ref(),
-            }
+        pub fn bandwidth(&self) -> Option<TokenBucket> {
+            let guard = self.inner.lock().unwrap();
+            guard.bandwidth.clone()
+        }
+
+        pub fn ops(&self) -> Option<TokenBucket> {
+            let guard = self.inner.lock().unwrap();
+            guard.ops.clone()
+        }
+    }
+
+    impl PartialEq for RateLimiter {
+        fn eq(&self, other: &RateLimiter) -> bool {
+            let self_guard = self.inner.lock().unwrap();
+            let other_guard = other.inner.lock().unwrap();
+            self_guard.bandwidth == other_guard.bandwidth && self_guard.ops == other_guard.ops
+        }
+    }
+
+    impl fmt::Debug for RateLimiter {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            let guard = self.inner.lock().unwrap();
+            write!(
+                f,
+                "RateLimiter {{ bandwidth: {:?}, ops: {:?} }}",
+                guard.bandwidth, guard.ops
+            )
         }
     }
 
@@ -640,7 +655,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_rate_limiter_default() {
-        let mut l = RateLimiter::default();
+        let l = RateLimiter::default();
 
         // limiter should not be blocked
         assert!(!l.is_blocked());
@@ -659,14 +674,13 @@ pub(crate) mod tests {
     #[test]
     fn test_rate_limiter_new() {
         let l = RateLimiter::new(1000, 1001, 1002, 1003, 1004, 1005).unwrap();
-
-        let bw = l.bandwidth.unwrap();
+        let bw = l.bandwidth().unwrap();
         assert_eq!(bw.capacity(), 1000);
         assert_eq!(bw.one_time_burst(), 1001);
         assert_eq!(bw.refill_time_ms(), 1002);
         assert_eq!(bw.budget(), 1000);
 
-        let ops = l.ops.unwrap();
+        let ops = l.ops().unwrap();
         assert_eq!(ops.capacity(), 1003);
         assert_eq!(ops.one_time_burst(), 1004);
         assert_eq!(ops.refill_time_ms(), 1005);
@@ -676,20 +690,20 @@ pub(crate) mod tests {
     #[test]
     fn test_rate_limiter_manual_replenish() {
         // rate limiter with limit of 1000 bytes/s and 1000 ops/s
-        let mut l = RateLimiter::new(1000, 0, 1000, 1000, 0, 1000).unwrap();
+        let l = RateLimiter::new(1000, 0, 1000, 1000, 0, 1000).unwrap();
 
         // consume 123 bytes
         assert!(l.consume(123, TokenType::Bytes));
         l.manual_replenish(23, TokenType::Bytes);
         {
-            let bytes_tb = l.get_token_bucket(TokenType::Bytes).unwrap();
+            let bytes_tb = l.bandwidth().unwrap();
             assert_eq!(bytes_tb.budget(), 900);
         }
         // consume 123 ops
         assert!(l.consume(123, TokenType::Ops));
         l.manual_replenish(23, TokenType::Ops);
         {
-            let bytes_tb = l.get_token_bucket(TokenType::Ops).unwrap();
+            let bytes_tb = l.ops().unwrap();
             assert_eq!(bytes_tb.budget(), 900);
         }
     }
@@ -697,7 +711,7 @@ pub(crate) mod tests {
     #[test]
     fn test_rate_limiter_bandwidth() {
         // rate limiter with limit of 1000 bytes/s
-        let mut l = RateLimiter::new(1000, 0, 1000, 0, 0, 0).unwrap();
+        let l = RateLimiter::new(1000, 0, 1000, 0, 0, 0).unwrap();
 
         // limiter should not be blocked
         assert!(!l.is_blocked());
@@ -730,7 +744,7 @@ pub(crate) mod tests {
     #[test]
     fn test_rate_limiter_ops() {
         // rate limiter with limit of 1000 ops/s
-        let mut l = RateLimiter::new(0, 0, 0, 1000, 0, 1000).unwrap();
+        let l = RateLimiter::new(0, 0, 0, 1000, 0, 1000).unwrap();
 
         // limiter should not be blocked
         assert!(!l.is_blocked());
@@ -763,7 +777,7 @@ pub(crate) mod tests {
     #[test]
     fn test_rate_limiter_full() {
         // rate limiter with limit of 1000 bytes/s and 1000 ops/s
-        let mut l = RateLimiter::new(1000, 0, 1000, 1000, 0, 1000).unwrap();
+        let l = RateLimiter::new(1000, 0, 1000, 1000, 0, 1000).unwrap();
 
         // limiter should not be blocked
         assert!(!l.is_blocked());
@@ -799,7 +813,7 @@ pub(crate) mod tests {
     #[test]
     fn test_rate_limiter_overconsumption() {
         // initialize the rate limiter
-        let mut l = RateLimiter::new(1000, 0, 1000, 1000, 0, 1000).unwrap();
+        let l = RateLimiter::new(1000, 0, 1000, 1000, 0, 1000).unwrap();
         // try to consume 2.5x the bucket size
         // we are "borrowing" 1.5x the bucket size in tokens since
         // the bucket is full
@@ -818,7 +832,7 @@ pub(crate) mod tests {
         assert!(!l.is_blocked());
 
         // reset the rate limiter
-        let mut l = RateLimiter::new(1000, 0, 1000, 1000, 0, 1000).unwrap();
+        let l = RateLimiter::new(1000, 0, 1000, 1000, 0, 1000).unwrap();
         // try to consume 1.5x the bucket size
         // we are "borrowing" 1.5x the bucket size in tokens since
         // the bucket is full, should arm the timer to 0.5x replenish
@@ -846,7 +860,7 @@ pub(crate) mod tests {
         assert!(!l.consume(100, TokenType::Bytes));
 
         // after waiting out the full duration, rate limiter should be
-        // availale again
+        // available again
         thread::sleep(Duration::from_millis(200));
         assert!(l.event_handler().is_ok());
         assert!(!l.is_blocked());
@@ -857,12 +871,12 @@ pub(crate) mod tests {
     fn test_update_buckets() {
         let mut x = RateLimiter::new(1000, 2000, 1000, 10, 20, 1000).unwrap();
 
-        let initial_bw = x.bandwidth.clone();
-        let initial_ops = x.ops.clone();
+        let initial_bw = x.bandwidth();
+        let initial_ops = x.ops();
 
         x.update_buckets(BucketUpdate::None, BucketUpdate::None);
-        assert_eq!(x.bandwidth, initial_bw);
-        assert_eq!(x.ops, initial_ops);
+        assert_eq!(x.bandwidth(), initial_bw);
+        assert_eq!(x.ops(), initial_ops);
 
         let new_bw = TokenBucket::new(123, 0, 57).unwrap();
         let new_ops = TokenBucket::new(321, 12346, 89).unwrap();
@@ -871,18 +885,21 @@ pub(crate) mod tests {
             BucketUpdate::Update(new_ops.clone()),
         );
 
-        // We have manually adjust the last_update field, because it changes when update_buckets()
-        // constructs new buckets (and thus gets a different value for last_update). We do this so
-        // it makes sense to test the following assertions.
-        x.bandwidth.as_mut().unwrap().last_update = new_bw.last_update;
-        x.ops.as_mut().unwrap().last_update = new_ops.last_update;
+        {
+            let mut guard = x.inner.lock().unwrap();
+            // We have manually adjust the last_update field, because it changes when update_buckets()
+            // constructs new buckets (and thus gets a different value for last_update). We do this so
+            // it makes sense to test the following assertions.
+            guard.bandwidth.as_mut().unwrap().last_update = new_bw.last_update;
+            guard.ops.as_mut().unwrap().last_update = new_ops.last_update;
+        }
 
-        assert_eq!(x.bandwidth, Some(new_bw));
-        assert_eq!(x.ops, Some(new_ops));
+        assert_eq!(x.bandwidth(), Some(new_bw));
+        assert_eq!(x.ops(), Some(new_ops));
 
         x.update_buckets(BucketUpdate::Disabled, BucketUpdate::Disabled);
-        assert_eq!(x.bandwidth, None);
-        assert_eq!(x.ops, None);
+        assert_eq!(x.bandwidth(), None);
+        assert_eq!(x.ops(), None);
     }
 
     #[test]

release-notes.md

@@ -1,13 +1,27 @@
-- [v33.0](#v330)
-    - [D-Bus based API](#d-bus-based-api)
-    - [Passthrough CPU cache information for AArch64](#passthrough-cpu-cache-information-for-aarch64)
+- [v35.1](#v351)
+- [v35.0](#v350)
+    - [`virtio-vsock` Support for Linux Guest Kernel v6.3+](#virtio-vsock-support-for-linux-guest-kernel-v63)
+    - [User Specified Serial Number for `virtio-block`](#user-specified-serial-number-for-virtio-block)
+    - [vCPU TSC Frequency Included in Migration State](#vcpu-tsc-frequency-included-in-migration-state)
     - [Notable Bug Fixes](#notable-bug-fixes)
     - [Contributors](#contributors)
+- [v34.0](#v340)
+    - [Paravirtualised Panic Device Support](#paravirtualised-panic-device-support)
+    - [Improvements to VM Core Dump](#improvements-to-vm-core-dump)
+    - [QCOW2 Support for Backing Files](#qcow2-support-for-backing-files)
+    - [Minimum Host Kernel Bump](#minimum-host-kernel-bump)
+    - [Notable Bug Fixes](#notable-bug-fixes-1)
+    - [Contributors](#contributors-1)
+- [v33.0](#v330)
+    - [D-Bus based API](#d-bus-based-api)
+    - [Expose Host CPU Cache Details for AArch64](#expose-host-cpu-cache-details-for-aarch64)
+    - [Notable Bug Fixes](#notable-bug-fixes-2)
+    - [Contributors](#contributors-2)
 - [v32.0](#v320)
     - [Increased PCI Segment Limit](#increased-pci-segment-limit)
     - [API Changes](#api-changes)
-    - [Notable Bug Fixes](#notable-bug-fixes-1)
-    - [Contributors](#contributors-1)
+    - [Notable Bug Fixes](#notable-bug-fixes-3)
+    - [Contributors](#contributors-3)
 - [v31.1](#v311)
 - [v31.0](#v310)
     - [Update to Latest `acpi_tables`](#update-to-latest-acpi_tables)
@@ -15,15 +29,15 @@
     - [Improvements on Console `SIGWINCH` Handler](#improvements-on-console-sigwinch-handler)
     - [Remove Directory Support from `MemoryZoneConfig::file`](#remove-directory-support-from-memoryzoneconfigfile)
     - [Documentation Improvements](#documentation-improvements)
-    - [Notable Bug Fixes](#notable-bug-fixes-2)
-    - [Contributors](#contributors-2)
+    - [Notable Bug Fixes](#notable-bug-fixes-4)
+    - [Contributors](#contributors-4)
 - [v30.0](#v300)
     - [Command Line Changes for Reduced Binary Size](#command-line-changes-for-reduced-binary-size)
     - [Basic vfio-user Server Support](#basic-vfio-user-server-support)
     - [Heap Profiling Support](#heap-profiling-support)
     - [Documentation Improvements](#documentation-improvements-1)
-    - [Notable Bug Fixes](#notable-bug-fixes-3)
-    - [Contributors](#contributors-3)
+    - [Notable Bug Fixes](#notable-bug-fixes-5)
+    - [Contributors](#contributors-5)
 - [v28.2](#v282)
 - [v29.0](#v290)
     - [Release Binary Supports Both MSHV and KVM](#release-binary-supports-both-mshv-and-kvm)
@@ -33,10 +47,10 @@
     - [`AArch64` Documentation Integration](#aarch64-documentation-integration)
     - [`virtio-block` Counters Enhancement](#virtio-block-counters-enhancement)
     - [TCP Offload Control](#tcp-offload-control)
-    - [Notable Bug Fixes](#notable-bug-fixes-4)
+    - [Notable Bug Fixes](#notable-bug-fixes-6)
     - [Removals](#removals)
     - [Deprecations](#deprecations)
-    - [Contributors](#contributors-4)
+    - [Contributors](#contributors-6)
 - [v28.1](#v281)
 - [v28.0](#v280)
     - [Community Engagement (Reminder)](#community-engagement-reminder)
@@ -44,9 +58,9 @@
     - [Virtualised TPM Support](#virtualised-tpm-support)
     - [Transparent Huge Page Support](#transparent-huge-page-support)
     - [README Quick Start Improved](#readme-quick-start-improved)
-    - [Notable Bug Fixes](#notable-bug-fixes-5)
+    - [Notable Bug Fixes](#notable-bug-fixes-7)
     - [Removals](#removals-1)
-    - [Contributors](#contributors-5)
+    - [Contributors](#contributors-7)
 - [v27.0](#v270)
     - [Community Engagement](#community-engagement)
     - [Prebuilt Packages](#prebuilt-packages)
@@ -55,41 +69,41 @@
     - [Simplified Build Feature Flags](#simplified-build-feature-flags)
     - [Asynchronous Kernel Loading](#asynchronous-kernel-loading)
     - [GDB Support for AArch64](#gdb-support-for-aarch64)
-    - [Notable Bug Fixes](#notable-bug-fixes-6)
+    - [Notable Bug Fixes](#notable-bug-fixes-8)
     - [Deprecations](#deprecations-1)
-    - [Contributors](#contributors-6)
+    - [Contributors](#contributors-8)
 - [v26.0](#v260)
     - [SMBIOS Improvements via `--platform`](#smbios-improvements-via---platform)
     - [Unified Binary MSHV and KVM Support](#unified-binary-mshv-and-kvm-support)
-    - [Notable Bug Fixes](#notable-bug-fixes-7)
+    - [Notable Bug Fixes](#notable-bug-fixes-9)
     - [Deprecations](#deprecations-2)
     - [Removals](#removals-2)
-    - [Contributors](#contributors-7)
+    - [Contributors](#contributors-9)
 - [v25.0](#v250)
     - [`ch-remote` Improvements](#ch-remote-improvements-1)
     - [VM "Coredump" Support](#vm-coredump-support)
-    - [Notable Bug Fixes](#notable-bug-fixes-8)
+    - [Notable Bug Fixes](#notable-bug-fixes-10)
     - [Removals](#removals-3)
-    - [Contributors](#contributors-8)
+    - [Contributors](#contributors-10)
 - [v24.0](#v240)
     - [Bypass Mode for `virtio-iommu`](#bypass-mode-for-virtio-iommu)
     - [Ensure Identifiers Uniqueness](#ensure-identifiers-uniqueness)
     - [Sparse Mmap support](#sparse-mmap-support)
     - [Expose Platform Serial Number](#expose-platform-serial-number)
-    - [Notable Bug Fixes](#notable-bug-fixes-9)
+    - [Notable Bug Fixes](#notable-bug-fixes-11)
     - [Notable Improvements](#notable-improvements)
     - [Deprecations](#deprecations-3)
     - [New on the Website](#new-on-the-website)
-    - [Contributors](#contributors-9)
+    - [Contributors](#contributors-11)
 - [v23.1](#v231)
 - [v23.0](#v230)
     - [vDPA Support](#vdpa-support)
     - [Updated OS Support list](#updated-os-support-list)
     - [`AArch64` Memory Map Improvements](#aarch64-memory-map-improvements)
     - [`AMX` Support](#amx-support)
-    - [Notable Bug Fixes](#notable-bug-fixes-10)
+    - [Notable Bug Fixes](#notable-bug-fixes-12)
     - [Deprecations](#deprecations-4)
-    - [Contributors](#contributors-10)
+    - [Contributors](#contributors-12)
 - [v22.1](#v221)
 - [v22.0](#v220)
     - [GDB Debug Stub Support](#gdb-debug-stub-support)
@@ -100,13 +114,13 @@
     - [PMU Support for AArch64](#pmu-support-for-aarch64)
     - [Documentation Under CC-BY-4.0 License](#documentation-under-cc-by-40-license)
     - [Deprecation of "Classic" `virtiofsd`](#deprecation-of-classic-virtiofsd)
-    - [Notable Bug Fixes](#notable-bug-fixes-11)
-    - [Contributors](#contributors-11)
+    - [Notable Bug Fixes](#notable-bug-fixes-13)
+    - [Contributors](#contributors-13)
 - [v21.0](#v210)
     - [Efficient Local Live Migration (for Live Upgrade)](#efficient-local-live-migration-for-live-upgrade)
     - [Recommended Kernel is Now 5.15](#recommended-kernel-is-now-515)
-    - [Notable Bug fixes](#notable-bug-fixes-12)
-    - [Contributors](#contributors-12)
+    - [Notable Bug fixes](#notable-bug-fixes-14)
+    - [Contributors](#contributors-14)
 - [v20.2](#v202)
 - [v20.1](#v201)
 - [v20.0](#v200)
@@ -115,8 +129,8 @@
     - [Improved VFIO support](#improved-vfio-support)
     - [Safer code](#safer-code)
     - [Extended documentation](#extended-documentation)
-    - [Notable bug fixes](#notable-bug-fixes-13)
-    - [Contributors](#contributors-13)
+    - [Notable bug fixes](#notable-bug-fixes-15)
+    - [Contributors](#contributors-15)
 - [v19.0](#v190)
     - [Improved PTY handling for serial and `virtio-console`](#improved-pty-handling-for-serial-and-virtio-console)
     - [PCI boot time optimisations](#pci-boot-time-optimisations)
@@ -124,8 +138,8 @@
     - [Live migration enhancements](#live-migration-enhancements)
     - [`virtio-mem` support with `vfio-user`](#virtio-mem-support-with-vfio-user)
     - [AArch64 for `virtio-iommu`](#aarch64-for-virtio-iommu)
-    - [Notable bug fixes](#notable-bug-fixes-14)
-    - [Contributors](#contributors-14)
+    - [Notable bug fixes](#notable-bug-fixes-16)
+    - [Contributors](#contributors-16)
 - [v18.0](#v180)
     - [Experimental User Device (`vfio-user`) support](#experimental-user-device-vfio-user-support)
     - [Migration support for `vhost-user` devices](#migration-support-for-vhost-user-devices)
@@ -135,23 +149,23 @@
     - [Live migration on MSHV hypervisor](#live-migration-on-mshv-hypervisor)
     - [AArch64 CPU topology support](#aarch64-cpu-topology-support)
     - [Power button support on AArch64](#power-button-support-on-aarch64)
-    - [Notable bug fixes](#notable-bug-fixes-15)
-    - [Contributors](#contributors-15)
+    - [Notable bug fixes](#notable-bug-fixes-17)
+    - [Contributors](#contributors-17)
 - [v17.0](#v170)
     - [ARM64 NUMA support using ACPI](#arm64-numa-support-using-acpi)
     - [`Seccomp` support for MSHV backend](#seccomp-support-for-mshv-backend)
     - [Hotplug of `macvtap` devices](#hotplug-of-macvtap-devices)
     - [Improved SGX support](#improved-sgx-support)
     - [Inflight tracking for `vhost-user` devices](#inflight-tracking-for-vhost-user-devices)
-    - [Notable bug fixes](#notable-bug-fixes-16)
-    - [Contributors](#contributors-16)
+    - [Notable bug fixes](#notable-bug-fixes-18)
+    - [Contributors](#contributors-18)
 - [v16.0](#v160)
     - [Improved live migration support](#improved-live-migration-support)
     - [Improved `vhost-user` support](#improved-vhost-user-support)
     - [ARM64 ACPI and UEFI support](#arm64-acpi-and-uefi-support)
-    - [Notable bug fixes](#notable-bug-fixes-17)
+    - [Notable bug fixes](#notable-bug-fixes-19)
     - [Removed functionality](#removed-functionality)
-    - [Contributors](#contributors-17)
+    - [Contributors](#contributors-19)
 - [v15.0](#v150)
     - [Version numbering and stability guarantees](#version-numbering-and-stability-guarantees)
     - [Network device rate limiting](#network-device-rate-limiting)
@@ -159,7 +173,7 @@
     - [`--api-socket` supports file descriptor parameter](#--api-socket-supports-file-descriptor-parameter)
     - [Bug fixes](#bug-fixes)
     - [Deprecations](#deprecations-5)
-    - [Contributors](#contributors-18)
+    - [Contributors](#contributors-20)
 - [v0.14.1](#v0141)
 - [v0.14.0](#v0140)
     - [Structured event monitoring](#structured-event-monitoring)
@@ -169,7 +183,7 @@
     - [PTY control for serial and `virtio-console`](#pty-control-for-serial-and-virtio-console)
     - [Block device rate limiting](#block-device-rate-limiting)
     - [Deprecations](#deprecations-6)
-    - [Contributors](#contributors-19)
+    - [Contributors](#contributors-21)
 - [v0.13.0](#v0130)
     - [Wider VFIO device support](#wider-vfio-device-support)
     - [Improved huge page support](#improved-huge-page-support)
@@ -177,13 +191,13 @@
     - [VHD disk image support](#vhd-disk-image-support)
     - [Improved Virtio device threading](#improved-virtio-device-threading)
     - [Clean shutdown support via synthetic power button](#clean-shutdown-support-via-synthetic-power-button)
-    - [Contributors](#contributors-20)
+    - [Contributors](#contributors-22)
 - [v0.12.0](#v0120)
     - [ARM64 enhancements](#arm64-enhancements)
     - [Removal of `vhost-user-net` and `vhost-user-block` self spawning](#removal-of-vhost-user-net-and-vhost-user-block-self-spawning)
     - [Migration of `vhost-user-fs` backend](#migration-of-vhost-user-fs-backend)
     - [Enhanced "info" API](#enhanced-info-api)
-    - [Contributors](#contributors-21)
+    - [Contributors](#contributors-23)
 - [v0.11.0](#v0110)
     - [`io_uring` support by default for `virtio-block`](#io_uring-support-by-default-for-virtio-block)
     - [Windows Guest Support](#windows-guest-support)
@@ -195,15 +209,15 @@
     - [Default Log Level Changed](#default-log-level-changed)
     - [New `--balloon` Parameter Added](#new---balloon-parameter-added)
     - [Experimental `virtio-watchdog` Support](#experimental-virtio-watchdog-support)
-    - [Notable Bug Fixes](#notable-bug-fixes-18)
-    - [Contributors](#contributors-22)
+    - [Notable Bug Fixes](#notable-bug-fixes-20)
+    - [Contributors](#contributors-24)
 - [v0.10.0](#v0100)
     - [`virtio-block` Support for Multiple Descriptors](#virtio-block-support-for-multiple-descriptors)
     - [Memory Zones](#memory-zones)
     - [`Seccomp` Sandbox Improvements](#seccomp-sandbox-improvements)
     - [Preliminary KVM HyperV Emulation Control](#preliminary-kvm-hyperv-emulation-control)
-    - [Notable Bug Fixes](#notable-bug-fixes-19)
-    - [Contributors](#contributors-23)
+    - [Notable Bug Fixes](#notable-bug-fixes-21)
+    - [Contributors](#contributors-25)
 - [v0.9.0](#v090)
     - [`io_uring` Based Block Device Support](#io_uring-based-block-device-support)
     - [Block and Network Device Statistics](#block-and-network-device-statistics)
@@ -216,17 +230,17 @@
     - [Enhancements to ARM64 Support](#enhancements-to-arm64-support)
     - [Intel SGX Support](#intel-sgx-support)
     - [`Seccomp` Sandbox Improvements](#seccomp-sandbox-improvements-1)
-    - [Notable Bug Fixes](#notable-bug-fixes-20)
-    - [Contributors](#contributors-24)
+    - [Notable Bug Fixes](#notable-bug-fixes-22)
+    - [Contributors](#contributors-26)
 - [v0.8.0](#v080)
     - [Experimental Snapshot and Restore Support](#experimental-snapshot-and-restore-support)
     - [Experimental ARM64 Support](#experimental-arm64-support)
     - [Support for Using 5-level Paging in Guests](#support-for-using-5-level-paging-in-guests)
     - [Virtio Device Interrupt Suppression for Network Devices](#virtio-device-interrupt-suppression-for-network-devices)
     - [`vhost_user_fs` Improvements](#vhost_user_fs-improvements)
-    - [Notable Bug Fixes](#notable-bug-fixes-21)
+    - [Notable Bug Fixes](#notable-bug-fixes-23)
     - [Command Line and API Changes](#command-line-and-api-changes)
-    - [Contributors](#contributors-25)
+    - [Contributors](#contributors-27)
 - [v0.7.0](#v070)
     - [Block, Network, Persistent Memory (PMEM), VirtioFS and Vsock hotplug](#block-network-persistent-memory-pmem-virtiofs-and-vsock-hotplug)
     - [Alternative `libc` Support](#alternative-libc-support)
@@ -236,14 +250,14 @@
     - [`Seccomp` Sandboxing](#seccomp-sandboxing)
     - [Updated Distribution Support](#updated-distribution-support)
     - [Command Line and API Changes](#command-line-and-api-changes-1)
-    - [Contributors](#contributors-26)
+    - [Contributors](#contributors-28)
 - [v0.6.0](#v060)
     - [Directly Assigned Devices Hotplug](#directly-assigned-devices-hotplug)
     - [Shared Filesystem Improvements](#shared-filesystem-improvements)
     - [Block and Networking IO Self Offloading](#block-and-networking-io-self-offloading)
     - [Command Line Interface](#command-line-interface)
     - [PVH Boot](#pvh-boot)
-    - [Contributors](#contributors-27)
+    - [Contributors](#contributors-29)
 - [v0.5.1](#v051)
 - [v0.5.0](#v050)
     - [Virtual Machine Dynamic Resizing](#virtual-machine-dynamic-resizing)
@@ -251,7 +265,7 @@
     - [New Interrupt Management Framework](#new-interrupt-management-framework)
     - [Development Tools](#development-tools)
     - [Kata Containers Integration](#kata-containers-integration)
-    - [Contributors](#contributors-28)
+    - [Contributors](#contributors-30)
 - [v0.4.0](#v040)
     - [Dynamic virtual CPUs addition](#dynamic-virtual-cpus-addition)
     - [Programmatic firmware tables generation](#programmatic-firmware-tables-generation)
@@ -260,7 +274,7 @@
     - [Userspace IOAPIC by default](#userspace-ioapic-by-default)
     - [PCI BAR reprogramming](#pci-bar-reprogramming)
     - [New `cloud-hypervisor` organization](#new-cloud-hypervisor-organization)
-    - [Contributors](#contributors-29)
+    - [Contributors](#contributors-31)
 - [v0.3.0](#v030)
     - [Block device offloading](#block-device-offloading)
     - [Network device backend](#network-device-backend)
@@ -287,6 +301,129 @@
     - [Unit testing](#unit-testing)
     - [Integration tests parallelization](#integration-tests-parallelization)
 
+# v35.1
+
+This is a bug fix release. The following issues have been addressed:
+
+* Fix a deadlock when TDX is enabled (#5845)
+* Correct default value for vCPU topology on AArch64 (#5893)
+* Fix PvPanic device PCI BAR alignment (#5956)
+* Bug fix to OpenAPI specification file (#5967)
+* Error out early for live migration when TDX is enabled (#6025)
+
+# v35.0
+
+This release has been tracked in our [roadmap
+project](https://github.com/orgs/cloud-hypervisor/projects/6) as iteration
+v35.0. The following user visible changes have been made:
+
+### `virtio-vsock` Support for Linux Guest Kernel v6.3+
+
+Since kernel v6.3, a vsock packet can be included in a single descriptor,
+instead of being split over two descriptors. Our `virtio-vsock` implementation
+now support both situations.
+
+### User Specified Serial Number for `virtio-block`
+
+A new option `serial` is added to the `--block` command that allows users to
+specify a serial number for block devices which will be guest visible.
+
+### vCPU TSC Frequency Included in Migration State
+
+This ensures migration works correctly between hosts that have different TSC
+frequencies if the guest is running with TSC as the source of timekeeping.
+
+### Notable Bug Fixes
+
+* Disallow concurrent CPU resizing (#5668)
+* Handle APIC EOI message for MSHV (#5681)
+* Use wrapping add for memory offset from instruction emulator (#5719)
+* Add global spell check via the 'typos' GitHub action (#5720)
+* Ensure probing reads are block size aligned (#5727)
+* Multiple bug fixes around the latency counter for block devices
+  (#5712, #5750, #5762, #5763)
+* Replace unsound `static mut` with `once_cell` (#5772)
+
+### Contributors
+
+Many thanks to everyone who has contributed to our release:
+
+*  Alyssa Ross <hi@alyssa.is>
+*  Anatol Belski <anbelski@linux.microsoft.com>
+*  Bo Chen <chen.bo@intel.com>
+*  Christian Blichmann <cblichmann@google.com>
+*  Jianyong Wu <jianyong.wu@arm.com>
+*  Jinank Jain <jinankjain@microsoft.com>
+*  Julian Stecklina <julian.stecklina@cyberus-technology.de>
+*  Omer Faruk Bayram <omer.faruk@sartura.hr>
+*  Philipp Schuster <philipp.schuster@cyberus-technology.de>
+*  Rob Bradford <rbradford@rivosinc.com>
+*  Ruslan Mstoi <ruslan.mstoi@intel.com>
+*  Thomas Barrett <tbarrett@crusoeenergy.com>
+*  Wei Liu <liuwe@microsoft.com>
+*  Yi Wang <foxywang@tencent.com>
+*  zhongbingnan <zhongbingnan@bytedance.com>
+
+# v34.0
+
+This release has been tracked in our [roadmap
+project](https://github.com/orgs/cloud-hypervisor/projects/6) as iteration
+v34.0. The following user visible changes have been made:
+
+### Paravirtualised Panic Device Support
+
+A new device has been added that can communicate when the guest kernel has
+panicked and share those details with the VMM. This is controlled with a new
+`--pvpanic` command line option and JSON API change equivalent. (#5526)
+
+### Improvements to VM Core Dump
+
+Requesting to dump the guest memory as core dump will now transparently pause
+the VM if required; returning to the original state after. (#5604)
+
+### QCOW2 Support for Backing Files
+
+The support for QCOW2 files has been enhanced to include support for using
+backing files. (#5573)
+
+### Minimum Host Kernel Bump
+
+The minimum supported host kernel is now 5.13 in order to incorporate a bug fix
+for `KVM_FEATURE_ASYNC_PF_INT` functionality. (#5626)
+
+### Notable Bug Fixes
+
+* The x86 emulator is only compiled in if MSHV is compiled in (the kernel
+  carries out this job with KVM) (#5561).
+* A regression has been fixed in VFIO support for devices that use MSI rather
+  than MSI-X (#5658).
+* When triggering a VM shutdown or reset via I/O the vCPU thread will be
+  blocked until that asynchronous event has been received (#5645).
+* Pausing a VM is now a synchronous action with the request only completing
+  when all vCPUs are paused (#5611).
+* Event monitor support now correctly supports concurrent access (#5633).
+* Bug fixes for the QCOW2 file support (#5573).
+
+### Contributors
+
+Many thanks to everyone who has contributed to our release:
+
+* Alyssa Ross <hi@alyssa.is>
+* Anatol Belski <anbelski@linux.microsoft.com>
+* Bo Chen <chen.bo@intel.com>
+* Changyuan Lyu <changyuanl@google.com>
+* Christian Blichmann <cblichmann@google.com>
+* Manish Goregaokar <manishsmail@gmail.com>
+* Omer Faruk Bayram <omer.faruk@sartura.hr>
+* Philipp Schuster <philipp.schuster@cyberus-technology.de>
+* Praveen K Paladugu <prapal@linux.microsoft.com>
+* Rob Bradford <rbradford@rivosinc.com>
+* Ruslan Mstoi <ruslan.mstoi@intel.com>
+* Yi Wang <foxywang@tencent.com>
+* Yong He <alexyonghe@tencent.com>
+* Yu Li <liyu.yukiteru@bytedance.com>
+* dom.song <dom.song@amperecomputing.com>
+
 # v33.0
 
 This release has been tracked in our [roadmap
@@ -806,7 +943,7 @@ binary with the detection of the hypervisor to use made at runtime.
 ### Notable Bug Fixes
 
 * The prefetchable flag is preserved on BARs for VFIO devices (#4353, #4454)
-* PCI Express capabilties for functionality we do not support are now filtered
+* PCI Express capabilities for functionality we do not support are now filtered
   out (#4456)
 * GDB breakpoint support is more reliable (#4354, #4363)
 * `SIGINT` and `SIGTERM` signals are now handled before the VM has booted
@@ -1161,10 +1298,10 @@ is now 5.15. (#3530)
 
 ### Notable Bug fixes
 
-* Multiple fixes were made to the OpenAPI YAML file to match the implementaion (#3555,#3562)
+* Multiple fixes were made to the OpenAPI YAML file to match the implementation (#3555,#3562)
 * Avoid live migration deadlock when triggered during the kernel boot (#3585)
 * Support live migration within firmware (#3586)
-* Validate the `virtio-net` desciptor chain (#3548)
+* Validate the `virtio-net` descriptor chain (#3548)
 * `direct=on` (`O_DIRECT`) can now be used with a guest that makes unaligned accesses (e.g. firmware) (#3587)
 
 ### Contributors

resources/Dockerfile

@@ -3,7 +3,7 @@
 # When changing this file don't forget to update the tag name in the
 # .github/workflows/docker-image.yaml file if doing multiple per day
 
-FROM ubuntu:20.04 as dev
+FROM ubuntu:22.04 as dev
 
 ARG TARGETARCH
 ARG RUST_TOOLCHAIN="1.67.1"
@@ -43,7 +43,6 @@ RUN apt-get update \
         socat \
         dosfstools \
         cpio \
-        python \
         python3 \
         python3-setuptools \
         ntfs-3g \
@@ -130,17 +129,18 @@ RUN echo 'source $CARGO_HOME/env' >> "$HOME"/.bashrc \
 RUN if [ "$TARGETARCH" = "amd64" ]; then \
        git clone https://github.com/spdk/spdk \
        && cd spdk \
-       && git checkout 6301f8915de32baed10dba1eebed556a6749211a \
+       && git checkout ef8bcce58f3f02b79c0619a297e4f17e81e62b24 \
        && git submodule update --init \
        && apt-get update \
        && ./scripts/pkgdep.sh \
        && apt-get clean \
        && ./configure --with-vfio-user \
-       && make -j $(nproc) \
+       && make -j $(nproc) TARGET_ARCHITECTURE=skylake \
+       && rm -rf /usr/local/bin/spdk-nvme \
        && mkdir /usr/local/bin/spdk-nvme \
-       && cp ./build/bin/nvmf_tgt /usr/local/bin/spdk-nvme \
-       && cp ./scripts/rpc.py /usr/local/bin/spdk-nvme \
-       && cp -r ./scripts/rpc /usr/local/bin/spdk-nvme \
+       && cp -f ./build/bin/nvmf_tgt /usr/local/bin/spdk-nvme \
+       && cp -f ./scripts/rpc.py /usr/local/bin/spdk-nvme \
+       && cp -rf ./python /usr/local/bin \
        && cd .. && rm -rf spdk; fi
 
 # install swtpm only for x86_64 arch

resources/linux-config-aarch64

@@ -1402,7 +1402,8 @@ CONFIG_NVME_MULTIPATH=y
 # CONFIG_MISC_RTSX_PCI is not set
 # CONFIG_HABANA_AI is not set
 # CONFIG_UACCE is not set
-# CONFIG_PVPANIC is not set
+CONFIG_PVPANIC=y
+CONFIG_PVPANIC_PCI=y
 # CONFIG_GP_PCI1XXXX is not set
 # end of Misc devices
 
@@ -3050,23 +3051,16 @@ CONFIG_SYMBOLIC_ERRNAME=y
 # end of printk and dmesg options
 
 CONFIG_DEBUG_KERNEL=y
-CONFIG_DEBUG_MISC=y
+# CONFIG_DEBUG_MISC is not set
 
 #
 # Compile-time checks and compiler options
 #
-CONFIG_DEBUG_INFO=y
 CONFIG_AS_HAS_NON_CONST_LEB128=y
-# CONFIG_DEBUG_INFO_NONE is not set
-CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y
+CONFIG_DEBUG_INFO_NONE=y
+# CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT is not set
 # CONFIG_DEBUG_INFO_DWARF4 is not set
 # CONFIG_DEBUG_INFO_DWARF5 is not set
-# CONFIG_DEBUG_INFO_REDUCED is not set
-CONFIG_DEBUG_INFO_COMPRESSED_NONE=y
-# CONFIG_DEBUG_INFO_COMPRESSED_ZLIB is not set
-# CONFIG_DEBUG_INFO_SPLIT is not set
-# CONFIG_DEBUG_INFO_BTF is not set
-# CONFIG_GDB_SCRIPTS is not set
 CONFIG_FRAME_WARN=2048
 CONFIG_STRIP_ASM_SYMS=y
 # CONFIG_READABLE_ASM is not set

resources/linux-config-x86_64

@@ -1378,7 +1378,8 @@ CONFIG_NVME_MULTIPATH=y
 # CONFIG_MISC_RTSX_PCI is not set
 # CONFIG_HABANA_AI is not set
 # CONFIG_UACCE is not set
-# CONFIG_PVPANIC is not set
+CONFIG_PVPANIC=y
+CONFIG_PVPANIC_PCI=y
 # CONFIG_GP_PCI1XXXX is not set
 # end of Misc devices
 
@@ -2924,23 +2925,16 @@ CONFIG_SYMBOLIC_ERRNAME=y
 # end of printk and dmesg options
 
 CONFIG_DEBUG_KERNEL=y
-CONFIG_DEBUG_MISC=y
+# CONFIG_DEBUG_MISC is not set
 
 #
 # Compile-time checks and compiler options
 #
-CONFIG_DEBUG_INFO=y
 CONFIG_AS_HAS_NON_CONST_LEB128=y
-# CONFIG_DEBUG_INFO_NONE is not set
-CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y
+CONFIG_DEBUG_INFO_NONE=y
+# CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT is not set
 # CONFIG_DEBUG_INFO_DWARF4 is not set
 # CONFIG_DEBUG_INFO_DWARF5 is not set
-# CONFIG_DEBUG_INFO_REDUCED is not set
-CONFIG_DEBUG_INFO_COMPRESSED_NONE=y
-# CONFIG_DEBUG_INFO_COMPRESSED_ZLIB is not set
-# CONFIG_DEBUG_INFO_SPLIT is not set
-# CONFIG_DEBUG_INFO_BTF is not set
-# CONFIG_GDB_SCRIPTS is not set
 CONFIG_FRAME_WARN=2048
 CONFIG_STRIP_ASM_SYMS=y
 # CONFIG_READABLE_ASM is not set

scripts/common-aarch64.sh

@@ -1,7 +1,5 @@
 #!/bin/bash
 
-export BUILD_TARGET=${BUILD_TARGET-aarch64-unknown-linux-gnu}
-
 WORKLOADS_DIR="$HOME/workloads"
 
 mkdir -p "$WORKLOADS_DIR"

scripts/dev_cli.sh

@@ -7,8 +7,8 @@
 CLI_NAME="Cloud Hypervisor"
 
 CTR_IMAGE_TAG="ghcr.io/cloud-hypervisor/cloud-hypervisor"
-CTR_IMAGE_VERSION="20230620-0"
-CTR_IMAGE="${CTR_IMAGE_TAG}:${CTR_IMAGE_VERSION}"
+CTR_IMAGE_VERSION="20231220-0"
+: "${CTR_IMAGE:=${CTR_IMAGE_TAG}:${CTR_IMAGE_VERSION}}"
 
 DOCKER_RUNTIME="docker"
 
@@ -282,11 +282,10 @@ cmd_build() {
     [ $build = "release" ] && cargo_args+=("--release")
     cargo_args+=(--target "$target")
 
-    rustflags=""
+    rustflags="$RUSTFLAGS"
     target_cc=""
     if [ "$(uname -m)" = "aarch64" ] && [ "$libc" = "musl" ]; then
-        rustflags="-C link-arg=-lgcc -C link_arg=-specs -C link_arg=/usr/lib/aarch64-linux-musl/musl-gcc.specs"
-        target_cc="musl-gcc"
+        rustflags="$rustflags -C link-args=-Wl,-Bstatic -C link-args=-lc"
     fi
 
     $DOCKER_RUNTIME run \
@@ -396,6 +395,12 @@ cmd_tests() {
     process_volumes_args
     target="$(uname -m)-unknown-linux-${libc}"
 
+    rustflags="$RUSTFLAGS"
+    target_cc=""
+    if [ "$(uname -m)" = "aarch64" ] && [ "$libc" = "musl" ]; then
+        rustflags="$rustflags -C link-args=-Wl,-Bstatic -C link-args=-lc"
+    fi
+
     if [[ "$unit" = true ]]; then
         say "Running unit tests for $target..."
         $DOCKER_RUNTIME run \
@@ -406,6 +411,8 @@ cmd_tests() {
             --cap-add net_admin \
             --volume "$CLH_ROOT_DIR:$CTR_CLH_ROOT_DIR" $exported_volumes \
             --env BUILD_TARGET="$target" \
+            --env RUSTFLAGS="$rustflags" \
+            --env TARGET_CC="$target_cc" \
             "$CTR_IMAGE" \
             ./scripts/run_unit_tests.sh "$@" || fix_dir_perms $? || exit $?
     fi
@@ -424,7 +431,9 @@ cmd_tests() {
             --volume "$CLH_ROOT_DIR:$CTR_CLH_ROOT_DIR" $exported_volumes \
             --volume "$CLH_INTEGRATION_WORKLOADS:$CTR_CLH_INTEGRATION_WORKLOADS" \
             --env USER="root" \
-            --env CH_LIBC="${libc}" \
+            --env BUILD_TARGET="$target" \
+            --env RUSTFLAGS="$rustflags" \
+            --env TARGET_CC="$target_cc" \
             "$CTR_IMAGE" \
             dbus-run-session ./scripts/run_integration_tests_"$(uname -m)".sh "$@" || fix_dir_perms $? || exit $?
     fi
@@ -443,7 +452,9 @@ cmd_tests() {
             --volume "$CLH_ROOT_DIR:$CTR_CLH_ROOT_DIR" $exported_volumes \
             --volume "$CLH_INTEGRATION_WORKLOADS:$CTR_CLH_INTEGRATION_WORKLOADS" \
             --env USER="root" \
-            --env CH_LIBC="${libc}" \
+            --env BUILD_TARGET="$target" \
+            --env RUSTFLAGS="$rustflags" \
+            --env TARGET_CC="$target_cc" \
             "$CTR_IMAGE" \
             ./scripts/run_integration_tests_sgx.sh "$@" || fix_dir_perms $? || exit $?
     fi
@@ -462,7 +473,9 @@ cmd_tests() {
             --volume "$CLH_ROOT_DIR:$CTR_CLH_ROOT_DIR" $exported_volumes \
             --volume "$CLH_INTEGRATION_WORKLOADS:$CTR_CLH_INTEGRATION_WORKLOADS" \
             --env USER="root" \
-            --env CH_LIBC="${libc}" \
+            --env BUILD_TARGET="$target" \
+            --env RUSTFLAGS="$rustflags" \
+            --env TARGET_CC="$target_cc" \
             "$CTR_IMAGE" \
             ./scripts/run_integration_tests_vfio.sh "$@" || fix_dir_perms $? || exit $?
     fi
@@ -481,7 +494,9 @@ cmd_tests() {
             --volume "$CLH_ROOT_DIR:$CTR_CLH_ROOT_DIR" $exported_volumes \
             --volume "$CLH_INTEGRATION_WORKLOADS:$CTR_CLH_INTEGRATION_WORKLOADS" \
             --env USER="root" \
-            --env CH_LIBC="${libc}" \
+            --env BUILD_TARGET="$target" \
+            --env RUSTFLAGS="$rustflags" \
+            --env TARGET_CC="$target_cc" \
             "$CTR_IMAGE" \
             ./scripts/run_integration_tests_windows_"$(uname -m)".sh "$@" || fix_dir_perms $? || exit $?
     fi
@@ -500,7 +515,9 @@ cmd_tests() {
             --volume "$CLH_ROOT_DIR:$CTR_CLH_ROOT_DIR" $exported_volumes \
             --volume "$CLH_INTEGRATION_WORKLOADS:$CTR_CLH_INTEGRATION_WORKLOADS" \
             --env USER="root" \
-            --env CH_LIBC="${libc}" \
+            --env BUILD_TARGET="$target" \
+            --env RUSTFLAGS="$rustflags" \
+            --env TARGET_CC="$target_cc" \
             "$CTR_IMAGE" \
             ./scripts/run_integration_tests_live_migration.sh "$@" || fix_dir_perms $? || exit $?
     fi
@@ -519,7 +536,9 @@ cmd_tests() {
             --volume "$CLH_ROOT_DIR:$CTR_CLH_ROOT_DIR" $exported_volumes \
             --volume "$CLH_INTEGRATION_WORKLOADS:$CTR_CLH_INTEGRATION_WORKLOADS" \
             --env USER="root" \
-            --env CH_LIBC="${libc}" \
+            --env BUILD_TARGET="$target" \
+            --env RUSTFLAGS="$rustflags" \
+            --env TARGET_CC="$target_cc" \
             "$CTR_IMAGE" \
             ./scripts/run_integration_tests_rate_limiter.sh "$@" || fix_dir_perms $? || exit $?
     fi
@@ -538,7 +557,9 @@ cmd_tests() {
             --volume "$CLH_ROOT_DIR:$CTR_CLH_ROOT_DIR" $exported_volumes \
             --volume "$CLH_INTEGRATION_WORKLOADS:$CTR_CLH_INTEGRATION_WORKLOADS" \
             --env USER="root" \
-            --env CH_LIBC="${libc}" \
+            --env BUILD_TARGET="$target" \
+            --env RUSTFLAGS="$rustflags" \
+            --env TARGET_CC="$target_cc" \
             --env RUST_BACKTRACE="${RUST_BACKTRACE}" \
             "$CTR_IMAGE" \
             ./scripts/run_metrics.sh "$@" || fix_dir_perms $? || exit $?