build: Release v36.1 (bug fix release)

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

.github/workflows/build.yaml

@@ -13,7 +13,7 @@ jobs:
           - stable
           - beta
           - nightly
-          - "1.64"
+          - "1.66"
         target:
           - x86_64-unknown-linux-gnu
           - x86_64-unknown-linux-musl
@@ -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 = "36.1.0"
 authors = ["The Cloud Hypervisor Authors"]
 edition = "2021"
 default-run = "cloud-hypervisor"
@@ -15,7 +15,7 @@ homepage = "https://github.com/cloud-hypervisor/cloud-hypervisor"
 # a.) A dependency requires it,
 # b.) If we want to use a new feature and that MSRV is at least 6 months old,
 # c.) There is a security issue that is addressed by the toolchain update.
-rust-version = "1.64"
+rust-version = "1.66"
 
 [profile.release]
 lto = true
@@ -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"
+clap = { version = "4.3.11", features = ["string"] }
 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"
+seccompiler = "0.4.0"
+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,26 @@ 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"
 
+# Please adjust `vmm::feature_list()` accordingly when changing the
+# feature list below
 [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 +82,7 @@ tracing = ["vmm/tracing", "tracer/tracing"]
 members = [
     "api_client",
     "arch",
-    "block_util",
+    "block",
     "devices",
     "event_monitor",
     "hypervisor",
@@ -88,12 +91,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
 
@@ -150,7 +150,7 @@ $ sudo setcap cap_net_admin+ep ./cloud-hypervisor
 $ ./create-cloud-init.sh
 $ ./cloud-hypervisor \
 	--kernel ./hypervisor-fw \
-	--disk path=focal-server-cloudimg-amd64.raw --disk path=/tmp/ubuntu-cloudinit.img \
+	--disk path=focal-server-cloudimg-amd64.raw path=/tmp/ubuntu-cloudinit.img \
 	--cpus boot=4 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask="
@@ -163,7 +163,7 @@ GRUB) is required then it necessary to switch to the serial console instead of
 ```shell
 $ ./cloud-hypervisor \
 	--kernel ./hypervisor-fw \
-	--disk path=focal-server-cloudimg-amd64.raw --disk path=/tmp/ubuntu-cloudinit.img \
+	--disk path=focal-server-cloudimg-amd64.raw path=/tmp/ubuntu-cloudinit.img \
 	--cpus boot=4 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask=" \
@@ -225,7 +225,7 @@ $ sudo setcap cap_net_admin+ep ./cloud-hypervisor
 $ ./create-cloud-init.sh
 $ ./cloud-hypervisor \
 	--kernel ./linux-cloud-hypervisor/arch/x86/boot/compressed/vmlinux.bin \
-	--disk path=focal-server-cloudimg-amd64.raw --disk path=/tmp/ubuntu-cloudinit.img \
+	--disk path=focal-server-cloudimg-amd64.raw path=/tmp/ubuntu-cloudinit.img \
 	--cmdline "console=hvc0 root=/dev/vda1 rw" \
 	--cpus boot=4 \
 	--memory size=1024M \
@@ -239,7 +239,7 @@ $ sudo setcap cap_net_admin+ep ./cloud-hypervisor
 $ ./create-cloud-init.sh
 $ ./cloud-hypervisor \
 	--kernel ./linux-cloud-hypervisor/arch/arm64/boot/Image \
-	--disk path=focal-server-cloudimg-arm64.raw --disk path=/tmp/ubuntu-cloudinit.img \
+	--disk path=focal-server-cloudimg-arm64.raw path=/tmp/ubuntu-cloudinit.img \
 	--cmdline "console=hvc0 root=/dev/vda1 rw" \
 	--cpus boot=4 \
 	--memory size=1024M \

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/lib.rs

@@ -92,7 +92,7 @@ pub mod x86_64;
 pub use x86_64::{
     arch_memory_regions, configure_system, configure_vcpu, generate_common_cpuid,
     get_host_cpu_phys_bits, initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE,
-    layout::CMDLINE_START, regs, CpuidFeatureEntry, EntryPoint, _NSIG,
+    layout::CMDLINE_START, regs, CpuidConfig, CpuidFeatureEntry, EntryPoint, _NSIG,
 };
 
 /// Safe wrapper for `sysconf(_SC_PAGESIZE)`.
@@ -108,6 +108,7 @@ pub struct NumaNode {
     pub memory_regions: Vec<Arc<GuestRegionMmap>>,
     pub hotplug_regions: Vec<Arc<GuestRegionMmap>>,
     pub cpus: Vec<u8>,
+    pub pci_segments: Vec<u16>,
     pub distances: BTreeMap<u32, u8>,
     pub memory_zones: Vec<String>,
     #[cfg(target_arch = "x86_64")]

arch/src/x86_64/mod.rs

@@ -37,9 +37,11 @@ const TSC_DEADLINE_TIMER_ECX_BIT: u8 = 24; // tsc deadline timer ecx bit.
 const HYPERVISOR_ECX_BIT: u8 = 31; // Hypervisor ecx bit.
 const MTRR_EDX_BIT: u8 = 12; // Hypervisor ecx bit.
 const INVARIANT_TSC_EDX_BIT: u8 = 8; // Invariant TSC bit on 0x8000_0007 EDX
+const AMX_BF16: u8 = 22; // AMX tile computation on bfloat16 numbers
+const AMX_TILE: u8 = 24; // AMX tile load/store instructions
+const AMX_INT8: u8 = 25; // AMX tile computation on 8-bit integers
 
 // 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 +63,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;
@@ -146,6 +148,15 @@ struct BootParamsWrapper(boot_params);
 // SAFETY: BootParamsWrap is a wrapper over `boot_params` (a series of ints).
 unsafe impl ByteValued for BootParamsWrapper {}
 
+pub struct CpuidConfig {
+    pub sgx_epc_sections: Option<Vec<SgxEpcSection>>,
+    pub phys_bits: u8,
+    pub kvm_hyperv: bool,
+    #[cfg(feature = "tdx")]
+    pub tdx: bool,
+    pub amx: bool,
+}
+
 #[derive(Debug)]
 pub enum Error {
     /// Error writing MP table to memory.
@@ -553,11 +564,7 @@ impl CpuidFeatureEntry {
 
 pub fn generate_common_cpuid(
     hypervisor: &Arc<dyn hypervisor::Hypervisor>,
-    topology: Option<(u8, u8, u8)>,
-    sgx_epc_sections: Option<Vec<SgxEpcSection>>,
-    phys_bits: u8,
-    kvm_hyperv: bool,
-    #[cfg(feature = "tdx")] tdx_enabled: bool,
+    config: &CpuidConfig,
 ) -> super::Result<Vec<CpuIdEntry>> {
     // SAFETY: cpuid called with valid leaves
     if unsafe { x86_64::__cpuid(1) }.ecx & 1 << HYPERVISOR_ECX_BIT == 1 << HYPERVISOR_ECX_BIT {
@@ -575,7 +582,10 @@ pub fn generate_common_cpuid(
         );
     }
 
-    info!("Generating guest CPUID for with physical address size: {phys_bits}");
+    info!(
+        "Generating guest CPUID for with physical address size: {}",
+        config.phys_bits
+    );
     let cpuid_patches = vec![
         // Patch tsc deadline timer bit
         CpuidPatch {
@@ -616,16 +626,12 @@ pub fn generate_common_cpuid(
 
     CpuidPatch::patch_cpuid(&mut cpuid, cpuid_patches);
 
-    if let Some(t) = topology {
-        update_cpuid_topology(&mut cpuid, t.0, t.1, t.2);
-    }
-
-    if let Some(sgx_epc_sections) = sgx_epc_sections {
+    if let Some(sgx_epc_sections) = &config.sgx_epc_sections {
         update_cpuid_sgx(&mut cpuid, sgx_epc_sections)?;
     }
 
     #[cfg(feature = "tdx")]
-    let tdx_capabilities = if tdx_enabled {
+    let tdx_capabilities = if config.tdx {
         let caps = hypervisor
             .tdx_capabilities()
             .map_err(Error::TdxCapabilities)?;
@@ -638,6 +644,12 @@ pub fn generate_common_cpuid(
     // Update some existing CPUID
     for entry in cpuid.as_mut_slice().iter_mut() {
         match entry.function {
+            // Clear AMX related bits if the AMX feature is not enabled
+            0x7 => {
+                if !config.amx && entry.index == 0 {
+                    entry.edx &= !(1 << AMX_BF16 | 1 << AMX_TILE | 1 << AMX_INT8)
+                }
+            }
             0xd =>
             {
                 #[cfg(feature = "tdx")]
@@ -673,19 +685,12 @@ pub fn generate_common_cpuid(
             }
             // Set CPU physical bits
             0x8000_0008 => {
-                entry.eax = (entry.eax & 0xffff_ff00) | (phys_bits as u32 & 0xff);
+                entry.eax = (entry.eax & 0xffff_ff00) | (config.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 {
+                if config.tdx {
                     entry.eax &= !(1 << KVM_FEATURE_CLOCKSOURCE_BIT
                         | 1 << KVM_FEATURE_CLOCKSOURCE2_BIT
                         | 1 << KVM_FEATURE_CLOCKSOURCE_STABLE_BIT
@@ -713,7 +718,7 @@ pub fn generate_common_cpuid(
         });
     }
 
-    if kvm_hyperv {
+    if config.kvm_hyperv {
         // Remove conflicting entries
         cpuid.retain(|c| c.function != 0x4000_0000);
         cpuid.retain(|c| c.function != 0x4000_0001);
@@ -769,11 +774,26 @@ pub fn configure_vcpu(
     boot_setup: Option<(EntryPoint, &GuestMemoryAtomic<GuestMemoryMmap>)>,
     cpuid: Vec<CpuIdEntry>,
     kvm_hyperv: bool,
+    cpu_vendor: CpuVendor,
+    topology: Option<(u8, u8, u8)>,
 ) -> super::Result<()> {
     // Per vCPU CPUID changes; common are handled via generate_common_cpuid()
     let mut cpuid = cpuid;
     CpuidPatch::set_cpuid_reg(&mut cpuid, 0xb, None, CpuidReg::EDX, u32::from(id));
     CpuidPatch::set_cpuid_reg(&mut cpuid, 0x1f, None, CpuidReg::EDX, u32::from(id));
+    if matches!(cpu_vendor, CpuVendor::AMD) {
+        CpuidPatch::set_cpuid_reg(
+            &mut cpuid,
+            0x8000_001e,
+            Some(0),
+            CpuidReg::EAX,
+            u32::from(id),
+        );
+    }
+
+    if let Some(t) = topology {
+        update_cpuid_topology(&mut cpuid, t.0, t.1, t.2, cpu_vendor, id);
+    }
 
     // Set ApicId in cpuid for each vcpu
     // SAFETY: get host cpuid when eax=1
@@ -819,12 +839,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 +1033,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 +1059,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(
@@ -1170,6 +1188,8 @@ fn update_cpuid_topology(
     threads_per_core: u8,
     cores_per_die: u8,
     dies_per_package: u8,
+    cpu_vendor: CpuVendor,
+    id: u8,
 ) {
     let thread_width = 8 - (threads_per_core - 1).leading_zeros();
     let core_width = (8 - (cores_per_die - 1).leading_zeros()) + thread_width;
@@ -1226,13 +1246,72 @@ fn update_cpuid_topology(
         u32::from(dies_per_package * cores_per_die * threads_per_core),
     );
     CpuidPatch::set_cpuid_reg(cpuid, 0x1f, Some(2), CpuidReg::ECX, 5 << 8);
+
+    if matches!(cpu_vendor, CpuVendor::AMD) {
+        CpuidPatch::set_cpuid_reg(
+            cpuid,
+            0x8000_001e,
+            Some(0),
+            CpuidReg::EBX,
+            ((threads_per_core as u32 - 1) << 8) | (id as u32 & 0xff),
+        );
+        CpuidPatch::set_cpuid_reg(
+            cpuid,
+            0x8000_001e,
+            Some(0),
+            CpuidReg::ECX,
+            ((dies_per_package as u32 - 1) << 8) | (thread_width + die_width) & 0xff,
+        );
+        CpuidPatch::set_cpuid_reg(cpuid, 0x8000_001e, Some(0), CpuidReg::EDX, 0);
+        if cores_per_die * threads_per_core > 1 {
+            CpuidPatch::set_cpuid_reg(
+                cpuid,
+                0x8000_0001,
+                Some(0),
+                CpuidReg::ECX,
+                (1u32 << 1) | (1u32 << 22),
+            );
+            CpuidPatch::set_cpuid_reg(
+                cpuid,
+                0x0000_0001,
+                Some(0),
+                CpuidReg::EBX,
+                ((id as u32) << 24)
+                    | (8 << 8)
+                    | (((cores_per_die * threads_per_core) as u32) << 16),
+            );
+            let cpuid_patches = vec![
+                // Patch tsc deadline timer bit
+                CpuidPatch {
+                    function: 1,
+                    index: 0,
+                    flags_bit: None,
+                    eax_bit: None,
+                    ebx_bit: None,
+                    ecx_bit: None,
+                    edx_bit: Some(28),
+                },
+            ];
+            CpuidPatch::patch_cpuid(cpuid, cpuid_patches);
+            CpuidPatch::set_cpuid_reg(
+                cpuid,
+                0x8000_0008,
+                Some(0),
+                CpuidReg::ECX,
+                ((thread_width + core_width + die_width) << 12)
+                    | ((cores_per_die * threads_per_core) - 1) as u32,
+            );
+        } else {
+            CpuidPatch::set_cpuid_reg(cpuid, 0x8000_0008, Some(0), CpuidReg::ECX, 0u32);
+        }
+    }
 }
 
 // The goal is to update the CPUID sub-leaves to reflect the number of EPC
 // sections exposed to the guest.
 fn update_cpuid_sgx(
     cpuid: &mut Vec<CpuIdEntry>,
-    epc_sections: Vec<SgxEpcSection>,
+    epc_sections: &[SgxEpcSection],
 ) -> Result<(), Error> {
     // Something's wrong if there's no EPC section.
     if epc_sections.is_empty() {

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,41 @@
 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_async_aio;
 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;
@@ -45,7 +62,9 @@ use vm_memory::{
     GuestMemoryError, GuestMemoryLoadGuard,
 };
 use vm_virtio::{AccessPlatform, Translatable};
+use vmm_sys_util::aio;
 use vmm_sys_util::eventfd::EventFd;
+use vmm_sys_util::{ioctl_io_nr, ioctl_ioc_nr};
 
 type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
 
@@ -66,12 +85,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 +118,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 +129,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 +332,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 +364,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 +381,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 +408,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 +430,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 +444,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 +483,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);
             }
@@ -540,53 +567,67 @@ unsafe impl ByteValued for VirtioBlockConfig {}
 // SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for VirtioBlockGeometry {}
 
+/// Check if aio can be used on the current system.
+pub fn block_aio_is_supported() -> bool {
+    aio::IoContext::new(1).is_ok()
+}
+
 /// 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 +736,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 +770,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_async_aio.rs

@@ -0,0 +1,150 @@
+// Copyright © 2023 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright © 2023 Crusoe Energy Systems LLC
+//
+
+use crate::async_io::{
+    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
+};
+use crate::DiskTopology;
+use std::fs::File;
+use std::io::{Seek, SeekFrom};
+use std::os::unix::io::{AsRawFd, RawFd};
+use vmm_sys_util::aio;
+use vmm_sys_util::eventfd::EventFd;
+
+pub struct RawFileDiskAio {
+    file: File,
+}
+
+impl RawFileDiskAio {
+    pub fn new(file: File) -> Self {
+        RawFileDiskAio { file }
+    }
+}
+
+impl DiskFile for RawFileDiskAio {
+    fn size(&mut self) -> DiskFileResult<u64> {
+        self.file
+            .seek(SeekFrom::End(0))
+            .map_err(DiskFileError::Size)
+    }
+
+    fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
+        Ok(Box::new(
+            RawFileAsyncAio::new(self.file.as_raw_fd(), ring_depth)
+                .map_err(DiskFileError::NewAsyncIo)?,
+        ) as Box<dyn AsyncIo>)
+    }
+
+    fn topology(&mut self) -> DiskTopology {
+        if let Ok(topology) = DiskTopology::probe(&self.file) {
+            topology
+        } else {
+            warn!("Unable to get device topology. Using default topology");
+            DiskTopology::default()
+        }
+    }
+}
+
+pub struct RawFileAsyncAio {
+    fd: RawFd,
+    ctx: aio::IoContext,
+    eventfd: EventFd,
+}
+
+impl RawFileAsyncAio {
+    pub fn new(fd: RawFd, queue_depth: u32) -> std::io::Result<Self> {
+        let eventfd = EventFd::new(libc::EFD_NONBLOCK)?;
+        let ctx = aio::IoContext::new(queue_depth)?;
+
+        Ok(RawFileAsyncAio { fd, ctx, eventfd })
+    }
+}
+
+impl AsyncIo for RawFileAsyncAio {
+    fn notifier(&self) -> &EventFd {
+        &self.eventfd
+    }
+
+    fn read_vectored(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+    ) -> AsyncIoResult<()> {
+        let iocbs = [&mut aio::IoControlBlock {
+            aio_fildes: self.fd.as_raw_fd() as u32,
+            aio_lio_opcode: aio::IOCB_CMD_PREADV as u16,
+            aio_buf: iovecs.as_ptr() as u64,
+            aio_nbytes: iovecs.len() as u64,
+            aio_offset: offset,
+            aio_data: user_data,
+            aio_flags: aio::IOCB_FLAG_RESFD,
+            aio_resfd: self.eventfd.as_raw_fd() as u32,
+            ..Default::default()
+        }];
+        let _ = self
+            .ctx
+            .submit(&iocbs[..])
+            .map_err(AsyncIoError::ReadVectored)?;
+
+        Ok(())
+    }
+
+    fn write_vectored(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+    ) -> AsyncIoResult<()> {
+        let iocbs = [&mut aio::IoControlBlock {
+            aio_fildes: self.fd.as_raw_fd() as u32,
+            aio_lio_opcode: aio::IOCB_CMD_PWRITEV as u16,
+            aio_buf: iovecs.as_ptr() as u64,
+            aio_nbytes: iovecs.len() as u64,
+            aio_offset: offset,
+            aio_data: user_data,
+            aio_flags: aio::IOCB_FLAG_RESFD,
+            aio_resfd: self.eventfd.as_raw_fd() as u32,
+            ..Default::default()
+        }];
+        let _ = self
+            .ctx
+            .submit(&iocbs[..])
+            .map_err(AsyncIoError::WriteVectored)?;
+
+        Ok(())
+    }
+
+    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
+        if let Some(user_data) = user_data {
+            let iocbs = [&mut aio::IoControlBlock {
+                aio_fildes: self.fd.as_raw_fd() as u32,
+                aio_lio_opcode: aio::IOCB_CMD_FSYNC as u16,
+                aio_data: user_data,
+                aio_flags: aio::IOCB_FLAG_RESFD,
+                aio_resfd: self.eventfd.as_raw_fd() as u32,
+                ..Default::default()
+            }];
+            let _ = self.ctx.submit(&iocbs[..]).map_err(AsyncIoError::Fsync)?;
+        } else {
+            // SAFETY: FFI call with a valid fd
+            unsafe { libc::fsync(self.fd) };
+        }
+
+        Ok(())
+    }
+
+    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
+        let mut events: [aio::IoEvent; 1] = [aio::IoEvent::default()];
+        let rc = self.ctx.get_events(0, &mut events, None).unwrap();
+        if rc == 0 {
+            None
+        } else {
+            Some((events[0].data, events[0].res as i32))
+        }
+    }
+}

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"
+bitflags = "2.4.1"
 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

@@ -166,8 +166,8 @@ impl Serial {
         Self::new(id, interrupt, None, state)
     }
 
-    pub fn set_out(&mut self, out: Box<dyn io::Write + Send>) {
-        self.out = Some(out);
+    pub fn set_out(&mut self, out: Option<Box<dyn io::Write + Send>>) {
+        self.out = out;
     }
 
     /// Queues raw bytes for the guest to read and signals the interrupt if the line status would
@@ -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

@@ -201,8 +201,8 @@ impl Pl011 {
         }
     }
 
-    pub fn set_out(&mut self, out: Box<dyn io::Write + Send>) {
-        self.out = Some(out);
+    pub fn set_out(&mut self, out: Option<Box<dyn io::Write + Send>>) {
+        self.out = out;
     }
 
     fn state(&self) -> Pl011State {
@@ -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
 
@@ -277,7 +295,7 @@ From the CLI, one can:
 The REST API, D-Bus API and the CLI all rely on a common, [internal API](#internal-api).
 
 The CLI options are parsed by the
-[argh crate](https://docs.rs/argh/latest/argh/) and then translated into
+[clap crate](https://docs.rs/clap/4.3.11/clap/) and then translated into
 [internal API](#internal-api) commands.
 
 The REST API is processed by an HTTP thread using the
@@ -309,7 +327,7 @@ As a summary, the REST API, the D-Bus API and the CLI are essentially frontends
                        |                                      |      +------------------------+
                        |            +----------+              |                 VMM
                        |     CLI    |          |              |
-                       +----------->+   argh   +--------------+
+                       +----------->+   clap   +--------------+
                                     |          |
                                     +----------+
 

docs/balloon.md

@@ -54,7 +54,7 @@ Value is a boolean set to `off` by default.
 _Example_
 
 ```
---ballloon size=2G,deflate_on_oom=on
+--balloon size=2G,deflate_on_oom=on
 ```
 
 ### `free_page_reporting`
@@ -72,5 +72,5 @@ Value is a boolean set to `off` by default.
 _Example_
 
 ```
---ballloon size=0,free_page_reporting=on
+--balloon size=0,free_page_reporting=on
 ```

docs/coverage.md

@@ -0,0 +1,81 @@
+# Code coverage
+
+LLVM provides a set of tools to collect code coverage data and present the data
+in human-consumable forms.
+
+## Building a suitable binary
+
+The compiler flag to generate code coverage data has been stabilized since Rust
+1.60.
+
+An instrumented binary can be built with the following command:
+
+```shell
+cargo clean && RUSTFLAGS='-C instrument-coverage' cargo build
+```
+
+Using either `debug` or `release` profile is fine. You will need to adjust
+the path for some commands.
+
+## Running the binary
+
+Run the binary as you normally would. When the process exits, you will see
+files with the prefix `profraw`.
+
+Multiple runs of the same binary will produce multiple `profraw` files.
+
+The more diverse the runs are, the better. Try to exercise different features
+as much as possible.
+
+## Combining raw data
+
+Raw data files can be combined with `llvm-profdata`.
+
+```shell
+rustup component add llvm-tools-preview
+# Assuming profraw files reside in the current directory and its children directories
+find . -name '*.profraw' -exec llvm-profdata merge -sparse {} -o coverage.profdata \;
+```
+
+A file named `coverage.profdata` will be generated.
+
+## Generating HTML files for human consumption
+
+This can be done either with LLVM or `grcov`.
+
+Here is an example using grcov.
+
+```shell
+cargo install grcov
+# Assuming the profdata file is in the top level directory of the Cloud Hypervisor repository
+grcov . --binary-path ./target/x86_64-unknown-linux-gnu/release -s . -t html --branch --ignore-not-existing -o coverage-html-output/
+```
+
+You can then open the `index.html` file under coverage-html-output to see the
+results.
+
+## Notes on running the in-tree integration tests and unit tests
+
+Please set RUSTFLAGS the same way while invoking `dev_cli.sh`. The script will
+pass RUSTFLAGS to the container.
+
+Since the `profraw` files are generated from within the container, the file
+paths embedded in the data files are going to be different. It is easier to do
+the data processing from within the container if you don't want to fight the
+tool chain.
+
+```shell
+# Get a shell
+./scripts/dev_cli.sh shell
+
+# Install llvm-tools-preview for llvm-profdata
+rustup component add llvm-tools-preview
+# Merge data files by using the following command
+find . -name '*.profraw' -exec `rustc --print sysroot`/lib/rustlib/x86_64-unknown-linux-gnu/bin/llvm-profdata merge -sparse {} -o coverage.profdata \;
+
+# As of writing, the container has Rust 1.67.1. It is too old for grcov.
+rustup install stable
+cargo +stable install grcov
+# Run grcov as usual
+grcov . --binary-path ./target/x86_64-unknown-linux-gnu/release -s . -t html --branch --ignore-not-existing -o coverage-html-output/
+```

docs/debug-port.md

@@ -36,7 +36,7 @@ Assuming parts of the guest software stack have been instrumented to use the
 `cloud-hypervisor` debug I/O port, we may want to gather the related logs.
 
 To do so we need to start `cloud-hypervisor` with the right debug level
-(`-v -v -v`). It is also recommended to have it log into a dedicated file in order
+(`-vvv`). It is also recommended to have it log into a dedicated file in order
 to easily grep for the tracing logs (e.g.
 `--log-file /tmp/cloud-hypervisor.log`):
 
@@ -48,7 +48,7 @@ to easily grep for the tracing logs (e.g.
     --memory size=1024M \
     --rng \
     --log-file /tmp/ch-fw.log \
-    -v -v -v
+    -vvv
 ```
 
 After booting the guest, we then have to grep for the debug I/O port traces in

docs/gdb.md

@@ -8,7 +8,7 @@ To enable debugging with GDB, build with the `guest_debug` feature enabled:
 cargo build --features guest_debug
 ```
 
-To use the `--gdb` option, specify the Unix Domain Socket with `path` that Cloud Hypervisor will use to communicate with the host's GDB:
+To use the `--gdb` option, specify the Unix Domain Socket with `--path` that Cloud Hypervisor will use to communicate with the host's GDB:
 
 ```bash
 ./cloud-hypervisor \

docs/hotplug.md

@@ -27,16 +27,16 @@ $ ./cloud-hypervisor/target/release/cloud-hypervisor \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask=" \
 	--rng \
-	--api-socket /tmp/ch-socket
+	--api-socket=/tmp/ch-socket
 $ popd
 ```
 
-Notice the addition of `--api-socket /tmp/ch-socket` and a `max` parameter on `--cpus boot=4,max=8`.
+Notice the addition of `--api-socket=/tmp/ch-socket` and a `max` parameter on `--cpus boot=4,max=8`.
 
 To ask the VMM to add additional vCPUs then use the resize API:
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket resize --cpus 8
+./ch-remote --api-socket=/tmp/ch-socket resize --cpus 8
 ```
 
 The extra vCPU threads will be created and advertised to the running kernel. The kernel does not bring up the CPUs immediately and instead the user must "online" them from inside the VM:
@@ -56,7 +56,7 @@ After a reboot the added CPUs will remain.
 Removing CPUs works similarly by reducing the number in the "desired_vcpus" field of the reisze API. The CPUs will be automatically offlined inside the guest so there is no need to run any commands inside the guest:
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket resize --cpus 2
+./ch-remote --api-socket=/tmp/ch-socket resize --cpus 2
 ```
 
 As per adding CPUs to the guest, after a reboot the VM will be running with the reduced number of vCPUs.
@@ -85,7 +85,7 @@ $ ./cloud-hypervisor/target/release/cloud-hypervisor \
 	--memory size=1024M,hotplug_size=8192M \
 	--net "tap=,mac=,ip=,mask=" \
 	--rng \
-	--api-socket /tmp/ch-socket
+	--api-socket=/tmp/ch-socket
 $ popd
 ```
 
@@ -98,7 +98,7 @@ root@ch-guest ~ # echo online | sudo tee /sys/devices/system/memory/auto_online_
 To ask the VMM to expand the RAM for the VM:
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket resize --memory 3G
+./ch-remote --api-socket=/tmp/ch-socket resize --memory 3G
 ```
 
 The new memory is now available to use inside the VM:
@@ -134,14 +134,14 @@ $ ./cloud-hypervisor/target/release/cloud-hypervisor \
 	--disk path=focal-server-cloudimg-amd64.raw \
 	--memory size=1024M,hotplug_size=8192M,hotplug_method=virtio-mem \
 	--net "tap=,mac=,ip=,mask=" \
-	--api-socket /tmp/ch-socket
+	--api-socket=/tmp/ch-socket
 $ popd
 ```
 
 To ask the VMM to expand the RAM for the VM (request is in bytes):
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket resize --memory 3G
+./ch-remote --api-socket=/tmp/ch-socket resize --memory 3G
 ```
 
 The new memory is now available to use inside the VM:
@@ -172,17 +172,17 @@ $ ./cloud-hypervisor/target/release/cloud-hypervisor \
 	--cpus boot=4 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask=" \
-	--api-socket /tmp/ch-socket
+	--api-socket=/tmp/ch-socket
 ```
 
-Notice the addition of `--api-socket /tmp/ch-socket`.
+Notice the addition of `--api-socket=/tmp/ch-socket`.
 
 ### Add VFIO Device
 
 To ask the VMM to add additional VFIO device then use the `add-device` API.
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket add-device path=/sys/bus/pci/devices/0000:01:00.0/
+./ch-remote --api-socket=/tmp/ch-socket add-device path=/sys/bus/pci/devices/0000:01:00.0/
 ```
 
 ### Add Disk Device
@@ -190,7 +190,7 @@ To ask the VMM to add additional VFIO device then use the `add-device` API.
 To ask the VMM to add additional disk device then use the `add-disk` API.
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket add-disk path=/foo/bar/cloud.img
+./ch-remote --api-socket=/tmp/ch-socket add-disk path=/foo/bar/cloud.img
 ```
 
 ### Add Fs Device
@@ -198,7 +198,7 @@ To ask the VMM to add additional disk device then use the `add-disk` API.
 To ask the VMM to add additional fs device then use the `add-fs` API.
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket add-fs tag=myfs,socket=/foo/bar/virtiofs.sock
+./ch-remote --api-socket=/tmp/ch-socket add-fs tag=myfs,socket=/foo/bar/virtiofs.sock
 ```
 
 ### Add Net Device
@@ -206,7 +206,7 @@ To ask the VMM to add additional fs device then use the `add-fs` API.
 To ask the VMM to add additional network device then use the `add-net` API.
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket add-net tap=chtap0
+./ch-remote --api-socket=/tmp/ch-socket add-net tap=chtap0
 ```
 
 ### Add Pmem Device
@@ -214,7 +214,7 @@ To ask the VMM to add additional network device then use the `add-net` API.
 To ask the VMM to add additional PMEM device then use the `add-pmem` API.
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket add-pmem file=/foo/bar.cloud.img
+./ch-remote --api-socket=/tmp/ch-socket add-pmem file=/foo/bar.cloud.img
 ```
 
 ### Add Vsock Device
@@ -222,7 +222,7 @@ To ask the VMM to add additional PMEM device then use the `add-pmem` API.
 To ask the VMM to add additional vsock device then use the `add-vsock` API.
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket add-vsock cid=3,socket=/foo/bar/vsock.sock
+./ch-remote --api-socket=/tmp/ch-socket add-vsock cid=3,socket=/foo/bar/vsock.sock
 ```
 
 ### Common Across All PCI Devices
@@ -244,7 +244,7 @@ After a reboot the added PCI device will remain.
 Removing a PCI device works the same way for all kind of PCI devices. The unique identifier related to the device must be provided. This identifier can be provided by the user when adding the new device, or by default Cloud Hypervisor will assign one.
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket remove-device _disk0
+./ch-remote --api-socket=/tmp/ch-socket remove-device _disk0
 ```
 
 As per adding a PCI device to the guest, after a reboot the VM will be running without the removed PCI device.

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/iommu.md

@@ -245,7 +245,7 @@ e.g.
 
 ```bash
 ./cloud-hypervisor \
-    --api-socket /tmp/api \
+    --api-socket=/tmp/api \
     --cpus boot=1 \
     --memory size=4G,hugepages=on \
     --disk path=focal-server-cloudimg-amd64.raw \
@@ -260,7 +260,7 @@ requiring the IOMMU then may be hotplugged:
 e.g.
 
 ```bash
-./ch-remote --api-socket /tmp/api add-device path=/sys/bus/pci/devices/0000:00:04.0,iommu=on,pci_segment=1
+./ch-remote --api-socket=/tmp/api add-device path=/sys/bus/pci/devices/0000:00:04.0,iommu=on,pci_segment=1
 ```
 
 Devices that cannot be placed behind an IOMMU (e.g. lacking an `iommu=` option)

docs/live_migration.md

@@ -16,22 +16,22 @@ $ target/release/cloud-hypervisor
     --disk path=~/workloads/focal.raw \
     --cpus boot=1 --memory size=1G,shared=on \
     --cmdline "root=/dev/vda1 console=ttyS0"  \
-    --serial tty --console off --api-socket /tmp/api1
+    --serial tty --console off --api-socket=/tmp/api1
 ```
 
 Launch the destination VM from the same directory (on the host machine):
 ```bash
-$ target/release/cloud-hypervisor --api-socket /tmp/api2
+$ target/release/cloud-hypervisor --api-socket=/tmp/api2
 ```
 
 Get ready for receiving migration for the destination VM (on the host machine):
 ```bash
-$ target/release/ch-remote --api-socket /tmp/api2 receive-migration unix:/tmp/sock
+$ target/release/ch-remote --api-socket=/tmp/api2 receive-migration unix:/tmp/sock
 ```
 
 Start to send migration for the source VM (on the host machine):
 ```bash
-$ target/release/ch-remote --api-socket /tmp/api1 send-migration --local unix:/tmp/sock
+$ target/release/ch-remote --api-socket=/tmp/api1 send-migration --local unix:/tmp/sock
 ```
 
 When the above commands completed, the source VM should be successfully
@@ -51,7 +51,7 @@ $ sudo /target/release/cloud-hypervisor \
         --cpus boot=1 --memory size=512M \
         --kernel vmlinux \
         --cmdline "root=/dev/vda1 console=ttyS0"  \
-        --disk path=focal-1.raw path=focal-nested.raw --disk path=tmp.img\
+        --disk path=focal-1.raw path=focal-nested.raw path=tmp.img\
         --net ip=192.168.101.1
 ```
 
@@ -63,7 +63,7 @@ $ sudo /target/release/cloud-hypervisor \
         --cpus boot=1 --memory size=512M \
         --kernel vmlinux \
         --cmdline "root=/dev/vda1 console=ttyS0"  \
-        --disk path=focal-2.raw path=focal-nested.raw --disk path=tmp.img\
+        --disk path=focal-2.raw path=focal-nested.raw path=tmp.img\
         --net ip=192.168.102.1
 ```
 
@@ -74,8 +74,8 @@ vm-1:~$ sudo ./cloud-hypervisor \
         --memory size=128M \
         --kernel vmlinux \
         --cmdline "console=ttyS0 root=/dev/vda1" \
-        --disk path=/dev/vdb --disk path=/dev/vdc \
-        --api-socket /tmp/api1 \
+        --disk path=/dev/vdb path=/dev/vdc \
+        --api-socket=/tmp/api1 \
         --net ip=192.168.100.1
 vm-1:~$ # setup the guest network if needed
 vm-1:~$ sudo ip addr add 192.168.101.2/24 dev ens4
@@ -108,7 +108,7 @@ echo "tmp = $tmp"
 
 Launch the nested destination VM (inside the guest OS of the VM 2):
 ```bash
-vm-2:~$ sudo ./cloud-hypervisor --api-socket /tmp/api2
+vm-2:~$ sudo ./cloud-hypervisor --api-socket=/tmp/api2
 vm-2:~$ # setup the guest network with the following commands if needed
 vm-2:~$ sudo ip addr add 192.168.102.2/24 dev ens4
 vm-2:~$ sudo ip link set up dev ens4
@@ -122,7 +122,7 @@ vm-2:~$ ping 192.168.101.2 # This should succeed
 Get ready for receiving migration for the nested destination VM (inside
 the guest OS of the VM 2):
 ```bash
-vm-2:~$ sudo ./ch-remote --api-socket /tmp/api2 receive-migration unix:/tmp/sock2
+vm-2:~$ sudo ./ch-remote --api-socket=/tmp/api2 receive-migration unix:/tmp/sock2
 vm-2:~$ sudo socat TCP-LISTEN:6000,reuseaddr UNIX-CLIENT:/tmp/sock2
 ```
 
@@ -130,7 +130,7 @@ Start to send migration for the nested source VM (inside the guest OS of
 the VM 1):
 ```bash
 vm-1:~$ sudo socat UNIX-LISTEN:/tmp/sock1,reuseaddr TCP:192.168.102.2:6000
-vm-1:~$ sudo ./ch-remote --api-socket /tmp/api1 send-migration unix:/tmp/sock1
+vm-1:~$ sudo ./ch-remote --api-socket=/tmp/api1 send-migration unix:/tmp/sock1
 ```
 
 When the above commands completed, the source VM should be successfully

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.
 
@@ -38,6 +38,6 @@ This level is for the benefit of developers. It should be used for sporadic and
 
 ### `debug!()`
 
-Use `-v -v` to enable.
+Use `-vv` to enable.
 
-For the most verbose of logging messages. It is acceptable to "spam" the log with repeated invocations of the same message. This level of logging would be combined with `--log-file`.
+For the most verbose of logging messages. It is acceptable to "spam" the log with repeated invocations of the same message. This level of logging would be combined with `--log-file`.

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.
 
@@ -516,7 +516,7 @@ different distances, it can be described with the following example.
 _Example_
 
 ```
---numa guest_numa_id=0,distances=[1@15,2@25] --numa guest_numa_id=1,distances=[0@15,2@20] guest_numa_id=2,distances=[0@25,1@20]
+--numa guest_numa_id=0,distances=[1@15,2@25] guest_numa_id=1,distances=[0@15,2@20] guest_numa_id=2,distances=[0@25,1@20]
 ```
 
 ### `memory_zones`
@@ -540,14 +540,14 @@ demarcate the list.
 
 Note that a memory zone must belong to a single NUMA node. The following
 configuration is incorrect, therefore not allowed:
-`--numa guest_numa_id=0,memory_zones=mem0 --numa guest_numa_id=1,memory_zones=mem0`
+`--numa guest_numa_id=0,memory_zones=mem0 guest_numa_id=1,memory_zones=mem0`
 
 _Example_
 
 ```
 --memory size=0
---memory-zone id=mem0,size=1G id=mem1,size=1G --memory-zone id=mem2,size=1G
---numa guest_numa_id=0,memory_zones=[mem0,mem2] --numa guest_numa_id=1,memory_zones=mem1
+--memory-zone id=mem0,size=1G id=mem1,size=1G id=mem2,size=1G
+--numa guest_numa_id=0,memory_zones=[mem0,mem2] guest_numa_id=1,memory_zones=mem1
 ```
 
 ### `sgx_epc_sections`
@@ -567,12 +567,21 @@ _Example_
 
 ```
 --sgx-epc id=epc0,size=32M id=epc1,size=64M id=epc2,size=32M
---numa guest_numa_id=0,sgx_epc_sections=epc1 --numa guest_numa_id=1,sgx_epc_sections=[epc0,epc2]
+--numa guest_numa_id=0,sgx_epc_sections=epc1 guest_numa_id=1,sgx_epc_sections=[epc0,epc2]
 ```
 
 ### PCI bus
 
-Cloud Hypervisor supports only one PCI bus, which is why it has been tied to
-the NUMA node 0 by default. It is the user responsibility to organize the NUMA
-nodes correctly so that vCPUs and guest RAM which should be located on the same
-NUMA node as the PCI bus end up on the NUMA node 0.
+Cloud Hypervisor supports guests with one or more PCI segments. The default PCI segment always
+has affinity to NUMA node 0. Be default, all other PCI segments have afffinity to NUMA node 0.
+The user may configure the NUMA affinity for any additional PCI segments.
+
+_Example_
+
+```
+--platform num_pci_segments=2
+--memory-zone size=16G,host_numa_node=0,id=mem0
+--memory-zone size=16G,host_numa_node=1,id=mem1
+--numa guest_numa_id=0,memory_zones=mem0,pci_segments=[0]
+--numa guest_numa_id=1,memory_zones=mem1,pci_segments=[1]
+```

docs/profiling.md

@@ -25,7 +25,7 @@ $ perf record -g target/profiling/cloud-hypervisor \
         --cpus boot=1 --memory size=1G \
         --cmdline "root=/dev/pmem0p1 console=ttyS0" \
         --serial tty --console off \
-        --api-socket /tmp/api1
+        --api-socket=/tmp/api1
 ```
 
 For analysing the samples:
@@ -52,5 +52,5 @@ $ perf record --call-graph lbr --all-user --user-callchains -g target/release/cl
         --cpus boot=1 --memory size=1G \
         --cmdline "root=/dev/pmem0p1 console=ttyS0" \
         --serial tty --console off \
-        --api-socket /tmp/api1
+        --api-socket=/tmp/api1
 ```

docs/snapshot_restore.md

@@ -25,14 +25,14 @@ First thing, we must run a Cloud Hypervisor VM:
 At any point in time when the VM is running, one might choose to pause it:
 
 ```bash
-./ch-remote --api-socket /tmp/cloud-hypervisor.sock pause
+./ch-remote --api-socket=/tmp/cloud-hypervisor.sock pause
 ```
 
 Once paused, the VM can be safely snapshot into the specified directory and
 using the following command:
 
 ```bash
-./ch-remote --api-socket /tmp/cloud-hypervisor.sock snapshot file:///home/foo/snapshot
+./ch-remote --api-socket=/tmp/cloud-hypervisor.sock snapshot file:///home/foo/snapshot
 ```
 
 Given the directory was present on the system, the snapshot will succeed and
@@ -79,7 +79,7 @@ Or using two different commands from two terminals:
 ./cloud-hypervisor --api-socket /tmp/cloud-hypervisor.sock
 
 # Second terminal
-./ch-remote --api-socket /tmp/cloud-hypervisor.sock restore source_url=file:///home/foo/snapshot
+./ch-remote --api-socket=/tmp/cloud-hypervisor.sock restore source_url=file:///home/foo/snapshot
 ```
 
 Remember the VM is restored in a `paused` state, which was the VM's state when
@@ -87,7 +87,7 @@ it was snapshot. For this reason, one must explicitly `resume` the VM before to
 start using it.
 
 ```bash
-./ch-remote --api-socket /tmp/cloud-hypervisor.sock resume
+./ch-remote --api-socket=/tmp/cloud-hypervisor.sock resume
 ```
 
 At this point, the VM is fully restored and is identical to the VM which was

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/vhost-user-blk-testing.md

@@ -94,7 +94,7 @@ VMs run in client mode. They connect to the socket created by the `dpdkvhostuser
         --memory size=1024M,hugepages=on,shared=true \
         --kernel linux/arch/x86/boot/compressed/vmlinux.bin \
         --cmdline "console=ttyS0 root=/dev/vda1 rw iommu=off" \
-        --disk path=images/focal-server-cloudimg-amd64.raw --disk vhost_user=true,socket=/var/tmp/vhost.1,num_queues=4,queue_size=128 \
+        --disk path=images/focal-server-cloudimg-amd64.raw vhost_user=true,socket=/var/tmp/vhost.1,num_queues=4,queue_size=128 \
         --console off \
         --serial tty \
         --rng

docs/vsock.md

@@ -50,14 +50,14 @@ The examples use __socat__ `>=1.7.4` to illustrate the VSOCK functionality. Howe
 
 ### Connecting from Host to Guest
 
-The host starts to listen on the defined port:
+The guest starts to listen on the defined port:
 
 `$ socat - VSOCK-LISTEN:1234`
 
-Once the host is listening, the guest can send data:
+Once the guest is listening, the host can send data:
 
 `echo -e "CONNECT 1234\\nHello from host!" | socat - UNIX-CONNECT:/tmp/ch.vsock
- 
+
 Note the string `CONNECT <port>` prepended to the actual data. It is possible for the guest to start listening on different ports, thus the specific command is needed to instruct VSOCK to which listener the host wants to connect. It needs to be sent once per connection. Once the connection established, data transfers can take place directly.
 
 ### Connecting from Guest to Host

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.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.149"
+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" }
+seccompiler = "0.4.0"
 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,27 +7,31 @@ 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 = ["igvm_parser", "igvm_defs"]
 tdx = []
 
 [dependencies]
-anyhow = "1.0.71"
+anyhow = "1.0.75"
 byteorder = "1.4.3"
-thiserror = "1.0.40"
-libc = "0.2.139"
+igvm_defs = { git = "https://github.com/microsoft/igvm", branch = "main" , package = "igvm_defs", optional  = true }
+igvm_parser = { git = "https://github.com/microsoft/igvm", branch = "main" , package = "igvm", optional  = true }
+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_with = { version = "3.0.0", default-features = false, features = ["macros"] }
+serde = { version = "1.0.168", features = ["rc", "derive"] }
+serde_with = { version = "3.4.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"] }
+thiserror = "1.0.40"
 
 [target.'cfg(target_arch = "x86_64")'.dependencies.iced-x86]
-version = "1.19.0"
+optional = true
+version = "1.20.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,21 @@ 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),
+    ///
+    /// Error reading value at given GPA
+    ///
+    #[error("Failed to read from GPA: {0}")]
+    GpaRead(#[source] anyhow::Error),
+    ///
+    /// Error writing value at given GPA
+    ///
+    #[error("Failed to write to GPA: {0}")]
+    GpaWrite(#[source] anyhow::Error),
 }
 
 #[derive(Debug)]
@@ -447,6 +462,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 +470,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,19 +14,27 @@ 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};
 use vfio_ioctls::VfioDeviceFd;
 use vm::DataMatch;
+
+#[cfg(feature = "sev_snp")]
+mod snp_constants;
 // x86_64 dependencies
 #[cfg(target_arch = "x86_64")]
 pub mod x86_64;
+#[cfg(feature = "sev_snp")]
+use snp_constants::*;
+
 use crate::{
     ClockData, CpuState, IoEventAddress, IrqRoutingEntry, MpState, UserMemoryRegion,
     USER_MEMORY_REGION_EXECUTE, USER_MEMORY_REGION_READ, USER_MEMORY_REGION_WRITE,
 };
+#[cfg(feature = "sev_snp")]
+use igvm_defs::IGVM_VHS_SNP_ID_BLOCK;
 use vmm_sys_util::eventfd::EventFd;
 #[cfg(target_arch = "x86_64")]
 pub use x86_64::VcpuMshvState;
@@ -38,9 +46,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 +218,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 {
@@ -242,6 +242,33 @@ impl hypervisor::Hypervisor for MshvHypervisor {
             break;
         }
 
+        // Set additional partition property for SEV-SNP partition.
+        if mshv_vm_type == VmType::Snp {
+            let snp_policy = snp::get_default_snp_guest_policy();
+            let vmgexit_offloads = snp::get_default_vmgexit_offload_features();
+            // SAFETY: access union fields
+            unsafe {
+                debug!(
+                    "Setting the partition isolation policy as: 0x{:x}",
+                    snp_policy.as_uint64
+                );
+                fd.set_partition_property(
+                    hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_POLICY,
+                    snp_policy.as_uint64,
+                )
+                .map_err(|e| hypervisor::HypervisorError::SetPartitionProperty(e.into()))?;
+                debug!(
+                    "Setting the partition property to enable VMGEXIT offloads as : 0x{:x}",
+                    vmgexit_offloads.as_uint64
+                );
+                fd.set_partition_property(
+                    hv_partition_property_code_HV_PARTITION_PROPERTY_SEV_VMGEXIT_OFFLOADS,
+                    vmgexit_offloads.as_uint64,
+                )
+                .map_err(|e| hypervisor::HypervisorError::SetPartitionProperty(e.into()))?;
+            }
+        }
+
         // Default Microsoft Hypervisor behavior for unimplemented MSR is to
         // send a fault to the guest if it tries to access it. It is possible
         // to override this behavior with a more suitable option i.e., ignore
@@ -273,6 +300,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 +357,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 +368,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 +378,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 +389,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 +607,386 @@ 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(),
+                    ))
+                }
+                #[cfg(feature = "sev_snp")]
+                hv_message_type_HVMSG_X64_SEV_VMGEXIT_INTERCEPT => {
+                    let info = x.to_vmg_intercept_info().unwrap();
+                    let ghcb_data = info.ghcb_msr >> GHCB_INFO_BIT_WIDTH;
+                    let ghcb_msr = svm_ghcb_msr {
+                        as_uint64: info.ghcb_msr,
+                    };
+                    // SAFETY: Accessing a union element from bindgen generated bindings.
+                    let ghcb_op = unsafe { ghcb_msr.__bindgen_anon_2.ghcb_info() as u32 };
+                    // Sanity check on the header fields before handling other operations.
+                    assert!(info.header.intercept_access_type == HV_INTERCEPT_ACCESS_EXECUTE as u8);
+
+                    match ghcb_op {
+                        GHCB_INFO_HYP_FEATURE_REQUEST => {
+                            // Pre-condition: GHCB data must be zero
+                            assert!(ghcb_data == 0);
+                            let mut ghcb_response = GHCB_INFO_HYP_FEATURE_RESPONSE as u64;
+                            // Indicate support for basic SEV-SNP features
+                            ghcb_response |=
+                                (GHCB_HYP_FEATURE_SEV_SNP << GHCB_INFO_BIT_WIDTH) as u64;
+                            // Indicate support for SEV-SNP AP creation
+                            ghcb_response |= (GHCB_HYP_FEATURE_SEV_SNP_AP_CREATION
+                                << GHCB_INFO_BIT_WIDTH)
+                                as u64;
+                            debug!(
+                                "GHCB_INFO_HYP_FEATURE_REQUEST: Supported features: {:0x}",
+                                ghcb_response
+                            );
+                            let arr_reg_name_value =
+                                [(hv_register_name_HV_X64_REGISTER_GHCB, ghcb_response)];
+                            set_registers_64!(self.fd, arr_reg_name_value)
+                                .map_err(|e| cpu::HypervisorCpuError::SetRegister(e.into()))?;
+                        }
+                        GHCB_INFO_REGISTER_REQUEST => {
+                            let mut ghcb_gpa = hv_x64_register_sev_ghcb::default();
+                            // SAFETY: Accessing a union element from bindgen generated bindings.
+                            unsafe {
+                                ghcb_gpa.__bindgen_anon_1.set_enabled(1);
+                                ghcb_gpa
+                                    .__bindgen_anon_1
+                                    .set_page_number(ghcb_msr.__bindgen_anon_2.gpa_page_number());
+                            }
+                            // SAFETY: Accessing a union element from bindgen generated bindings.
+                            let reg_name_value = unsafe {
+                                [(
+                                    hv_register_name_HV_X64_REGISTER_SEV_GHCB_GPA,
+                                    ghcb_gpa.as_uint64,
+                                )]
+                            };
+
+                            set_registers_64!(self.fd, reg_name_value)
+                                .map_err(|e| cpu::HypervisorCpuError::SetRegister(e.into()))?;
+
+                            let mut resp_ghcb_msr = svm_ghcb_msr::default();
+                            // SAFETY: Accessing a union element from bindgen generated bindings.
+                            unsafe {
+                                resp_ghcb_msr
+                                    .__bindgen_anon_2
+                                    .set_ghcb_info(GHCB_INFO_REGISTER_RESPONSE as u64);
+                                resp_ghcb_msr.__bindgen_anon_2.set_gpa_page_number(
+                                    ghcb_msr.__bindgen_anon_2.gpa_page_number(),
+                                );
+                            }
+                            // SAFETY: Accessing a union element from bindgen generated bindings.
+                            let reg_name_value = unsafe {
+                                [(
+                                    hv_register_name_HV_X64_REGISTER_GHCB,
+                                    resp_ghcb_msr.as_uint64,
+                                )]
+                            };
+
+                            set_registers_64!(self.fd, reg_name_value)
+                                .map_err(|e| cpu::HypervisorCpuError::SetRegister(e.into()))?;
+                        }
+                        GHCB_INFO_SEV_INFO_REQUEST => {
+                            let sev_cpuid_function = 0x8000_001F;
+                            let cpu_leaf = self
+                                .fd
+                                .get_cpuid_values(sev_cpuid_function, 0, 0, 0)
+                                .unwrap();
+                            let ebx = cpu_leaf[1];
+                            // First 6-byte of EBX represents page table encryption bit number
+                            let pbit_encryption = (ebx & 0x3f) as u8;
+                            let mut ghcb_response = GHCB_INFO_SEV_INFO_RESPONSE as u64;
+
+                            // GHCBData[63:48] specifies the maximum GHCB protocol version supported
+                            ghcb_response |= (GHCB_PROTOCOL_VERSION_MAX as u64) << 48;
+                            // GHCBData[47:32] specifies the minimum GHCB protocol version supported
+                            ghcb_response |= (GHCB_PROTOCOL_VERSION_MIN as u64) << 32;
+                            // GHCBData[31:24] specifies the SEV page table encryption bit number.
+                            ghcb_response |= (pbit_encryption as u64) << 24;
+
+                            let arr_reg_name_value =
+                                [(hv_register_name_HV_X64_REGISTER_GHCB, ghcb_response)];
+                            set_registers_64!(self.fd, arr_reg_name_value)
+                                .map_err(|e| cpu::HypervisorCpuError::SetRegister(e.into()))?;
+                        }
+                        GHCB_INFO_NORMAL => {
+                            let exit_code =
+                                info.__bindgen_anon_2.__bindgen_anon_1.sw_exit_code as u32;
+                            // SAFETY: Accessing a union element from bindgen generated bindings.
+                            let pfn = unsafe { ghcb_msr.__bindgen_anon_2.gpa_page_number() };
+                            let ghcb_gpa = pfn << GHCB_INFO_BIT_WIDTH;
+                            match exit_code {
+                                SVM_EXITCODE_HV_DOORBELL_PAGE => {
+                                    let exit_info1 =
+                                        info.__bindgen_anon_2.__bindgen_anon_1.sw_exit_info1 as u32;
+                                    match exit_info1 {
+                                        SVM_NAE_HV_DOORBELL_PAGE_GET_PREFERRED => {
+                                            // Hypervisor does not have any preference for doorbell GPA.
+                                            let preferred_doorbell_gpa: u64 = 0xFFFFFFFFFFFFFFFF;
+                                            let mut swei2_rw_gpa_arg =
+                                                mshv_bindings::mshv_read_write_gpa {
+                                                    base_gpa: ghcb_gpa + GHCB_SW_EXITINFO2_OFFSET,
+                                                    byte_count: std::mem::size_of::<u64>() as u32,
+                                                    ..Default::default()
+                                                };
+                                            swei2_rw_gpa_arg.data.copy_from_slice(
+                                                &preferred_doorbell_gpa.to_le_bytes(),
+                                            );
+                                            self.fd.gpa_write(&mut swei2_rw_gpa_arg).map_err(
+                                                |e| cpu::HypervisorCpuError::GpaWrite(e.into()),
+                                            )?;
+                                        }
+                                        SVM_NAE_HV_DOORBELL_PAGE_SET => {
+                                            let exit_info2 = info
+                                                .__bindgen_anon_2
+                                                .__bindgen_anon_1
+                                                .sw_exit_info2;
+                                            let mut ghcb_doorbell_gpa =
+                                                hv_x64_register_sev_hv_doorbell::default();
+                                            // SAFETY: Accessing a union element from bindgen generated bindings.
+                                            unsafe {
+                                                ghcb_doorbell_gpa.__bindgen_anon_1.set_enabled(1);
+                                                ghcb_doorbell_gpa
+                                                    .__bindgen_anon_1
+                                                    .set_page_number(exit_info2 >> PAGE_SHIFT);
+                                            }
+                                            // SAFETY: Accessing a union element from bindgen generated bindings.
+                                            let reg_names = unsafe {
+                                                [(
+                                                    hv_register_name_HV_X64_REGISTER_SEV_DOORBELL_GPA,
+                                                    ghcb_doorbell_gpa.as_uint64,
+                                                )]
+                                            };
+                                            set_registers_64!(self.fd, reg_names).map_err(|e| {
+                                                cpu::HypervisorCpuError::SetRegister(e.into())
+                                            })?;
+
+                                            let mut swei2_rw_gpa_arg =
+                                                mshv_bindings::mshv_read_write_gpa {
+                                                    base_gpa: ghcb_gpa + GHCB_SW_EXITINFO2_OFFSET,
+                                                    byte_count: std::mem::size_of::<u64>() as u32,
+                                                    ..Default::default()
+                                                };
+                                            swei2_rw_gpa_arg.data[0..8]
+                                                .copy_from_slice(&exit_info2.to_le_bytes());
+                                            self.fd.gpa_write(&mut swei2_rw_gpa_arg).map_err(
+                                                |e| cpu::HypervisorCpuError::GpaWrite(e.into()),
+                                            )?;
+
+                                            // Clear the SW_EXIT_INFO1 register to indicate no error
+                                            let mut swei1_rw_gpa_arg =
+                                                mshv_bindings::mshv_read_write_gpa {
+                                                    base_gpa: ghcb_gpa + GHCB_SW_EXITINFO1_OFFSET,
+                                                    byte_count: std::mem::size_of::<u64>() as u32,
+                                                    ..Default::default()
+                                                };
+                                            self.fd.gpa_write(&mut swei1_rw_gpa_arg).map_err(
+                                                |e| cpu::HypervisorCpuError::GpaWrite(e.into()),
+                                            )?;
+                                        }
+                                        SVM_NAE_HV_DOORBELL_PAGE_QUERY => {
+                                            let mut reg_assocs = [ hv_register_assoc {
+                                                name: hv_register_name_HV_X64_REGISTER_SEV_DOORBELL_GPA,
+                                                ..Default::default()
+                                            } ];
+                                            self.fd.get_reg(&mut reg_assocs).unwrap();
+                                            // SAFETY: Accessing a union element from bindgen generated bindings.
+                                            let doorbell_gpa = unsafe { reg_assocs[0].value.reg64 };
+                                            let mut swei2_rw_gpa_arg =
+                                                mshv_bindings::mshv_read_write_gpa {
+                                                    base_gpa: ghcb_gpa + GHCB_SW_EXITINFO2_OFFSET,
+                                                    byte_count: std::mem::size_of::<u64>() as u32,
+                                                    ..Default::default()
+                                                };
+                                            swei2_rw_gpa_arg
+                                                .data
+                                                .copy_from_slice(&doorbell_gpa.to_le_bytes());
+                                            self.fd.gpa_write(&mut swei2_rw_gpa_arg).map_err(
+                                                |e| cpu::HypervisorCpuError::GpaWrite(e.into()),
+                                            )?;
+                                        }
+                                        SVM_NAE_HV_DOORBELL_PAGE_CLEAR => {
+                                            let mut swei2_rw_gpa_arg =
+                                                mshv_bindings::mshv_read_write_gpa {
+                                                    base_gpa: ghcb_gpa + GHCB_SW_EXITINFO2_OFFSET,
+                                                    byte_count: std::mem::size_of::<u64>() as u32,
+                                                    ..Default::default()
+                                                };
+                                            self.fd.gpa_write(&mut swei2_rw_gpa_arg).map_err(
+                                                |e| cpu::HypervisorCpuError::GpaWrite(e.into()),
+                                            )?;
+                                        }
+                                        _ => {
+                                            panic!(
+                                                "SVM_EXITCODE_HV_DOORBELL_PAGE: Unhandled exit code: {:0x}",
+                                                exit_info1
+                                            );
+                                        }
+                                    }
+                                }
+                                SVM_EXITCODE_SNP_EXTENDED_GUEST_REQUEST => {
+                                    warn!("Fetching extended guest request is not supported");
+                                    // Extended guest request is not supported by the Hypervisor
+                                    // Returning the error to the guest
+                                    // 0x6 means `The NAE event was not valid`
+                                    // Reference: GHCB Spec, page 42
+                                    let value: u64 = 0x6;
+                                    let mut swei2_rw_gpa_arg = mshv_bindings::mshv_read_write_gpa {
+                                        base_gpa: ghcb_gpa + GHCB_SW_EXITINFO2_OFFSET,
+                                        byte_count: std::mem::size_of::<u64>() as u32,
+                                        ..Default::default()
+                                    };
+                                    swei2_rw_gpa_arg.data.copy_from_slice(&value.to_le_bytes());
+                                    self.fd
+                                        .gpa_write(&mut swei2_rw_gpa_arg)
+                                        .map_err(|e| cpu::HypervisorCpuError::GpaWrite(e.into()))?;
+                                }
+                                SVM_EXITCODE_IOIO_PROT => {
+                                    let exit_info1 =
+                                        info.__bindgen_anon_2.__bindgen_anon_1.sw_exit_info1 as u32;
+                                    let port_info = hv_sev_vmgexit_port_info {
+                                        as_uint32: exit_info1,
+                                    };
+
+                                    let port =
+                                        // SAFETY: Accessing a union element from bindgen generated bindings.
+                                        unsafe { port_info.__bindgen_anon_1.intercepted_port() };
+                                    let mut len = 4;
+                                    // SAFETY: Accessing a union element from bindgen generated bindings.
+                                    unsafe {
+                                        if port_info.__bindgen_anon_1.operand_size_16bit() == 1 {
+                                            len = 2;
+                                        } else if port_info.__bindgen_anon_1.operand_size_8bit()
+                                            == 1
+                                        {
+                                            len = 1;
+                                        }
+                                    }
+                                    let is_write =
+                                        // SAFETY: Accessing a union element from bindgen generated bindings.
+                                        unsafe { port_info.__bindgen_anon_1.access_type() == 0 };
+                                    let mut rax_rw_gpa_arg: mshv_read_write_gpa =
+                                        mshv_bindings::mshv_read_write_gpa {
+                                            base_gpa: ghcb_gpa + GHCB_RAX_OFFSET,
+                                            byte_count: std::mem::size_of::<u64>() as u32,
+                                            ..Default::default()
+                                        };
+                                    self.fd
+                                        .gpa_read(&mut rax_rw_gpa_arg)
+                                        .map_err(|e| cpu::HypervisorCpuError::GpaRead(e.into()))?;
+
+                                    if is_write {
+                                        if let Some(vm_ops) = &self.vm_ops {
+                                            vm_ops
+                                                .pio_write(
+                                                    port.into(),
+                                                    &rax_rw_gpa_arg.data[0..len],
+                                                )
+                                                .map_err(|e| {
+                                                    cpu::HypervisorCpuError::RunVcpu(e.into())
+                                                })?;
+                                        }
+                                    } else {
+                                        if let Some(vm_ops) = &self.vm_ops {
+                                            vm_ops
+                                                .pio_read(
+                                                    port.into(),
+                                                    &mut rax_rw_gpa_arg.data[0..len],
+                                                )
+                                                .map_err(|e| {
+                                                    cpu::HypervisorCpuError::RunVcpu(e.into())
+                                                })?;
+                                        }
+
+                                        self.fd.gpa_write(&mut rax_rw_gpa_arg).map_err(|e| {
+                                            cpu::HypervisorCpuError::GpaWrite(e.into())
+                                        })?;
+                                    }
+
+                                    // Clear the SW_EXIT_INFO1 register to indicate no error
+                                    let mut swei1_rw_gpa_arg = mshv_bindings::mshv_read_write_gpa {
+                                        base_gpa: ghcb_gpa + GHCB_SW_EXITINFO1_OFFSET,
+                                        byte_count: std::mem::size_of::<u64>() as u32,
+                                        ..Default::default()
+                                    };
+                                    self.fd
+                                        .gpa_write(&mut swei1_rw_gpa_arg)
+                                        .map_err(|e| cpu::HypervisorCpuError::GpaWrite(e.into()))?;
+                                }
+                                SVM_EXITCODE_MMIO_READ => {
+                                    let src_gpa =
+                                        info.__bindgen_anon_2.__bindgen_anon_1.sw_exit_info1;
+                                    let dst_gpa = info.__bindgen_anon_2.__bindgen_anon_1.sw_scratch;
+                                    let data_len =
+                                        info.__bindgen_anon_2.__bindgen_anon_1.sw_exit_info2
+                                            as usize;
+                                    // Sanity check to make sure data len is within supported range.
+                                    assert!(data_len <= 0x8);
+
+                                    let mut data: Vec<u8> = vec![0; data_len];
+                                    if let Some(vm_ops) = &self.vm_ops {
+                                        vm_ops.mmio_read(src_gpa, &mut data[0..data_len]).map_err(
+                                            |e| cpu::HypervisorCpuError::RunVcpu(e.into()),
+                                        )?;
+                                    }
+                                    let mut arg: mshv_read_write_gpa =
+                                        mshv_bindings::mshv_read_write_gpa {
+                                            base_gpa: dst_gpa,
+                                            byte_count: data_len as u32,
+                                            ..Default::default()
+                                        };
+                                    arg.data[0..data_len].copy_from_slice(&data);
+
+                                    self.fd
+                                        .gpa_write(&mut arg)
+                                        .map_err(|e| cpu::HypervisorCpuError::GpaWrite(e.into()))?;
+                                }
+                                SVM_EXITCODE_MMIO_WRITE => {
+                                    let dst_gpa =
+                                        info.__bindgen_anon_2.__bindgen_anon_1.sw_exit_info1;
+                                    let src_gpa = info.__bindgen_anon_2.__bindgen_anon_1.sw_scratch;
+                                    let data_len =
+                                        info.__bindgen_anon_2.__bindgen_anon_1.sw_exit_info2
+                                            as usize;
+                                    // Sanity check to make sure data len is within supported range.
+                                    assert!(data_len <= 0x8);
+                                    let mut arg: mshv_read_write_gpa =
+                                        mshv_bindings::mshv_read_write_gpa {
+                                            base_gpa: src_gpa,
+                                            byte_count: data_len as u32,
+                                            ..Default::default()
+                                        };
+
+                                    self.fd
+                                        .gpa_read(&mut arg)
+                                        .map_err(|e| cpu::HypervisorCpuError::GpaRead(e.into()))?;
+
+                                    if let Some(vm_ops) = &self.vm_ops {
+                                        vm_ops
+                                            .mmio_write(dst_gpa, &arg.data[0..data_len])
+                                            .map_err(|e| {
+                                                cpu::HypervisorCpuError::RunVcpu(e.into())
+                                            })?;
+                                    }
+                                }
+                                _ => panic!(
+                                    "GHCB_INFO_NORMAL: Unhandled exit code: {:0x}",
+                                    exit_code
+                                ),
+                            }
+                        }
+                        _ => panic!("Unsupported VMGEXIT operation: {:0x}", ghcb_op),
+                    }
+
+                    Ok(cpu::VmExit::Ignore)
+                }
                 exit => Err(cpu::HypervisorCpuError::RunVcpu(anyhow!(
                     "Unhandled VCPU exit {:?}",
                     exit
@@ -603,7 +1026,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 +1037,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)
@@ -1229,4 +1652,89 @@ impl vm::Vm for MshvVm {
     fn as_any(&self) -> &dyn Any {
         self
     }
+    /// Initialize the SEV-SNP VM
+    #[cfg(feature = "sev_snp")]
+    fn sev_snp_init(&self) -> vm::Result<()> {
+        self.fd
+            .set_partition_property(
+                hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_STATE,
+                hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE as u64,
+            )
+            .map_err(|e| vm::HypervisorVmError::InitializeSevSnp(e.into()))
+    }
+
+    #[cfg(feature = "sev_snp")]
+    fn import_isolated_pages(
+        &self,
+        page_type: u32,
+        page_size: u32,
+        pages: &[u64],
+    ) -> vm::Result<()> {
+        if pages.is_empty() {
+            return Ok(());
+        }
+
+        let mut isolated_pages =
+            vec_with_array_field::<mshv_import_isolated_pages, u64>(pages.len());
+        isolated_pages[0].num_pages = pages.len() as u64;
+        isolated_pages[0].page_type = page_type;
+        isolated_pages[0].page_size = page_size;
+        // SAFETY: isolated_pages initialized with pages.len() and now it is being turned into
+        // pages_slice with pages.len() again. It is guaranteed to be large enough to hold
+        // everything from pages.
+        unsafe {
+            let pages_slice: &mut [u64] = isolated_pages[0].page_number.as_mut_slice(pages.len());
+            pages_slice.copy_from_slice(pages);
+        }
+        self.fd
+            .import_isolated_pages(&isolated_pages[0])
+            .map_err(|e| vm::HypervisorVmError::ImportIsolatedPages(e.into()))
+    }
+    #[cfg(feature = "sev_snp")]
+    fn complete_isolated_import(
+        &self,
+        snp_id_block: IGVM_VHS_SNP_ID_BLOCK,
+        host_data: &[u8],
+        id_block_enabled: u8,
+    ) -> vm::Result<()> {
+        let mut auth_info = hv_snp_id_auth_info {
+            id_key_algorithm: snp_id_block.id_key_algorithm,
+            auth_key_algorithm: snp_id_block.author_key_algorithm,
+            ..Default::default()
+        };
+        // Each of r/s component is 576 bits long
+        auth_info.id_block_signature[..SIG_R_COMPONENT_SIZE_IN_BYTES]
+            .copy_from_slice(snp_id_block.id_key_signature.r_comp.as_ref());
+        auth_info.id_block_signature
+            [SIG_R_COMPONENT_SIZE_IN_BYTES..SIG_R_AND_S_COMPONENT_SIZE_IN_BYTES]
+            .copy_from_slice(snp_id_block.id_key_signature.s_comp.as_ref());
+        auth_info.id_key[..ECDSA_CURVE_ID_SIZE_IN_BYTES]
+            .copy_from_slice(snp_id_block.id_public_key.curve.to_le_bytes().as_ref());
+        auth_info.id_key[ECDSA_SIG_X_COMPONENT_START..ECDSA_SIG_X_COMPONENT_END]
+            .copy_from_slice(snp_id_block.id_public_key.qx.as_ref());
+        auth_info.id_key[ECDSA_SIG_Y_COMPONENT_START..ECDSA_SIG_Y_COMPONENT_END]
+            .copy_from_slice(snp_id_block.id_public_key.qy.as_ref());
+
+        let data = mshv_complete_isolated_import {
+            import_data: hv_partition_complete_isolated_import_data {
+                psp_parameters: hv_psp_launch_finish_data {
+                    id_block: hv_snp_id_block {
+                        launch_digest: snp_id_block.ld,
+                        family_id: snp_id_block.family_id,
+                        image_id: snp_id_block.image_id,
+                        version: snp_id_block.version,
+                        guest_svn: snp_id_block.guest_svn,
+                        policy: get_default_snp_guest_policy(),
+                    },
+                    id_auth_info: auth_info,
+                    host_data: host_data[0..32].try_into().unwrap(),
+                    id_block_enabled,
+                    author_key_enabled: 0,
+                },
+            },
+        };
+        self.fd
+            .complete_isolated_import(&data)
+            .map_err(|e| vm::HypervisorVmError::CompleteIsolatedImport(e.into()))
+    }
 }

hypervisor/src/mshv/snp_constants.rs

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
+//
+// Copyright © 2020, Microsoft Corporation
+//
+
+// Reference: https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/56860.pdf
+// Chapter 10
+pub const SIG_R_COMPONENT_SIZE_IN_BYTES: usize = 72;
+pub const SIG_R_AND_S_COMPONENT_SIZE_IN_BYTES: usize = 144;
+pub const ECDSA_CURVE_ID_SIZE_IN_BYTES: usize = 4;
+pub const ECDSA_SIG_X_COMPONENT_SIZE_IN_BYTES: usize = 72;
+pub const ECDSA_SIG_Y_COMPONENT_SIZE_IN_BYTES: usize = 72;
+pub const ECDSA_SIG_X_COMPONENT_START: usize = ECDSA_CURVE_ID_SIZE_IN_BYTES;
+pub const ECDSA_SIG_X_COMPONENT_END: usize =
+    ECDSA_SIG_X_COMPONENT_START + ECDSA_SIG_X_COMPONENT_SIZE_IN_BYTES;
+pub const ECDSA_SIG_Y_COMPONENT_START: usize = ECDSA_SIG_X_COMPONENT_END;
+pub const ECDSA_SIG_Y_COMPONENT_END: usize =
+    ECDSA_SIG_X_COMPONENT_END + ECDSA_SIG_Y_COMPONENT_SIZE_IN_BYTES;
+
+// These constants are derived from GHCB spec Sect. 2.6 Table 3 GHCB Layout
+// Link: https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/56421.pdf
+pub const GHCB_RAX_OFFSET: u64 = 0x01F8;
+pub const GHCB_SW_EXITINFO1_OFFSET: u64 = 0x398;
+pub const GHCB_SW_EXITINFO2_OFFSET: u64 = 0x3A0;

hypervisor/src/vm.rs

@@ -19,6 +19,8 @@ use crate::cpu::Vcpu;
 use crate::ClockData;
 use crate::UserMemoryRegion;
 use crate::{IoEventAddress, IrqRoutingEntry};
+#[cfg(feature = "sev_snp")]
+use igvm_defs::IGVM_VHS_SNP_ID_BLOCK;
 use std::any::Any;
 #[cfg(target_arch = "x86_64")]
 use std::fs::File;
@@ -190,6 +192,13 @@ pub enum HypervisorVmError {
     #[error("Failed to assert virtual Interrupt: {0}")]
     AsserttVirtualInterrupt(#[source] anyhow::Error),
 
+    #[cfg(feature = "sev_snp")]
+    ///
+    /// Error initializing SEV-SNP on the VM
+    ///
+    #[error("Failed to initialize SEV-SNP: {0}")]
+    InitializeSevSnp(#[source] std::io::Error),
+
     #[cfg(feature = "tdx")]
     ///
     /// Error initializing TDX on the VM
@@ -213,6 +222,15 @@ pub enum HypervisorVmError {
     ///
     #[error("Failed to create Vgic: {0}")]
     CreateVgic(#[source] anyhow::Error),
+    ///
+    /// Import isolated pages error
+    ///
+    #[error("Failed to import isolated pages: {0}")]
+    ImportIsolatedPages(#[source] anyhow::Error),
+    /// Failed to complete isolated import
+    ///
+    #[error("Failed to complete isolated import: {0}")]
+    CompleteIsolatedImport(#[source] anyhow::Error),
 }
 ///
 /// Result type for returning from a function
@@ -324,8 +342,13 @@ pub trait Vm: Send + Sync + Any {
     fn stop_dirty_log(&self) -> Result<()>;
     /// Get dirty pages bitmap
     fn get_dirty_log(&self, slot: u32, base_gpa: u64, memory_size: u64) -> Result<Vec<u64>>;
+    #[cfg(feature = "sev_snp")]
+    /// Initialize SEV-SNP on this VM
+    fn sev_snp_init(&self) -> Result<()> {
+        unimplemented!()
+    }
     #[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 +358,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,
@@ -347,6 +370,26 @@ pub trait Vm: Send + Sync + Any {
     }
     /// Downcast to the underlying hypervisor VM type
     fn as_any(&self) -> &dyn Any;
+    /// Import the isolated pages
+    #[cfg(feature = "sev_snp")]
+    fn import_isolated_pages(
+        &self,
+        _page_type: u32,
+        _page_size: u32,
+        _pages: &[u64],
+    ) -> Result<()> {
+        unimplemented!()
+    }
+    /// Complete the isolated import
+    #[cfg(feature = "sev_snp")]
+    fn complete_isolated_import(
+        &self,
+        _snp_id_block: IGVM_VHS_SNP_ID_BLOCK,
+        _host_data: &[u8],
+        _id_block_enabled: u8,
+    ) -> Result<()> {
+        unimplemented!()
+    }
 }
 
 pub trait VmOps: Send + Sync {

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,