.github: Re-order release steps to ensure binaries are available

Since we run "cargo clean" before running the aarch64 build we need to create the release and upload the x86-64 assets before the clean. Signed-off-by: Rob Bradford <robert.bradford@intel.com>
build: Release v29.0
2026-08-05 02:19:16 +00:00 · 2023-01-14 12:12:11 +00:00 · 2023-01-13 17:10:35 +00:00 · 2023-01-13 16:44:59 +00:00 · 2023-01-13 16:44:59 +00:00 · 2023-01-13 14:38:15 +00:00
205 changed files with 10296 additions and 6381 deletions
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -34,22 +34,22 @@ jobs:
          override: true

      - name: Build (default features)
-        run: cargo rustc --locked --bin cloud-hypervisor -- -D warnings
+        run: cargo rustc --locked --bin cloud-hypervisor -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Build (kvm)
-        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "kvm"  -- -D warnings
+        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "kvm"  -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Build (default features + tdx)
-        run: cargo rustc --locked --bin cloud-hypervisor --features "tdx" -- -D warnings
+        run: cargo rustc --locked --bin cloud-hypervisor --features "tdx" -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Build (default features + guest_debug)
-        run: cargo rustc --locked --bin cloud-hypervisor --features "guest_debug" -- -D warnings
+        run: cargo rustc --locked --bin cloud-hypervisor --features "guest_debug" -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Build (mshv)
-        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "mshv"  -- -D warnings
+        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "mshv"  -- -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
+        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "mshv,kvm"  -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Release Build (default features)
        run: cargo build --locked --all --release --target=${{ matrix.target }}
--- a/.github/workflows/quality.yaml
+++ b/.github/workflows/quality.yaml
@@ -13,15 +13,24 @@ jobs:
        rust:
          - stable
        target:
-          - x86_64-unknown-linux-gnu
          - aarch64-unknown-linux-gnu
+          - aarch64-unknown-linux-musl
+          - x86_64-unknown-linux-gnu
+          - x86_64-unknown-linux-musl
+
        experimental: [false]
        include:
+          - rust: beta
+            target: aarch64-unknown-linux-gnu
+            experimental: true
+          - rust: beta
+            target: aarch64-unknown-linux-musl
+            experimental: true
          - rust: beta
            target: x86_64-unknown-linux-gnu
            experimental: true
          - rust: beta
-            target: aarch64-unknown-linux-gnu
+            target: x86_64-unknown-linux-musl
            experimental: true
    steps:
      - name: Code checkout
@@ -53,28 +62,28 @@ jobs:
        with:
          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
          command: clippy
-          args: --locked --all --all-targets --no-default-features --tests --features "kvm" -- -D warnings
+          args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --features "kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Clippy (default features)
        uses: actions-rs/cargo@v1
        with:
          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
          command: clippy
-          args: --locked --all --all-targets --tests -- -D warnings
+          args: --target=${{ matrix.target }} --locked --all --all-targets --tests -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Clippy (default features + guest_debug)
        uses: actions-rs/cargo@v1
        with:
          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
          command: clippy
-          args: --locked --all --all-targets --tests --features "guest_debug" -- -D warnings
+          args: --target=${{ matrix.target }} --locked --all --all-targets --tests --features "guest_debug" -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Clippy (default features + tracing)
        uses: actions-rs/cargo@v1
        with:
          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
          command: clippy
-          args: --locked --all --all-targets --tests --features "tracing" -- -D warnings
+          args: --target=${{ matrix.target }} --locked --all --all-targets --tests --features "tracing" -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Clippy (mshv)
        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
@@ -82,7 +91,7 @@ jobs:
        with:
          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
          command: clippy
-          args: --locked --all --all-targets --no-default-features --tests --features "mshv" -- -D warnings
+          args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --features "mshv" -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Clippy (mshv + kvm)
        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
@@ -90,7 +99,7 @@ jobs:
        with:
          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
          command: clippy
-          args: --locked --all --all-targets --no-default-features --tests --features "mshv,kvm" -- -D warnings
+          args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --features "mshv,kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Clippy (kvm + tdx)
        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
@@ -98,7 +107,7 @@ jobs:
        with:
          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
          command: clippy
-          args: --locked --all --all-targets --no-default-features --tests --features "tdx,kvm" -- -D warnings
+          args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --features "tdx,kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks

      - name: Check build did not modify any files
        run: test -z "$(git status --porcelain)"
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -1,62 +1,47 @@
 name: Cloud Hypervisor Release
-on: [create]
+on: [pull_request, create]

 jobs:
  release:
-    if: github.event_name == 'create' && github.event.ref_type == 'tag'
    name: Release
    runs-on: ubuntu-latest
    steps:
      - name: Code checkout
        uses: actions/checkout@v2
      - name: Install musl-gcc
-        run: sudo apt install -y musl-tools      
+        run: sudo apt install -y musl-tools
      - name: Create release directory
        run: rsync -rv --exclude=.git . ../cloud-hypervisor-${{ github.event.ref }}
      - name: Install Rust toolchain (x86_64-unknown-linux-gnu)
        uses: actions-rs/toolchain@v1
        with:
-            toolchain: "1.62"
-            target: x86_64-unknown-linux-gnu
+          toolchain: "1.62"
+          target: x86_64-unknown-linux-gnu
      - name: Install Rust toolchain (x86_64-unknown-linux-musl)
        uses: actions-rs/toolchain@v1
        with:
-            toolchain: "1.62"
-            target: x86_64-unknown-linux-musl
+          toolchain: "1.62"
+          target: x86_64-unknown-linux-musl
      - name: Build
        uses: actions-rs/cargo@v1
        with:
-            toolchain: "1.62"
-            command: build
-            args: --all --release --target=x86_64-unknown-linux-gnu
+          toolchain: "1.62"
+          command: build
+          args: --all --release --no-default-features --features "kvm,mshv" --target=x86_64-unknown-linux-gnu
      - name: Static Build
        uses: actions-rs/cargo@v1
        with:
-            toolchain: "1.62"
-            command: build
-            args: --all --release --target=x86_64-unknown-linux-musl
-      - name: Strip cloud-hypervisor binaries
-        run: strip target/*/release/cloud-hypervisor
+          toolchain: "1.62"
+          command: build
+          args: --all --release --no-default-features --features "kvm,mshv" --target=x86_64-unknown-linux-musl
      - name: Install Rust toolchain (aarch64-unknown-linux-musl)
        uses: actions-rs/toolchain@v1
        with:
-            toolchain: "1.62"
-            target: aarch64-unknown-linux-musl
-            override: true
-      - name: Static Build (AArch64)
-        uses: actions-rs/cargo@v1
-        with:
-            use-cross: true
-            command: build
-            args: --all --release --target=aarch64-unknown-linux-musl
-      - name: Vendor
-        working-directory: ../cloud-hypervisor-${{ github.event.ref }}
-        run: |
-          mkdir ../vendor-cargo-home
-          export CARGO_HOME=$(realpath ../vendor-cargo-home)
-          mkdir .cargo
-          cargo vendor > .cargo/config.toml
+          toolchain: "1.62"
+          target: aarch64-unknown-linux-musl
+          override: true
      - name: Create Release
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
        id: create_release
        uses: actions/create-release@v1
        env:
@@ -66,20 +51,8 @@ jobs:
          release_name: ${{ github.ref }}
          draft: true
          prerelease: true
-      - name: Create vendored source archive
-        working-directory: ../
-        run:  tar cJf cloud-hypervisor-${{ github.event.ref }}.tar.xz cloud-hypervisor-${{ github.event.ref }}
-      - name: Upload cloud-hypervisor vendored source archive
-        id: upload-release-cloud-hypervisor-vendored-sources
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ../cloud-hypervisor-${{ github.event.ref }}.tar.xz
-          asset_name: cloud-hypervisor-${{ github.event.ref }}.tar.xz
-          asset_content_type: application/x-xz
      - name: Upload cloud-hypervisor
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
        id: upload-release-cloud-hypervisor
        uses: actions/upload-release-asset@v1
        env:
@@ -90,6 +63,7 @@ jobs:
          asset_name: cloud-hypervisor
          asset_content_type: application/octet-stream
      - name: Upload static cloud-hypervisor
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
        id: upload-release-static-cloud-hypervisor
        uses: actions/upload-release-asset@v1
        env:
@@ -100,6 +74,7 @@ jobs:
          asset_name: cloud-hypervisor-static
          asset_content_type: application/octet-stream
      - name: Upload ch-remote
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
        id: upload-release-ch-remote
        uses: actions/upload-release-asset@v1
        env:
@@ -110,6 +85,7 @@ jobs:
          asset_name: ch-remote
          asset_content_type: application/octet-stream
      - name: Upload static-ch-remote
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
        id: upload-release-static-ch-remote
        uses: actions/upload-release-asset@v1
        env:
@@ -119,7 +95,18 @@ jobs:
          asset_path: target/x86_64-unknown-linux-musl/release/ch-remote
          asset_name: ch-remote-static
          asset_content_type: application/octet-stream
+      - name: Clean build tree ahead of cross build
+        uses: actions-rs/cargo@v1
+        with:
+          command: clean
+      - name: Static Build (AArch64)
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: build
+          args: --all --release --target=aarch64-unknown-linux-musl
      - name: Upload static AArch64 cloud-hypervisor
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
        id: upload-release-static-aarch64-cloud-hypervisor
        uses: actions/upload-release-asset@v1
        env:
@@ -130,6 +117,7 @@ jobs:
          asset_name: cloud-hypervisor-static-aarch64
          asset_content_type: application/octet-stream
      - name: Upload static AArch64 ch-remote
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
        id: upload-release-static-aarch64-ch-remote
        uses: actions/upload-release-asset@v1
        env:
@@ -139,3 +127,24 @@ jobs:
          asset_path: target/aarch64-unknown-linux-musl/release/ch-remote
          asset_name: ch-remote-static-aarch64
          asset_content_type: application/octet-stream
+      - name: Vendor
+        working-directory: ../cloud-hypervisor-${{ github.event.ref }}
+        run: |
+          mkdir ../vendor-cargo-home
+          export CARGO_HOME=$(realpath ../vendor-cargo-home)
+          mkdir .cargo
+          cargo vendor > .cargo/config.toml
+      - name: Create vendored source archive
+        working-directory: ../
+        run: tar cJf cloud-hypervisor-${{ github.event.ref }}.tar.xz cloud-hypervisor-${{ github.event.ref }}
+      - name: Upload cloud-hypervisor vendored source archive
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
+        id: upload-release-cloud-hypervisor-vendored-sources
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ../cloud-hypervisor-${{ github.event.ref }}.tar.xz
+          asset_name: cloud-hypervisor-${{ github.event.ref }}.tar.xz
+          asset_content_type: application/x-xz
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@
 **/Cargo.lock
 **/rusty-tags.vi
 /rpm/SOURCES
+/.vscode
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,18 +11,18 @@ dependencies = [

 [[package]]
 name = "aho-corasick"
-version = "0.7.19"
+version = "0.7.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
+checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
 dependencies = [
 "memchr",
 ]

 [[package]]
 name = "anyhow"
-version = "1.0.65"
+version = "1.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98161a4e3e2184da77bb14f02184cdd111e83bbbcc9979dfee3c44b9a85f5602"
+checksum = "2cb2f989d18dd141ab8ae82f64d1a8cdd37e0840f73a406896cf5e99502fab61"

 [[package]]
 name = "api_client"
@@ -59,17 +59,6 @@ dependencies = [
 "vmm-sys-util",
 ]

-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -99,6 +88,7 @@ dependencies = [
 "libc",
 "log",
 "qcow",
+ "smallvec",
 "thiserror",
 "versionize",
 "versionize_derive",
@@ -118,9 +108,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"

 [[package]]
 name = "cc"
-version = "1.0.73"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+checksum = "a20104e2335ce8a659d6dd92a51a767a0c062599c73b343fd152cb401e828c3d"

 [[package]]
 name = "cfg-if"
@@ -130,33 +120,31 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "clap"
-version = "3.2.22"
+version = "4.0.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86447ad904c7fb335a790c9d7fe3d0d971dc523b8ccd1561a520de9a85302750"
+checksum = "a7db700bc935f9e43e88d00b0850dae18a63773cfbec6d8e070fccf7fef89a39"
 dependencies = [
- "atty",
 "bitflags",
 "clap_lex",
- "indexmap",
+ "is-terminal",
 "once_cell",
 "strsim",
 "termcolor",
 "terminal_size",
- "textwrap",
 ]

 [[package]]
 name = "clap_lex"
-version = "0.2.4"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"
 dependencies = [
 "os_str_bytes",
 ]

 [[package]]
 name = "cloud-hypervisor"
-version = "27.0.0"
+version = "29.0.0"
 dependencies = [
 "anyhow",
 "api_client",
@@ -175,6 +163,7 @@ dependencies = [
 "signal-hook",
 "test_infra",
 "thiserror",
+ "tpm",
 "tracer",
 "vm-memory",
 "vmm",
@@ -199,9 +188,9 @@ checksum = "55626594feae15d266d52440b26ff77de0e22230cf0c113abe619084c1ddc910"

 [[package]]
 name = "darling"
-version = "0.14.1"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4529658bdda7fd6769b8614be250cdcfc3aeb0ee72fe66f9e41e5e5eb73eac02"
+checksum = "b0dd3cd20dc6b5a876612a6e5accfe7f3dd883db6d07acfbf14c128f61550dfa"
 dependencies = [
 "darling_core",
 "darling_macro",
@@ -209,9 +198,9 @@ dependencies = [

 [[package]]
 name = "darling_core"
-version = "0.14.1"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "649c91bc01e8b1eac09fb91e8dbc7d517684ca6be8ebc75bb9cafc894f9fdb6f"
+checksum = "a784d2ccaf7c98501746bf0be29b2022ba41fd62a2e622af997a03e9f972859f"
 dependencies = [
 "fnv",
 "ident_case",
@@ -223,9 +212,9 @@ dependencies = [

 [[package]]
 name = "darling_macro"
-version = "0.14.1"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddfc69c5bfcbd2fc09a0f38451d2daf0e372e367986a83906d1b0dbc88134fb5"
+checksum = "7618812407e9402654622dd402b0a89dff9ba93badd6540781526117b92aab7e"
 dependencies = [
 "darling_core",
 "quote",
@@ -244,6 +233,9 @@ dependencies = [
 "hypervisor",
 "libc",
 "log",
+ "phf",
+ "thiserror",
+ "tpm",
 "versionize",
 "versionize_derive",
 "vm-device",
@@ -274,12 +266,12 @@ dependencies = [

 [[package]]
 name = "env_logger"
-version = "0.9.1"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c90bf5f19754d10198ccb95b70664fc925bd1fc090a0fd9a6ebc54acc8cd6272"
+checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0"
 dependencies = [
- "atty",
 "humantime",
+ "is-terminal",
 "log",
 "regex",
 "termcolor",
@@ -363,9 +355,9 @@ dependencies = [

 [[package]]
 name = "getrandom"
-version = "0.2.7"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6"
+checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
 "cfg-if",
 "libc",
@@ -378,17 +370,11 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"

-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
 [[package]]
 name = "hermit-abi"
-version = "0.1.20"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7a30908dbce072eca83216eab939d2290080e00ca71611b96a09e5cdce5f3fa"
+checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
 dependencies = [
 "libc",
 ]
@@ -423,12 +409,11 @@ dependencies = [

 [[package]]
 name = "iced-x86"
-version = "1.17.0"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "158f5204401d08f91d19176112146d75e99b3cf745092e268fa7be33e09adcec"
+checksum = "1dd04b950d75b3498320253b17fb92745b2cc79ead8814aede2f7c1bab858bec"
 dependencies = [
 "lazy_static",
- "static_assertions",
 ]

 [[package]]
@@ -437,16 +422,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

-[[package]]
-name = "indexmap"
-version = "1.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
-dependencies = [
- "autocfg",
- "hashbrown",
-]
-
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -458,15 +433,19 @@ dependencies = [

 [[package]]
 name = "io-lifetimes"
-version = "0.7.3"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ea37f355c05dde75b84bba2d767906ad522e97cd9e2eef2be7a4ab7fb442c06"
+checksum = "46112a93252b123d31a119a8d1a1ac19deac4fac6e0e8b0df58f0d4e5870e63c"
+dependencies = [
+ "libc",
+ "windows-sys",
+]

 [[package]]
 name = "io-uring"
-version = "0.5.6"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a645fd8e7048c2f54050f7d0d4de8f624ada437e043bc7d72609bd08d70120b"
+checksum = "c9ddf18110cedc09617f5a965bdb51adb0c0fb02c791e4ab22f7a21bb25269b0"
 dependencies = [
 "bitflags",
 "libc",
@@ -482,15 +461,27 @@ dependencies = [
 ]

 [[package]]
-name = "itoa"
-version = "1.0.3"
+name = "is-terminal"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8af84674fe1f223a982c933a0ee1086ac4d4052aa0fb8060c12c6ad838e754"
+checksum = "28dfb6c8100ccc63462345b67d1bbc3679177c75ee4bf59bf29c8b1d110b8189"
+dependencies = [
+ "hermit-abi",
+ "io-lifetimes",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"

 [[package]]
 name = "kvm-bindings"
-version = "0.5.0"
-source = "git+https://github.com/cloud-hypervisor/kvm-bindings?branch=ch-v0.5.0-tdx#52e56d0e8ef0f6ea32fc0492e6a175b73617a49f"
+version = "0.6.0"
+source = "git+https://github.com/cloud-hypervisor/kvm-bindings?branch=ch-v0.6.0-tdx#7d9ffb47e5b9b1989577258800a0f57c93f1445f"
 dependencies = [
 "serde",
 "serde_derive",
@@ -499,8 +490,9 @@ dependencies = [

 [[package]]
 name = "kvm-ioctls"
-version = "0.11.0"
-source = "git+https://github.com/rust-vmm/kvm-ioctls?branch=main#e6739aeebcc56dfea62216b2cc4cddd13d0a1182"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3a321cabd827642499c77e27314f388dd83a717a5ca716b86476fb947f73ae4"
 dependencies = [
 "kvm-bindings",
 "libc",
@@ -515,9 +507,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.133"
+version = "0.2.139"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0f80d65747a3e43d1596c7c5492d95d5edddaabd45a7fcdb02b95f644164966"
+checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"

 [[package]]
 name = "libssh2-sys"
@@ -547,18 +539,18 @@ dependencies = [

 [[package]]
 name = "linux-loader"
-version = "0.6.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62a2f912deca034ec34b0a43a390059ea98daac40e440ebe8bea88f3315fe168"
+checksum = "b9259ddbfbb52cc918f6bbc60390004ddd0228cf1d85f402009ff2b3d95de83f"
 dependencies = [
 "vm-memory",
 ]

 [[package]]
 name = "linux-raw-sys"
-version = "0.0.46"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"
+checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"

 [[package]]
 name = "lock_api"
@@ -594,7 +586,7 @@ checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 [[package]]
 name = "micro_http"
 version = "0.1.0"
-source = "git+https://github.com/firecracker-microvm/micro-http?branch=main#863b0370ba7e57f7df5b908ada9e5b44809ccae9"
+source = "git+https://github.com/firecracker-microvm/micro-http?branch=main#4b18a043e997da5b5f679e3defc279fec908753e"
 dependencies = [
 "libc",
 "vmm-sys-util",
@@ -603,7 +595,7 @@ dependencies = [
 [[package]]
 name = "mshv-bindings"
 version = "0.1.1"
-source = "git+https://github.com/rust-vmm/mshv?branch=main#2d0aaa16b00eec5470aed0d4e8f8ce24550df6d1"
+source = "git+https://github.com/rust-vmm/mshv?branch=main#fb19bb30110c3a3268ad815897bba407fce1843c"
 dependencies = [
 "libc",
 "serde",
@@ -615,7 +607,7 @@ dependencies = [
 [[package]]
 name = "mshv-ioctls"
 version = "0.1.1"
-source = "git+https://github.com/rust-vmm/mshv?branch=main#2d0aaa16b00eec5470aed0d4e8f8ce24550df6d1"
+source = "git+https://github.com/rust-vmm/mshv?branch=main#fb19bb30110c3a3268ad815897bba407fce1843c"
 dependencies = [
 "libc",
 "mshv-bindings",
@@ -671,24 +663,24 @@ dependencies = [

 [[package]]
 name = "once_cell"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1"
+checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"

 [[package]]
 name = "openssl-src"
-version = "111.22.0+1.1.1q"
+version = "111.24.0+1.1.1s"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f31f0d509d1c1ae9cada2f9539ff8f37933831fd5098879e482aa687d659853"
+checksum = "3498f259dab01178c6228c6b00dcef0ed2a2d5e20d648c017861227773ea4abd"
 dependencies = [
 "cc",
 ]

 [[package]]
 name = "openssl-sys"
-version = "0.9.76"
+version = "0.9.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5230151e44c0f05157effb743e8d517472843121cf9243e8b81393edb5acd9ce"
+checksum = "23bbbf7854cd45b83958ebe919f0e8e516793727652e27fda10a8384cfc790b7"
 dependencies = [
 "autocfg",
 "cc",
@@ -704,9 +696,9 @@ version = "0.1.0"

 [[package]]
 name = "os_str_bytes"
-version = "6.3.0"
+version = "6.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ff7415e9ae3fff1225851df9e0d9e4e5479f947619774677a63572e55e80eff"
+checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"

 [[package]]
 name = "parking_lot"
@@ -735,9 +727,9 @@ dependencies = [

 [[package]]
 name = "paste"
-version = "1.0.9"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1"
+checksum = "d01a5bd0424d00070b0098dd17ebca6f961a959dead1dbcbbbc1d1cd8d3deeba"

 [[package]]
 name = "pci"
@@ -776,10 +768,52 @@ dependencies = [
 ]

 [[package]]
-name = "pkg-config"
-version = "0.3.25"
+name = "phf"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae"
+checksum = "928c6535de93548188ef63bb7c4036bd415cd8f36ad25af44b9789b2ee72a48c"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1181c94580fa345f50f19d738aaa39c0ed30a600d95cb2d3e23f94266f14fbf"
+dependencies = [
+ "phf_shared",
+ "rand",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92aacdc5f16768709a569e913f7451034034178b05bdc8acda226659a3dccc66"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1fb5f6f826b772a8d4c0394209441e7d37cbbb967ae9c7e0e8134365c9ee676"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"

 [[package]]
 name = "pnet"
@@ -872,9 +906,9 @@ dependencies = [

 [[package]]
 name = "proc-macro2"
-version = "1.0.44"
+version = "1.0.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bd7356a8122b6c4a24a82b278680c73357984ca2fc79a0f9fa6dea7dced7c58"
+checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
 dependencies = [
 "unicode-ident",
 ]
@@ -892,13 +926,28 @@ dependencies = [

 [[package]]
 name = "quote"
-version = "1.0.21"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
+checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
 dependencies = [
 "proc-macro2",
 ]

+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
 [[package]]
 name = "rate_limiter"
 version = "0.1.0"
@@ -930,9 +979,9 @@ dependencies = [

 [[package]]
 name = "regex"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b"
+checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
 dependencies = [
 "aho-corasick",
 "memchr",
@@ -941,15 +990,15 @@ dependencies = [

 [[package]]
 name = "regex-syntax"
-version = "0.6.27"
+version = "0.6.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
+checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"

 [[package]]
 name = "remain"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06df529c0d271b27ac4a2c260f5ce2914b60bd44702cecec7b9f271adbdde23b"
+checksum = "5704e2cda92fd54202f05430725317ba0ea7d0c96b246ca0a92e45177127ba3b"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -967,9 +1016,9 @@ dependencies = [

 [[package]]
 name = "rustix"
-version = "0.35.10"
+version = "0.36.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af895b90e5c071badc3136fc10ff0bcfc98747eadbaf43ed8f214e07ba8f8477"
+checksum = "a3807b5d10909833d3e9acd1eb5fb988f79376ff10fce42937de71a449c4c588"
 dependencies = [
 "bitflags",
 "errno",
@@ -1002,24 +1051,24 @@ dependencies = [

 [[package]]
 name = "semver"
-version = "1.0.14"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e25dfac463d778e353db5be2449d1cce89bd6fd23c9f1ea21310ce6e5a1b29c4"
+checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"

 [[package]]
 name = "serde"
-version = "1.0.145"
+version = "1.0.151"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "728eb6351430bccb993660dfffc5a72f91ccc1295abaa8ce19b27ebe4f75568b"
+checksum = "97fed41fc1a24994d044e6db6935e69511a1153b52c15eb42493b26fa87feba0"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.145"
+version = "1.0.151"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81fa1584d3d1bcacd84c277a0dfe21f5b0f6accf4a23d04d4c6d61f1af522b4c"
+checksum = "255abe9a125a985c05190d687b320c12f9b1f0b99445e608c21ba0782c719ad8"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1028,9 +1077,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.85"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e55a28e3aaef9d5ce0506d0a14dbba8054ddc7e499ef522dd8b26859ec9d4a44"
+checksum = "020ff22c755c2ed3f8cf162dbb41a7268d934702f3ed3631656ea597e08fc3db"
 dependencies = [
 "itoa",
 "ryu",
@@ -1039,9 +1088,9 @@ dependencies = [

 [[package]]
 name = "serde_with"
-version = "2.0.1"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368f2d60d049ea019a84dcd6687b0d1e0030fe663ae105039bdf967ed5e6a9a7"
+checksum = "25bf4a5a814902cd1014dbccfa4d4560fb8432c779471e96e035602519f82eef"
 dependencies = [
 "serde",
 "serde_with_macros",
@@ -1049,9 +1098,9 @@ dependencies = [

 [[package]]
 name = "serde_with_macros"
-version = "2.0.1"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ccadfacf6cf10faad22bbadf55986bdd0856edfb5d9210aa1dcf1f516e84e93"
+checksum = "e3452b4c0f6c1e357f73fdb87cd1efabaa12acf328c7a528e252893baeb3f4aa"
 dependencies = [
 "darling",
 "proc-macro2",
@@ -1083,10 +1132,16 @@ dependencies = [
 ]

 [[package]]
-name = "smallvec"
-version = "1.9.0"
+name = "siphasher"
+version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fd0db749597d91ff862fd1d55ea87f7855a744a8425a64695b6fca237d1dad1"
+checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
+
+[[package]]
+name = "smallvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"

 [[package]]
 name = "ssh2"
@@ -1100,12 +1155,6 @@ dependencies = [
 "parking_lot",
 ]

-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
 [[package]]
 name = "strsim"
 version = "0.10.0"
@@ -1114,27 +1163,15 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

 [[package]]
 name = "syn"
-version = "1.0.101"
+version = "1.0.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e90cde112c4b9690b8cbe810cba9ddd8bc1d7472e2cae317b69e9438c1cba7d2"
+checksum = "60b9b43d45702de4c839cb9b51d9f529c5dd26a4aff255b42b1ebc03e88ee908"
 dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
 ]

-[[package]]
-name = "synstructure"
-version = "0.12.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "unicode-xid",
-]
-
 [[package]]
 name = "termcolor"
 version = "1.1.3"
@@ -1146,9 +1183,9 @@ dependencies = [

 [[package]]
 name = "terminal_size"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8440c860cf79def6164e4a0a983bcc2305d82419177a0e0c71930d049e3ac5a1"
+checksum = "cb20089a8ba2b69debd491f8d2d023761cbf196e999218c591fa1e7e15a21907"
 dependencies = [
 "rustix",
 "windows-sys",
@@ -1169,35 +1206,38 @@ dependencies = [
 "wait-timeout",
 ]

-[[package]]
-name = "textwrap"
-version = "0.15.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "949517c0cf1bf4ee812e2e07e08ab448e3ae0d23472aee8a06c985f0c8815b16"
-dependencies = [
- "terminal_size",
-]
-
 [[package]]
 name = "thiserror"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
+checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
+checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]

+[[package]]
+name = "tpm"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "libc",
+ "log",
+ "thiserror",
+ "vmm-sys-util",
+]
+
 [[package]]
 name = "tracer"
 version = "0.1.0"
@@ -1211,21 +1251,15 @@ dependencies = [

 [[package]]
 name = "unicode-ident"
-version = "1.0.4"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"

 [[package]]
 name = "uuid"
-version = "1.1.2"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd6469f4314d5f1ffec476e05f17cc9a78bc7a27a6a857842170bdf8d6f98d2f"
+checksum = "422ee0de9031b5b948b97a8fc04e3aa35230001a722ddd27943e0be31564ce4c"
 dependencies = [
 "getrandom",
 ]
@@ -1238,9 +1272,9 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"

 [[package]]
 name = "versionize"
-version = "0.1.6"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7429cf68de8f091b667d27323ed323afd39584a56d533995b12ddd748e5e6ca9"
+checksum = "d6e2495726cf917e7ba7ec8bf0f0fceab543dd38d0a4195ed6bef331e38a290f"
 dependencies = [
 "bincode",
 "crc64",
@@ -1265,17 +1299,16 @@ dependencies = [

 [[package]]
 name = "vfio-bindings"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43449b404c488f70507dca193debd4bea361fe8089869b947adc19720e464bce"
+version = "0.4.0"
+source = "git+https://github.com/rust-vmm/vfio?branch=main#7ef33f6759ae6d37a54cd66f749aa47c1c81509c"
 dependencies = [
 "vmm-sys-util",
 ]

 [[package]]
 name = "vfio-ioctls"
-version = "0.1.0"
-source = "git+https://github.com/rust-vmm/vfio?branch=main#bf7c9b997b4ad0ca1ab4bfe96dc1b10d4bc5be24"
+version = "0.2.0"
+source = "git+https://github.com/rust-vmm/vfio?branch=main#7ef33f6759ae6d37a54cd66f749aa47c1c81509c"
 dependencies = [
 "byteorder",
 "kvm-bindings",
@@ -1320,9 +1353,9 @@ dependencies = [

 [[package]]
 name = "vhost"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79243657c76e5c90dcbf60187c842614f6dfc7123972c55bb3bcc446792aca93"
+checksum = "c9b791c5b0717a0558888a4cf7240cea836f39a99cb342e12ce633dcaa078072"
 dependencies = [
 "bitflags",
 "libc",
@@ -1332,9 +1365,9 @@ dependencies = [

 [[package]]
 name = "vhost-user-backend"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a0fc7d5f8e2943cd9f2ecd58be3f2078add863a49573d14dd9d64e1ab26544c"
+checksum = "9f237b91db4ac339d639fb43398b52d785fa51e3c7760ac9425148863c1f4303"
 dependencies = [
 "libc",
 "log",
@@ -1426,9 +1459,9 @@ dependencies = [

 [[package]]
 name = "virtio-queue"
-version = "0.6.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "435dd49c7b38419729afd43675850c7b5dc4728f2fabd70c7a9079a331e4f8c6"
+checksum = "19e927d93d54c365034fd7f31a5f458a1f540de4a37c52e892670dad9692173c"
 dependencies = [
 "log",
 "virtio-bindings",
@@ -1461,13 +1494,13 @@ dependencies = [
 [[package]]
 name = "vm-fdt"
 version = "0.2.0"
-source = "git+https://github.com/rust-vmm/vm-fdt?branch=main#8a19dcc94a4fb0044ff6e879e069901e0a74a943"
+source = "git+https://github.com/rust-vmm/vm-fdt?branch=main#c5a99ab71b130435927d19b50c85fcd5ce904a8c"

 [[package]]
 name = "vm-memory"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "583f213899e8a5eea23d9c507252d4bed5bc88f0ecbe0783262f80034630744b"
+checksum = "688a70366615b45575a424d9c665561c1b5ab2224d494f706b6a6812911a827c"
 dependencies = [
 "arc-swap",
 "libc",
@@ -1547,9 +1580,9 @@ dependencies = [

 [[package]]
 name = "vmm-sys-util"
-version = "0.10.0"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08604d7be03eb26e33b3cee3ed4aef2bf550b305d1cca60e84da5d28d3790b62"
+checksum = "cc06a16ee8ebf0d9269aed304030b0d20a866b8b3dd3d4ce532596ac567a0d24"
 dependencies = [
 "bitflags",
 "libc",
@@ -1605,46 +1638,60 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

 [[package]]
 name = "windows-sys"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
+checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
 dependencies = [
+ "windows_aarch64_gnullvm",
 "windows_aarch64_msvc",
 "windows_i686_gnu",
 "windows_i686_msvc",
 "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
 "windows_x86_64_msvc",
 ]

 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.36.1"
+name = "windows_aarch64_gnullvm"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
+checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4"

 [[package]]
 name = "windows_i686_gnu"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
+checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7"

 [[package]]
 name = "windows_i686_msvc"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
+checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246"

 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
+checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028"

 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
+checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5"

 [[package]]
 name = "zerocopy"
@@ -1658,11 +1705,11 @@ dependencies = [

 [[package]]
 name = "zerocopy-derive"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0fbc82b82efe24da867ee52e015e58178684bd9dd64c34e66bdf21da2582a9f"
+checksum = "6505e6815af7de1746a08f69c69606bb45695a17149517680f3b2149713b19a3"
 dependencies = [
 "proc-macro2",
+ "quote",
 "syn",
- "synstructure",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cloud-hypervisor"
-version = "27.0.0"
+version = "29.0.0"
 authors = ["The Cloud Hypervisor Authors"]
 edition = "2021"
 default-run = "cloud-hypervisor"
@@ -10,46 +10,49 @@ description = "Open source Virtual Machine Monitor (VMM) that runs on top of KVM
 homepage = "https://github.com/cloud-hypervisor/cloud-hypervisor"
 # Minimum buildable version:
 # Keep in sync with version in .github/workflows/build.yaml
+# Policy on MSRV (see #4318):
+# Can only be bumped by:
+# 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.60"

 [profile.release]
 lto = true
 codegen-units = 1
 opt-level = "s"
+strip = true

 [dependencies]
-anyhow = "1.0.65"
+anyhow = "1.0.68"
 api_client = { path = "api_client" }
-clap = { version = "3.2.22", features = ["wrap_help","cargo"] }
+clap = { version = "4.0.32", features = ["wrap_help","cargo","string"] }
 epoll = "4.3.1"
 event_monitor = { path = "event_monitor" }
 hypervisor = { path = "hypervisor" }
-libc = "0.2.133"
+libc = "0.2.139"
 log = { version = "0.4.17", features = ["std"] }
 option_parser = { path = "option_parser" }
 seccompiler = "0.3.0"
-serde_json = "1.0.85"
+serde_json = "1.0.89"
 signal-hook = "0.3.14"
-thiserror = "1.0.37"
+thiserror = "1.0.38"
+tpm = { path = "tpm"}
 tracer = { path = "tracer" }
 vmm = { path = "vmm" }
-vmm-sys-util = "0.10.0"
-vm-memory = "0.9.0"
-
-[build-dependencies]
-clap = { version = "3.2.22", features = ["cargo"] }
+vmm-sys-util = "0.11.0"
+vm-memory = "0.10.0"

 # List of patched crates
 [patch.crates-io]
-kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.5.0-tdx" }
-kvm-ioctls = { git = "https://github.com/rust-vmm/kvm-ioctls", branch = "main" }
+kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.6.0-tdx" }
 versionize_derive = { git = "https://github.com/cloud-hypervisor/versionize_derive", branch = "ch" }

 [dev-dependencies]
 dirs = "4.0.0"
 net_util = { path = "net_util" }
-once_cell = "1.15.0"
-serde_json = "1.0.85"
+once_cell = "1.16.0"
+serde_json = "1.0.89"
 test_infra = { path = "test_infra" }
 wait-timeout = "0.2.0"

--- a/761
+++ b/761
@@ -1,352 +1,449 @@
 def runWorkers = true
-pipeline{
-	agent none
-	stages {
-		stage ('Early checks') {
-			agent { node { label 'built-in' } }
-			stages {
-				stage ('Checkout') {
-					steps {
-						checkout scm
-					}
-				}
-				stage ('Check for documentation only changes') {
-					when {
-						expression {
-							return docsFileOnly()
-						}
-					}
-					steps {
-						script {
-							runWorkers = false
-							echo "Documentation only changes, no need to run the CI"
-						}
-					}
-				}
-				stage ('Check for fuzzer files only changes') {
-					when {
-						expression {
-							return fuzzFileOnly()
-						}
-					}
-					steps {
-						script {
-							runWorkers = false
-							echo "Fuzzer cargo files only changes, no need to run the CI"
-						}
-					}
-				}
-				stage ('Check for RFC/WIP builds') {
-					when {
-  						changeRequest comparator: 'REGEXP', title: '.*(rfc|RFC|wip|WIP).*'
-  						beforeAgent true
-					}
-					steps {
-						error("Failing as this is marked as a WIP or RFC PR.")
-					}
-				}
-				stage ('Cancel older builds') {
-					when { not { branch 'main' } }
-					steps {
-						cancelPreviousBuilds()
-					}
-				}
-			}
-		}
-		stage ('Build') {
-			parallel {
-				stage ('Worker build') {
-					agent { node { label 'jammy' } }
-					when {
-						beforeAgent true
-						expression {
-							return runWorkers
-						}
-					}
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-						stage ('Prepare environment') {
-							steps {
-								sh "scripts/prepare_vdpa.sh"
-							}
-						}
-						stage ('Run OpenAPI tests') {
-							steps {
-								sh "scripts/run_openapi_tests.sh"
-							}
-						}
-						stage ('Run unit tests') {
-							steps {
-								sh "scripts/dev_cli.sh tests --unit"
-							}
-						}
-						stage ('Run integration tests') {
-							options {
-								timeout(time: 1, unit: 'HOURS')
-							}
-							steps {
-								sh "sudo modprobe openvswitch"
-								sh "scripts/dev_cli.sh tests --integration"
-							}
-						}
-					}
-				}
-				stage ('AArch64 worker build') {
-					agent { node { label 'bionic-arm64' } }
-					when {
-						beforeAgent true
-						expression {
-							return runWorkers
-						}
-					}
-					environment {
-        					AZURE_CONNECTION_STRING = credentials('46b4e7d6-315f-4cc1-8333-b58780863b9b')
-					}
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-						stage ('Run unit tests') {
-							steps {
-								sh "scripts/dev_cli.sh tests --unit --libc musl"
-							}
-						}
-						stage ('Run integration tests') {
-							options {
-								timeout(time: 1, unit: 'HOURS')
-							}
-							steps {
-								sh "sudo modprobe openvswitch"
-								sh "scripts/dev_cli.sh tests --integration --libc musl"
-							}
-						}
-						stage ('Install azure-cli') {
-							steps {
-								installAzureCli("bionic", "arm64")
-							}
-						}
-						stage ('Download Windows image') {
-							steps {
-								sh '''#!/bin/bash -x
-									IMG_BASENAME=windows-11-iot-enterprise-aarch64.raw
-									IMG_PATH=$HOME/workloads/$IMG_BASENAME
-									IMG_GZ_PATH=$HOME/workloads/$IMG_BASENAME.gz
-									IMG_GZ_BLOB_NAME=windows-11-iot-enterprise-aarch64-9-min.raw.gz
-									cp "scripts/$IMG_BASENAME.sha1" "$HOME/workloads/"
-									pushd "$HOME/workloads"
-									if sha1sum "$IMG_BASENAME.sha1" --check; then
-										exit
-									fi
-									popd
-									mkdir -p "$HOME/workloads"
-									az storage blob download \
-										--container-name private-images \
-										--file "$IMG_GZ_PATH" \
-										--name "$IMG_GZ_BLOB_NAME" \
-										--connection-string "$AZURE_CONNECTION_STRING"
-									gzip -d $IMG_GZ_PATH
-								'''
-							}
-						}
-						stage ('Run Windows guest integration tests') {
-							options {
-								timeout(time: 1, unit: 'HOURS')
-							}
-							steps {
-								sh "scripts/dev_cli.sh tests --integration-windows --libc musl"
-							}
-						}
-					}
-					post {
-						always {
-							sh "sudo chown -R jenkins.jenkins ${WORKSPACE}"
-							deleteDir()
-						}
-					}
-				}
-				stage ('Worker build (musl)') {
-					agent { node { label 'jammy' } }
-					when {
-						beforeAgent true
-						expression {
-							return runWorkers
-						}
-					}
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-						stage ('Prepare environment') {
-							steps {
-								sh "scripts/prepare_vdpa.sh"
-							}
-						}
-						stage ('Run unit tests for musl') {
-							steps {
-								sh "scripts/dev_cli.sh tests --unit --libc musl"
-							}
-						}
-						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"
-							}
-						}
-					}
-				}
-				stage ('Worker build - Windows guest') {
-					agent { node { label 'jammy' } }
-					when {
-						beforeAgent true
-						expression {
-							return runWorkers
-						}
-					}
-					environment {
-        					AZURE_CONNECTION_STRING = credentials('46b4e7d6-315f-4cc1-8333-b58780863b9b')
-					}
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-						stage ('Install azure-cli') {
-							steps {
-								installAzureCli("jammy", "amd64")
-							}
-						}
-						stage ('Download assets') {
-							steps {
-								sh "mkdir ${env.HOME}/workloads"
-								sh 'az storage blob download --container-name private-images --file "$HOME/workloads/windows-server-2019.raw" --name windows-server-2019.raw --connection-string "$AZURE_CONNECTION_STRING"'
-							}
-						}
-						stage ('Run Windows guest integration tests') {
-							options {
-								timeout(time: 1, unit: 'HOURS')
-							}
-							steps {
-								sh "scripts/dev_cli.sh tests --integration-windows"
-							}
-						}
-						stage ('Run Windows guest integration tests for musl') {
-							options {
-								timeout(time: 1, unit: 'HOURS')
-							}
-							steps {
-								sh "scripts/dev_cli.sh tests --integration-windows --libc musl"
-							}
-						}
-					}
-				}
-				stage ('Worker build - Live Migration') {
-					agent { node { label 'jammy' } }
-					when {
-						beforeAgent true
-						expression {
-							return runWorkers
-						}
-					}
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-						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 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"
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	post {
-		regression {
-			script {
-				if (env.BRANCH_NAME == 'main') {
-					slackSend (color: '#ff0000', message: '"main" branch build is now failing', channel: '#jenkins-ci')
-				}
-			}
-		}
-		fixed {
-			script {
-				if (env.BRANCH_NAME == 'main') {
-					slackSend (color: '#00ff00', message: '"main" branch build is now fixed', channel: '#jenkins-ci')
-				}
-			}
-		}
-	}
+pipeline {
+    agent none
+    stages {
+        stage('Early checks') {
+            agent { node { label 'built-in' } }
+            stages {
+                stage('Checkout') {
+                    steps {
+                        checkout scm
+                    }
+                }
+                stage('Check if worker build can be skipped') {
+                    when {
+                        expression {
+                            return skipWorkerBuild()
+                        }
+                    }
+                    steps {
+                        script {
+                            runWorkers = false
+                            echo 'No changes requring a build'
+                        }
+                    }
+                }
+                stage('Check for RFC/WIP builds') {
+                    when {
+                        changeRequest comparator: 'REGEXP', title: '.*(rfc|RFC|wip|WIP).*'
+                        beforeAgent true
+                    }
+                    steps {
+                        error('Failing as this is marked as a WIP or RFC PR.')
+                    }
+                }
+                stage('Cancel older builds') {
+                    when { not { branch 'main' } }
+                    steps {
+                        cancelPreviousBuilds()
+                    }
+                }
+            }
+        }
+        stage('Build') {
+            parallel {
+                stage('Worker build') {
+                    agent { node { label 'jammy' } }
+                    when {
+                        beforeAgent true
+                        expression {
+                            return runWorkers
+                        }
+                    }
+                    stages {
+                        stage('Checkout') {
+                            steps {
+                                checkout scm
+                            }
+                        }
+                        stage('Prepare environment') {
+                            steps {
+                                sh 'scripts/prepare_vdpa.sh'
+                            }
+                        }
+                        stage('Run OpenAPI tests') {
+                            steps {
+                                sh 'scripts/run_openapi_tests.sh'
+                            }
+                        }
+                        stage('Run unit tests') {
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --unit'
+                            }
+                        }
+                        stage('Run integration tests') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'sudo modprobe openvswitch'
+                                sh 'scripts/dev_cli.sh tests --integration'
+                            }
+                        }
+                        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 unit tests for musl') {
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --unit --libc musl'
+                            }
+                        }
+                        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'
+                            }
+                        }
+                        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 {
+                        beforeAgent true
+                        expression {
+                            return runWorkers
+                        }
+                    }
+                    environment {
+                            AZURE_CONNECTION_STRING = credentials('46b4e7d6-315f-4cc1-8333-b58780863b9b')
+                    }
+                    stages {
+                        stage('Checkout') {
+                            steps {
+                                checkout scm
+                            }
+                        }
+                        stage('Run unit tests') {
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --unit --libc musl'
+                            }
+                        }
+                        stage('Run integration tests') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'sudo modprobe openvswitch'
+                                sh 'scripts/dev_cli.sh tests --integration --libc musl'
+                            }
+                        }
+                        stage('Install azure-cli') {
+                            steps {
+                                installAzureCli('bionic', 'arm64')
+                            }
+                        }
+                        stage('Download Windows image') {
+                            steps {
+                                sh '''#!/bin/bash -x
+                                    IMG_BASENAME=windows-11-iot-enterprise-aarch64.raw
+                                    IMG_PATH=$HOME/workloads/$IMG_BASENAME
+                                    IMG_GZ_PATH=$HOME/workloads/$IMG_BASENAME.gz
+                                    IMG_GZ_BLOB_NAME=windows-11-iot-enterprise-aarch64-9-min.raw.gz
+                                    cp "scripts/$IMG_BASENAME.sha1" "$HOME/workloads/"
+                                    pushd "$HOME/workloads"
+                                    if sha1sum "$IMG_BASENAME.sha1" --check; then
+                                        exit
+                                    fi
+                                    popd
+                                    mkdir -p "$HOME/workloads"
+                                    az storage blob download \
+                                        --container-name private-images \
+                                        --file "$IMG_GZ_PATH" \
+                                        --name "$IMG_GZ_BLOB_NAME" \
+                                        --connection-string "$AZURE_CONNECTION_STRING"
+                                    gzip -d $IMG_GZ_PATH
+                                '''
+                            }
+                        }
+                        stage('Run Windows guest integration tests') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --integration-windows --libc musl'
+                            }
+                        }
+                    }
+                    post {
+                        always {
+                            sh "sudo chown -R jenkins.jenkins ${WORKSPACE}"
+                            deleteDir()
+                        }
+                    }
+                }
+                stage('Worker build - Windows guest') {
+                    agent { node { label 'jammy' } }
+                    when {
+                        beforeAgent true
+                        expression {
+                            return runWorkers
+                        }
+                    }
+                    environment {
+                            AZURE_CONNECTION_STRING = credentials('46b4e7d6-315f-4cc1-8333-b58780863b9b')
+                    }
+                    stages {
+                        stage('Checkout') {
+                            steps {
+                                checkout scm
+                            }
+                        }
+                        stage('Install azure-cli') {
+                            steps {
+                                installAzureCli('jammy', 'amd64')
+                            }
+                        }
+                        stage('Download assets') {
+                            steps {
+                                sh "mkdir ${env.HOME}/workloads"
+                                sh 'az storage blob download --container-name private-images --file "$HOME/workloads/windows-server-2019.raw" --name windows-server-2019.raw --connection-string "$AZURE_CONNECTION_STRING"'
+                            }
+                        }
+                        stage('Run Windows guest integration tests') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --integration-windows'
+                            }
+                        }
+                        stage('Run Windows guest integration tests for musl') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --integration-windows --libc musl'
+                            }
+                        }
+                    }
+                }
+                stage('Worker build - Metrics') {
+                    agent { node { label 'jammy-metrics' } }
+                    when {
+                        branch 'main'
+                        beforeAgent true
+                        expression {
+                            return runWorkers
+                        }
+                    }
+                    environment {
+                        METRICS_PUBLISH_KEY = credentials('52e0945f-ce7a-43d1-87af-67d1d87cc40f')
+                    }
+                    stages {
+                        stage('Checkout') {
+                            steps {
+                                checkout scm
+                            }
+                        }
+                        stage('Run metrics tests') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --metrics -- -- --report-file /root/workloads/metrics.json'
+                            }
+                        }
+                        stage('Upload metrics report') {
+                            steps {
+                                sh 'curl -X PUT https://cloud-hypervisor-metrics.azurewebsites.net/api/publishmetrics -H "x-functions-key: $METRICS_PUBLISH_KEY" -T ~/workloads/metrics.json'
+                            }
+                        }
+                    }
+                }
+                stage('Worker build - Rate Limiter') {
+                    agent { node { label 'focal-metrics' } }
+                    when {
+                        branch 'main'
+                        beforeAgent true
+                        expression {
+                            return runWorkers
+                        }
+                    }
+                    stages {
+                        stage('Checkout') {
+                            steps {
+                                checkout scm
+                            }
+                        }
+                        stage('Run rate-limiter integration tests') {
+                            options {
+                                timeout(time: 10, unit: 'MINUTES')
+                            }
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --integration-rate-limiter'
+                            }
+                        }
+                    }
+                }
+                stage('Worker build - SGX') {
+                    agent { node { label 'jammy-sgx' } }
+                    when {
+                        beforeAgent true
+                        allOf {
+                            branch 'main'
+                            expression {
+                                return runWorkers
+                            }
+                        }
+                    }
+                    stages {
+                        stage('Checkout') {
+                            steps {
+                                checkout scm
+                            }
+                        }
+                        stage('Run SGX integration tests') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --integration-sgx'
+                            }
+                        }
+                        stage('Run SGX integration tests for musl') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --integration-sgx --libc musl'
+                            }
+                        }
+                    }
+                    post {
+                        always {
+                            sh "sudo chown -R jenkins.jenkins ${WORKSPACE}"
+                            deleteDir()
+                        }
+                    }
+                }
+                stage('Worker build - VFIO') {
+                    agent { node { label 'jammy-vfio' } }
+                    when {
+                        beforeAgent true
+                        allOf {
+                            branch 'main'
+                            expression {
+                                return runWorkers
+                            }
+                        }
+                    }
+                    stages {
+                        stage('Checkout') {
+                            steps {
+                                checkout scm
+                            }
+                        }
+                        stage('Run VFIO integration tests') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --integration-vfio'
+                            }
+                        }
+                        stage('Run VFIO integration tests for musl') {
+                            options {
+                                timeout(time: 1, unit: 'HOURS')
+                            }
+                            steps {
+                                sh 'scripts/dev_cli.sh tests --integration-vfio --libc musl'
+                            }
+                        }
+                    }
+                    post {
+                        always {
+                            sh "sudo chown -R jenkins.jenkins ${WORKSPACE}"
+                            deleteDir()
+                        }
+                    }
+                }
+            }
+        }
+    }
+    post {
+        regression {
+            script {
+                if (env.BRANCH_NAME == 'main') {
+                    slackSend(color: '#ff0000', message: '"main" branch build is now failing', channel: '#jenkins-ci')
+                }
+            }
+        }
+        fixed {
+            script {
+                if (env.BRANCH_NAME == 'main') {
+                    slackSend(color: '#00ff00', message: '"main" branch build is now fixed', channel: '#jenkins-ci')
+                }
+            }
+        }
+    }
 }

 def cancelPreviousBuilds() {
-	// Check for other instances of this particular build, cancel any that are older than the current one
-	def jobName = env.JOB_NAME
-		def currentBuildNumber = env.BUILD_NUMBER.toInteger()
-		def currentJob = Jenkins.instance.getItemByFullName(jobName)
+    // Check for other instances of this particular build, cancel any that are older than the current one
+    def jobName = env.JOB_NAME
+    def currentBuildNumber = env.BUILD_NUMBER.toInteger()
+    def currentJob = Jenkins.instance.getItemByFullName(jobName)

-		// Loop through all instances of this particular job/branch
-		for (def build : currentJob.builds) {
-			if (build.isBuilding() && (build.number.toInteger() < currentBuildNumber)) {
-				echo "Older build still queued. Sending kill signal to build number: ${build.number}"
-				build.doStop()
-			}
-		}
+    // Loop through all instances of this particular job/branch
+    for (def build : currentJob.builds) {
+        if (build.isBuilding() && (build.number.toInteger() < currentBuildNumber)) {
+            echo "Older build still queued. Sending kill signal to build number: ${build.number}"
+            build.doStop()
+        }
+    }
 }

 def installAzureCli(distro, arch) {
-	sh "sudo apt install -y ca-certificates curl apt-transport-https lsb-release gnupg"
-	sh "curl -sL https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/microsoft.gpg > /dev/null"
-	sh "echo \"deb [arch=${arch}] https://packages.microsoft.com/repos/azure-cli/ ${distro} main\" | sudo tee /etc/apt/sources.list.d/azure-cli.list"
-	sh "sudo apt update"
-	sh "sudo apt install -y azure-cli"
+    sh 'sudo apt install -y ca-certificates curl apt-transport-https lsb-release gnupg'
+    sh 'curl -sL https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/microsoft.gpg > /dev/null'
+    sh "echo \"deb [arch=${arch}] https://packages.microsoft.com/repos/azure-cli/ ${distro} main\" | sudo tee /etc/apt/sources.list.d/azure-cli.list"
+    sh 'sudo apt update'
+    sh 'sudo apt install -y azure-cli'
 }

-def boolean docsFileOnly() {
+def boolean skipWorkerBuild() {
    if (env.CHANGE_TARGET == null) {
-        return false;
+        return false
    }

-    return sh(
+    if (sh(
        returnStatus: true,
        script: "git diff --name-only origin/${env.CHANGE_TARGET}... | grep -v '\\.md'"
-    ) != 0
-}
-
-def boolean fuzzFileOnly() {
-    if (env.CHANGE_TARGET == null) {
-        return false;
+    ) != 0) {
+        return true
    }

-    return sh(
+    if (sh(
        returnStatus: true,
        script: "git diff --name-only origin/${env.CHANGE_TARGET}... | grep -v -E 'fuzz/'"
-    ) != 0
+    ) != 0) {
+        return true
+    }
+
+    if (sh(
+        returnStatus: true,
+        script: "git diff --name-only origin/${env.CHANGE_TARGET}... | grep -v -E '.github/'"
+    ) != 0) {
+        return true
+    }
+
+    return false
 }
--- a/README.md
+++ b/README.md
@@ -5,24 +5,21 @@
    - [Guest OS](#guest-os)
 - [2. Getting Started](#2-getting-started)
  - [Host OS](#host-os)
-  - [Preparation](#preparation)
-  - [Install prerequisites](#install-prerequisites)
-  - [Clone and build](#clone-and-build)
-    - [Containerized builds and tests](#containerized-builds-and-tests)
-  - [Use Prebuilt Binaries](#use-prebuilt-binaries)
-  - [Run](#run)
-    - [Cloud image](#cloud-image)
-    - [Custom kernel and disk image](#custom-kernel-and-disk-image)
-      - [Building your kernel](#building-your-kernel)
+  - [Use Pre-built Binaries](#use-pre-built-binaries)
+  - [Packages](#packages)
+  - [Building from Source](#building-from-source)
+  - [Booting Linux](#booting-linux)
+    - [Firmware Booting](#firmware-booting)
+    - [Custom Kernel and Disk Image](#custom-kernel-and-disk-image)
+      - [Building your Kernel](#building-your-kernel)
      - [Disk image](#disk-image)
      - [Booting the guest VM](#booting-the-guest-vm)
 - [3. Status](#3-status)
  - [Hot Plug](#hot-plug)
  - [Device Model](#device-model)
-  - [TODO](#todo)
  - [Roadmap](#roadmap)
- [4. `rust-vmm` project dependency](#4-rust-vmm-project-dependency)
-  - [Firecracker and crosvm](#firecracker-and-crosvm)
+- [4. Relationship with _Rust VMM_ Project](#4-relationship-with-rust-vmm-project)
+  - [Differences with Firecracker and crosvm](#differences-with-firecracker-and-crosvm)
 - [5. Community](#5-community)
  - [Contribute](#contribute)
  - [Slack](#slack)
@@ -32,18 +29,18 @@
 # 1. What is Cloud Hypervisor?

 Cloud Hypervisor is an open source Virtual Machine Monitor (VMM) that runs on
-top of [KVM](https://www.kernel.org/doc/Documentation/virtual/kvm/api.txt)
-hypervisor and Microsoft Hypervisor (MSHV).
+top of the [KVM](https://www.kernel.org/doc/Documentation/virtual/kvm/api.txt)
+hypervisor and the Microsoft Hypervisor (MSHV).

-The project focuses on exclusively running modern, cloud workloads, on top of
-a limited set of hardware architectures and platforms. Cloud workloads refers
-to those that are usually run by customers inside a cloud provider. For our
-purposes this means modern operating systems with most I/O handled by
-paravirtualised devices (i.e. virtio), no requirement for legacy devices, and
+The project focuses on running modern, _Cloud Workloads_, on specific, common,
+hardware architectures. In this case _Cloud Workloads_ refers to those that are
+run by customers inside a Cloud Service Provider. This means modern operating
+systems with most I/O handled by
+paravirtualised devices (e.g. _virtio_), no requirement for legacy devices, and
 64-bit CPUs.

 Cloud Hypervisor is implemented in [Rust](https://www.rust-lang.org/) and is
-based on the [rust-vmm](https://github.com/rust-vmm) crates.
+based on the [Rust VMM](https://github.com/rust-vmm) crates.

 ## Objectives

@@ -63,7 +60,7 @@ based on the [rust-vmm](https://github.com/rust-vmm) crates.
 ### Architectures

 Cloud Hypervisor supports the `x86-64` and `AArch64` architectures. There are
-some small differences in functionality between the two architectures
+minor differences in functionality between the two architectures
 (see [#1125](https://github.com/cloud-hypervisor/cloud-hypervisor/issues/1125)).

 ### Guest OS
@@ -72,202 +69,186 @@ Cloud Hypervisor supports `64-bit Linux` and Windows 10/Windows Server 2019.

 # 2. Getting Started

-Below sections describe how to build and run Cloud Hypervisor on the `x86_64`
-platform. For getting started on the `AArch64` platform, please refer to the
-[Arm64 documentation](docs/arm64.md).
+The following sections describe how to build and run Cloud Hypervisor.
+
+## Prerequisites for AArch64
+
+- AArch64 servers (recommended) or development boards equipped with the GICv3
+  interrupt controller.

 ## Host OS

-Based on required KVM functionality the minimum host kernel version is 4.11.
-For adequate peformance the minimum recommended host kernel vesion is 5.6. The
+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.

-## Preparation
+## Use Pre-built Binaries

-We create a folder to build and run `cloud-hypervisor` at `$HOME/cloud-hypervisor`
+The recommended approach to getting started with Cloud Hypervisor is by using a
+pre-built binary. Binaries are available for the [latest
+release](https://github.com/cloud-hypervisor/cloud-hypervisor/releases/latest).
+Use `cloud-hypervisor-static` for `x86-64` or `cloud-hypervisor-static-aarch64`
+for `AArch64` platform.

-```shell
-$ export CLOUDH=$HOME/cloud-hypervisor
-$ mkdir $CLOUDH
-```
+## Packages

-## Install prerequisites
-
-You need to install some prerequisite packages in order to build and test Cloud
-Hypervisor. Here, all the steps are based on Ubuntu, for other Linux
-distributions please replace the package manager and package name.
-
-```shell
-# Install build-essential, git, and qemu-utils
-$ sudo apt install git build-essential qemu-utils
-# Install rust tool chain
-$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-# If you want to build statically linked binary please add musl target
-$ rustup target add x86_64-unknown-linux-musl
-```
-
-## Clone and build
-
-First you need to clone and build the cloud-hypervisor repo:
-
-```shell
-$ pushd $CLOUDH
-$ git clone https://github.com/cloud-hypervisor/cloud-hypervisor.git
-$ cd cloud-hypervisor
-$ cargo build --release
-
-# We need to give the cloud-hypervisor binary the NET_ADMIN capabilities for it to set TAP interfaces up on the host.
-$ sudo setcap cap_net_admin+ep ./target/release/cloud-hypervisor
-
-# If you want to build statically linked binary
-$ cargo build --release --target=x86_64-unknown-linux-musl --all
-$ popd
-```
-
-This will build a `cloud-hypervisor` binary under
-`$CLOUDH/cloud-hypervisor/target/release/cloud-hypervisor`.
-
-### Containerized builds and tests
-
-If you want to build and test Cloud Hypervisor without having to install all the
-required dependencies (The rust toolchain, cargo tools, etc), you can also use
-Cloud Hypervisor's development script: `dev_cli.sh`. Please note that upon its
-first invocation, this script will pull a fairly large container image.
-
-For example, to build the Cloud Hypervisor release binary:
-
-```shell
-$ pushd $CLOUDH
-$ cd cloud-hypervisor
-$ ./scripts/dev_cli.sh build --release
-```
-
-With `dev_cli.sh`, one can also run the Cloud Hypervisor CI locally. This can be
-very convenient for debugging CI errors without having to fully rely on the
-Cloud Hypervisor CI infrastructure.
-
-For example, to run the Cloud Hypervisor unit tests:
-
-```shell
-$ ./scripts/dev_cli.sh tests --unit
-```
-
-Run the `./scripts/dev_cli.sh --help` command to view all the supported
-development script commands and their related options.
-
-## Use Prebuilt Binaries
-
-Cloud Hypervisor packages targeting some popular Linux distributions are available
-thanks to the [Open Build Service](https://build.opensuse.org). The
-[OBS README](https://github.com/cloud-hypervisor/obs-packaging) explains how to
+For convenience, packages are also available targeting some popular Linux
+distributions. This is thanks to the [Open Build
+Service](https://build.opensuse.org). The [OBS
+README](https://github.com/cloud-hypervisor/obs-packaging) explains how to
 enable the repository in a supported Linux distribution and install Cloud Hypervisor
 and accompanying packages. Please report any packaging issues in the
 [obs-packaging](https://github.com/cloud-hypervisor/obs-packaging) repository.

-## Run
+## Building from Source

-You can run a guest VM by either using an existing cloud image or booting into
-your own kernel and disk image.
+Please see the [instructions for building from source](docs/building.md) if you
+do not wish to use the pre-built binaries.

-### Cloud image
+## Booting Linux

-Cloud Hypervisor supports booting disk images containing all needed
-components to run cloud workloads, a.k.a. cloud images. To do that we rely on
-the [Rust Hypervisor
-Firmware](https://github.com/cloud-hypervisor/rust-hypervisor-firmware) project
-to provide an ELF formatted KVM firmware for `cloud-hypervisor` to directly
-boot into.
+Cloud Hypervisor supports direct kernel boot (the x86-64 kernel requires the kernel
+built with PVH support) or booting via a firmware (either [Rust Hypervisor
+Firmware](https://github.com/cloud-hypervisor/rust-hypervisor-firmware) or an
+edk2 UEFI firmware called `CLOUDHV` / `CLOUDHV_EFI`.)

-We need to get the latest `rust-hypervisor-firmware` release and also a working
-cloud image. Here we will use a Ubuntu image:
+Binary builds of the firmware files are available for the latest release of
+[Rust Hyperivor
+Firmware](https://github.com/cloud-hypervisor/rust-hypervisor-firmware/releases/latest)
+and [our edk2
+repository](https://github.com/cloud-hypervisor/edk2/releases/latest)
+
+The choice of firmware depends on your guest OS choice; some experimentation
+may be required.
+
+### Firmware Booting
+
+Cloud Hypervisor supports booting disk images containing all needed components
+to run cloud workloads, a.k.a. cloud images. 
+
+The following sample commands will download an Ubuntu Cloud image, converting
+it into a format that Cloud Hypervisor can use and a firmware to boot the image
+with.

 ```shell
-$ pushd $CLOUDH
 $ wget https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-amd64.img
 $ qemu-img convert -p -f qcow2 -O raw focal-server-cloudimg-amd64.img focal-server-cloudimg-amd64.raw
-$ wget https://github.com/cloud-hypervisor/rust-hypervisor-firmware/releases/download/0.4.1/hypervisor-fw
-$ popd
+$ wget https://github.com/cloud-hypervisor/rust-hypervisor-firmware/releases/download/0.4.2/hypervisor-fw
 ```

+The Ubuntu cloud images do not ship with a default password so it necessary to
+use a `cloud-init` disk image to customise the image on the first boot. A basic
+`cloud-init` image is generated by this [script](scripts/create-cloud-init.sh).
+This seeds the image with a default username/password of `cloud/cloud123`. It
+is only necessary to add this disk image on the first boot.
+
 ```shell
-$ pushd $CLOUDH
-$ sudo setcap cap_net_admin+ep ./cloud-hypervisor/target/release/cloud-hypervisor
-$ ./cloud-hypervisor/target/release/cloud-hypervisor \
+$ 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=focal-server-cloudimg-amd64.raw path=/tmp/ubuntu-cloudinit.img \
 	--cpus boot=4 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask="
-$ popd
 ```

-Multiple arguments can be given to the `--disk` parameter.
+If access to the firmware messages or interaction with the boot loader (e.g.
+GRUB) is required then it necessary to switch to the serial console instead of
+`virtio-console`.

-### Custom kernel and disk image
+```shell
+$ ./cloud-hypervisor \
+	--kernel ./hypervisor-fw \
+	--disk path=focal-server-cloudimg-amd64.raw path=/tmp/ubuntu-cloudinit.img \
+	--cpus boot=4 \
+	--memory size=1024M \
+	--net "tap=,mac=,ip=,mask=" \
+	--serial tty \
+	--console off
+```

-#### Building your kernel
+### Custom Kernel and Disk Image

-Cloud Hypervisor also supports direct kernel boot into a `vmlinux` ELF kernel.
-In order to support virtio-watchdog we have our own development branch. You are
-of course able to use your own kernel but these instructions will continue with
-the version that we develop and test against.
+#### Building your Kernel
+
+Cloud Hypervisor also supports direct kernel boot. For x86-64, a `vmlinux` ELF kernel (compiled with PVH support) is needed. In order to support development there is a custom branch; however provided the required options are enabled any recent kernel will suffice.

 To build the kernel:

 ```shell
-
 # Clone the Cloud Hypervisor Linux branch
-$ pushd $CLOUDH
 $ git clone --depth 1 https://github.com/cloud-hypervisor/linux.git -b ch-5.15.12 linux-cloud-hypervisor
 $ pushd linux-cloud-hypervisor
-
-# Use the cloud-hypervisor kernel config to build your kernel
-$ cp $CLOUDH/cloud-hypervisor/resources/linux-config-x86_64 .config
+# Use the x86-64 cloud-hypervisor kernel config to build your kernel for x86-64
+$ wget https://raw.githubusercontent.com/cloud-hypervisor/cloud-hypervisor/main/resources/linux-config-x86_64
+# Use the AArch64 cloud-hypervisor kernel config to build your kernel for AArch64
+$ wget https://raw.githubusercontent.com/cloud-hypervisor/cloud-hypervisor/main/resources/linux-config-aarch64
+$ cp linux-config-x86_64 .config  # x86-64
+$ cp linux-config-aarch64 .config # AArch64
+# Do native build of the x86-64 kernel
 $ KCFLAGS="-Wa,-mx86-used-note=no" make bzImage -j `nproc`
+# Do native build of the AArch64 kernel
+$ make -j `nproc`
 $ popd
 ```

-The `vmlinux` kernel image will then be located at
+For x86-64, the `vmlinux` kernel image will then be located at
 `linux-cloud-hypervisor/arch/x86/boot/compressed/vmlinux.bin`.
+For AArch64, the `Image` kernel image will then be located at
+`linux-cloud-hypervisor/arch/arm64/boot/Image`.

 #### Disk image

-For the disk image, we will use a Ubuntu cloud image that contains a root
-partition:
+For the disk image the same Ubuntu image as before can be used. This contains
+an `ext4` root filesystem.

 ```shell
-$ pushd $CLOUDH
-$ wget https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-amd64.img
-$ qemu-img convert -p -f qcow2 -O raw focal-server-cloudimg-amd64.img focal-server-cloudimg-amd64.raw
-$ popd
+$ wget https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-amd64.img # x86-64
+$ wget https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-arm64.img # AArch64
+$ qemu-img convert -p -f qcow2 -O raw focal-server-cloudimg-amd64.img focal-server-cloudimg-amd64.raw # x86-64
+$ qemu-img convert -p -f qcow2 -O raw focal-server-cloudimg-arm64.img focal-server-cloudimg-arm64.raw # AArch64
 ```

 #### Booting the guest VM

-Now we can directly boot into our custom kernel and make it use the Ubuntu root
-partition. If we want to have 4 vCPUs and 1024 MBytes of memory:
+These sample commands boot the disk image using the custom kernel whilst also
+supplying the desired kernel command line.
+
+- x86-64

 ```shell
-$ pushd $CLOUDH
-$ sudo setcap cap_net_admin+ep ./cloud-hypervisor/target/release/cloud-hypervisor
-$ ./cloud-hypervisor/target/release/cloud-hypervisor \
+$ 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=focal-server-cloudimg-amd64.raw path=/tmp/ubuntu-cloudinit.img \
 	--cmdline "console=hvc0 root=/dev/vda1 rw" \
 	--cpus boot=4 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask="
 ```

-The above example use the `virtio-console` device as the guest console, and this
-device may not be enabled soon enough by the guest kernel to get early kernel
-debug messages.
-
-When in need for earlier debug messages, using the legacy serial device based
-console is preferred:
+- AArch64

+```shell
+$ 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 path=/tmp/ubuntu-cloudinit.img \
+	--cmdline "console=hvc0 root=/dev/vda1 rw" \
+	--cpus boot=4 \
+	--memory size=1024M \
+	--net "tap=,mac=,ip=,mask="
 ```
-$ ./cloud-hypervisor/target/release/cloud-hypervisor \
+
+If earlier kernel messages are required the serial console should be used instead of `virtio-console`.
+
+- x86-64
+
+```shell
+$ ./cloud-hypervisor \
 	--kernel ./linux-cloud-hypervisor/arch/x86/boot/compressed/vmlinux.bin \
 	--console off \
 	--serial tty \
@@ -278,10 +259,24 @@ $ ./cloud-hypervisor/target/release/cloud-hypervisor \
 	--net "tap=,mac=,ip=,mask="
 ```

+- AArch64
+
+```shell
+$ ./cloud-hypervisor \
+	--kernel ./linux-cloud-hypervisor/arch/arm64/boot/Image \
+	--console off \
+	--serial tty \
+	--disk path=focal-server-cloudimg-arm64.raw \
+	--cmdline "console=ttyAMA0 root=/dev/vda1 rw" \
+	--cpus boot=4 \
+	--memory size=1024M \
+	--net "tap=,mac=,ip=,mask="
+```
+
 # 3. Status

-Cloud Hypervisor is under active development. The following stability guarantees
-are currently made:
+Cloud Hypervisor is under active development. The following stability
+guarantees are currently made:

 * The API (including command line options) will not be removed or changed in a
  breaking way without a minimum of 2 major releases notice. Where possible
@@ -299,16 +294,17 @@ Currently the following items are **not** guaranteed across updates:
 * The following features are considered experimental and may change
  substantially between releases: TDX, vfio-user, vDPA.

-As of 2022-04-05, the following cloud images are supported:
+Further details can be found in the [release documentation](docs/releases.md).

- [Ubuntu Bionic](https://cloud-images.ubuntu.com/bionic/current/) (cloudimg)
- [Ubuntu Focal](https://cloud-images.ubuntu.com/focal/current/) (cloudimg)
- [Ubuntu Jammy](https://cloud-images.ubuntu.com/jammy/current/) (cloudimg)
+As of 2023-01-03, the following cloud images are supported:
+
+- [Ubuntu Focal](https://cloud-images.ubuntu.com/focal/current/) (focal-server-cloudimg-{amd64,arm64}.img)
+- [Ubuntu Jammy](https://cloud-images.ubuntu.com/jammy/current/) (jammy-server-cloudimg-{amd64,arm64}.img )
+- [Fedora 36](https://fedora.mirrorservice.org/fedora/linux/releases/36/Cloud/) ([Fedora-Cloud-Base-36-1.5.x86_64.raw.xz](https://fedora.mirrorservice.org/fedora/linux/releases/36/Cloud/x86_64/images/) / [Fedora-Cloud-Base-36-1.5.aarch64.raw.xz](https://fedora.mirrorservice.org/fedora/linux/releases/36/Cloud/aarch64/images/))

 Direct kernel boot to userspace should work with a rootfs from most
-distributions.
-
-Further details can be found in the [release documentation](docs/releases.md).
+distributions although you may need to enable exotic filesystem types in the
+reference kernel configuration (e.g. XFS or btrfs.)

 ## Hot Plug

@@ -321,18 +317,12 @@ Cloud Hypervisor supports hotplug of CPUs, passthrough devices (VFIO),
 Details of the device model can be found in this
 [documentation](docs/device_model.md).

-## TODO
-
-We are not tracking the Cloud Hypervisor TODO list from a specific git tracked
-file but through
-[github issues](https://github.com/cloud-hypervisor/cloud-hypervisor/issues/new)
-instead.
-
 ## Roadmap

-The project roadmap is tracked through a [GitHub project](https://github.com/orgs/cloud-hypervisor/projects/6).
+The project roadmap is tracked through a [GitHub
+project](https://github.com/orgs/cloud-hypervisor/projects/6).

-# 4. `rust-vmm` project dependency
+# 4. Relationship with _Rust VMM_ Project

 In order to satisfy the design goal of having a high-performance,
 security-focused hypervisor the decision was made to use the
@@ -341,39 +331,26 @@ focus on memory and thread safety makes it an ideal candidate for implementing
 VMMs.

 Instead of implementing the VMM components from scratch, Cloud Hypervisor is
-importing the [rust-vmm](https://github.com/rust-vmm) crates, and sharing code
+importing the [Rust VMM](https://github.com/rust-vmm) crates, and sharing code
 and architecture together with other VMMs like e.g. Amazon's
 [Firecracker](https://firecracker-microvm.github.io/) and Google's
 [crosvm](https://chromium.googlesource.com/chromiumos/platform/crosvm/).

-Cloud Hypervisor embraces the rust-vmm project goals, which is to be able to
-share and re-use as many virtualization crates as possible. As such, the Cloud
-Hypervisor relationship with the rust-vmm project is twofold:
+Cloud Hypervisor embraces the _Rust VMM_ project's goals, which is to be able
+to share and re-use as many virtualization crates as possible.

-1. It will use as much of the rust-vmm code as possible. Any new rust-vmm crate
-   that's relevant to the project goals will be integrated as soon as possible.
-2. As it is likely that the rust-vmm project will lack some of the features that
-   Cloud Hypervisor needs (e.g. ACPI, VFIO, vhost-user, etc), we will be using
-   the Cloud Hypervisor VMM to implement and test them, and contribute them back
-   to the rust-vmm project.
-
-## Firecracker and crosvm
+## Differences with Firecracker and crosvm

 A large part of the Cloud Hypervisor code is based on either the Firecracker or
-the crosvm projects implementations. Both of these are VMMs written in Rust with
-a focus on safety and security, like Cloud Hypervisor.
+the crosvm project's implementations. Both of these are VMMs written in Rust
+with a focus on safety and security, like Cloud Hypervisor.

-However we want to emphasize that the Cloud Hypervisor project is neither a fork
-nor a reimplementation of any of those projects. The goals and use cases we're
-trying to meet are different. We're aiming at supporting cloud workloads, i.e.
-those modern, full Linux distribution images currently being run by Cloud
-Service Provider (CSP) tenants.
+The goal of the Cloud Hypervisor project differs from the aforementioned
+projects in that it aims to be a general purpose VMM for _Cloud Workloads_ and
+not limited to container/serverless or client workloads.

-Our primary target is not to support client or serverless use cases, and as such
-our code base already diverges from the crosvm and Firecracker ones. As we add
-more features to support our use cases, we believe that the divergence will
-increase while at the same time sharing as much of the fundamental
-virtualization code through the rust-vmm project crates as possible.
+The Cloud Hypervisor community thanks the communities of both the Firecracker
+and crosvm projects for their excellent work.

 # 5. Community

@@ -383,12 +360,12 @@ repository.

 ## Contribute

-We are working on building a global, diverse and collaborative community around
-the Cloud Hypervisor project. Anyone who is interested in
+The project strongly believes in building a global, diverse and collaborative
+community around the Cloud Hypervisor project. Anyone who is interested in
 [contributing](CONTRIBUTING.md) to the project is welcome to participate.

-We believe that contributing to a open source project like Cloud Hypervisor
-covers a lot more than just sending code. Testing, documentation, pull request
+Contributing to a open source project like Cloud Hypervisor covers a lot more
+than just sending code. Testing, documentation, pull request
 reviews, bug reports, feature requests, project improvement suggestions, etc,
 are all equal and welcome means of contribution. See the
 [CONTRIBUTING](CONTRIBUTING.md) document for more details.
--- a/acpi_tables/Cargo.toml
+++ b/acpi_tables/Cargo.toml
@@ -5,4 +5,4 @@ authors = ["The Cloud Hypervisor Authors"]
 edition = "2021"

 [dependencies]
-vm-memory = "0.9.0"
+vm-memory = "0.10.0"
--- a/acpi_tables/src/sdt.rs
+++ b/acpi_tables/src/sdt.rs
@@ -38,7 +38,6 @@ pub struct Sdt {
    data: Vec<u8>,
 }

-#[allow(clippy::len_without_is_empty)]
 impl Sdt {
    pub fn new(
        signature: [u8; 4],
@@ -98,6 +97,7 @@ impl Sdt {
    /// Write a value at the given offset
    pub fn write<T>(&mut self, offset: usize, value: T) {
        assert!((offset + (std::mem::size_of::<T>() - 1)) < self.data.len());
+        // SAFETY: The assertion above makes sure we don't do out of bounds write.
        unsafe {
            *(((self.data.as_mut_ptr() as usize) + offset) as *mut T) = value;
        }
@@ -123,6 +123,10 @@ impl Sdt {
    pub fn len(&self) -> usize {
        self.data.len()
    }
+
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
 }

 #[cfg(test)]
--- a/api_client/Cargo.toml
+++ b/api_client/Cargo.toml
@@ -5,4 +5,4 @@ authors = ["The Cloud Hypervisor Authors"]
 edition = "2021"

 [dependencies]
-vmm-sys-util = "0.10.0"
+vmm-sys-util = "0.11.0"
--- a/api_client/src/lib.rs
+++ b/api_client/src/lib.rs
@@ -22,16 +22,16 @@ impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use Error::*;
        match self {
-            Socket(e) => write!(f, "Error writing to or reading from HTTP socket: {}", e),
-            SocketSendFds(e) => write!(f, "Error writing to or reading from HTTP socket: {}", e),
-            StatusCodeParsing(e) => write!(f, "Error parsing HTTP status code: {}", e),
+            Socket(e) => write!(f, "Error writing to or reading from HTTP socket: {e}"),
+            SocketSendFds(e) => write!(f, "Error writing to or reading from HTTP socket: {e}"),
+            StatusCodeParsing(e) => write!(f, "Error parsing HTTP status code: {e}"),
            MissingProtocol => write!(f, "HTTP output is missing protocol statement"),
-            ContentLengthParsing(e) => write!(f, "Error parsing HTTP Content-Length field: {}", e),
+            ContentLengthParsing(e) => write!(f, "Error parsing HTTP Content-Length field: {e}"),
            ServerResponse(s, o) => {
                if let Some(o) = o {
-                    write!(f, "Server responded with an error: {:?}: {}", s, o)
+                    write!(f, "Server responded with an error: {s:?}: {o}")
                } else {
-                    write!(f, "Server responded with an error: {:?}", s)
+                    write!(f, "Server responded with an error: {s:?}")
                }
            }
        }
@@ -79,7 +79,7 @@ impl StatusCode {
 }

 fn get_header<'a>(res: &'a str, header: &'a str) -> Option<&'a str> {
-    let header_str = format!("{}: ", header);
+    let header_str = format!("{header}: ");
    res.find(&header_str)
        .map(|o| &res[o + header_str.len()..o + res[o..].find('\r').unwrap()])
 }
@@ -153,8 +153,7 @@ pub fn simple_api_full_command_with_fds_and_response<T: Read + Write + ScmSocket
    socket
        .send_with_fds(
            &[format!(
-                "{} /api/v1/{} HTTP/1.1\r\nHost: localhost\r\nAccept: */*\r\n",
-                method, full_command
+                "{method} /api/v1/{full_command} HTTP/1.1\r\nHost: localhost\r\nAccept: */*\r\n"
            )
            .as_bytes()],
            &request_fds,
@@ -235,7 +234,7 @@ pub fn simple_api_command_with_fds<T: Read + Write + ScmSocket>(
 ) -> Result<(), Error> {
    // Create the full VM command. For VMM commands, use
    // simple_api_full_command().
-    let full_command = format!("vm.{}", c);
+    let full_command = format!("vm.{c}");

    simple_api_full_command_with_fds(socket, method, &full_command, request_body, request_fds)
 }
--- a/arch/Cargo.toml
+++ b/arch/Cargo.toml
@@ -9,20 +9,20 @@ default = []
 tdx = []

 [dependencies]
-anyhow = "1.0.65"
+anyhow = "1.0.68"
 byteorder = "1.4.3"
 hypervisor = { path = "../hypervisor" }
-libc = "0.2.133"
-linux-loader = { version = "0.6.0", features = ["elf", "bzimage", "pe"] }
+libc = "0.2.139"
+linux-loader = { version = "0.8.1", features = ["elf", "bzimage", "pe"] }
 log = "0.4.17"
-serde = { version = "1.0.145", features = ["rc", "derive"] }
-thiserror = "1.0.37"
-uuid = "1.1.2"
-versionize = "0.1.6"
+serde = { version = "1.0.151", features = ["rc", "derive"] }
+thiserror = "1.0.38"
+uuid = "1.2.2"
+versionize = "0.1.9"
 versionize_derive = "0.1.4"
-vm-memory = { version = "0.9.0", features = ["backend-mmap", "backend-bitmap"] }
+vm-memory = { version = "0.10.0", features = ["backend-mmap", "backend-bitmap"] }
 vm-migration = { path = "../vm-migration" }
-vmm-sys-util = { version = "0.10.0", features = ["with-serde"] }
+vmm-sys-util = { version = "0.11.0", features = ["with-serde"] }

 [target.'cfg(target_arch = "aarch64")'.dependencies]
 fdt_parser = { version = "0.1.4", package = "fdt" }
--- a/arch/src/aarch64/fdt.rs
+++ b/arch/src/aarch64/fdt.rs
@@ -51,8 +51,6 @@ const SIZE_CELLS: u32 = 0x2;
 // Look for "The 1st cell..."
 const GIC_FDT_IRQ_TYPE_SPI: u32 = 0;
 const GIC_FDT_IRQ_TYPE_PPI: u32 = 1;
-const GIC_FDT_IRQ_PPI_CPU_SHIFT: u32 = 8;
-const GIC_FDT_IRQ_PPI_CPU_MASK: u32 = 0xff << GIC_FDT_IRQ_PPI_CPU_SHIFT;

 // From https://elixir.bootlin.com/linux/v4.9.62/source/include/dt-bindings/interrupt-controller/irq.h#L17
 const IRQ_TYPE_EDGE_RISING: u32 = 1;
@@ -121,7 +119,7 @@ pub fn create_fdt<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHash
    create_gic_node(&mut fdt, gic_device)?;
    create_timer_node(&mut fdt)?;
    if pmu_supported {
-        create_pmu_node(&mut fdt, vcpu_mpidr.len())?;
+        create_pmu_node(&mut fdt)?;
    }
    create_clock_node(&mut fdt)?;
    create_psci_node(&mut fdt)?;
@@ -162,7 +160,7 @@ fn create_cpu_nodes(
    let num_cpus = vcpu_mpidr.len();

    for (cpu_id, mpidr) in vcpu_mpidr.iter().enumerate().take(num_cpus) {
-        let cpu_name = format!("cpu@{:x}", cpu_id);
+        let cpu_name = format!("cpu@{cpu_id:x}");
        let cpu_node = fdt.begin_node(&cpu_name)?;
        fdt.property_string("device_type", "cpu")?;
        fdt.property_string("compatible", "arm,arm-v8")?;
@@ -194,15 +192,15 @@ fn create_cpu_nodes(

        // Create device tree nodes with regard of above mapping.
        for cluster_idx in 0..packages {
-            let cluster_name = format!("cluster{:x}", cluster_idx);
+            let cluster_name = format!("cluster{cluster_idx:x}");
            let cluster_node = fdt.begin_node(&cluster_name)?;

            for core_idx in 0..cores_per_package {
-                let core_name = format!("core{:x}", core_idx);
+                let core_name = format!("core{core_idx:x}");
                let core_node = fdt.begin_node(&core_name)?;

                for thread_idx in 0..threads_per_core {
-                    let thread_name = format!("thread{:x}", thread_idx);
+                    let thread_name = format!("thread{thread_idx:x}");
                    let thread_node = fdt.begin_node(&thread_name)?;
                    let cpu_idx = threads_per_core * cores_per_package * cluster_idx
                        + threads_per_core * core_idx
@@ -249,7 +247,7 @@ fn create_memory_node(
                    node_memory_addr = memory_region_start_addr;
                }
            }
-            let memory_node_name = format!("memory@{:x}", node_memory_addr);
+            let memory_node_name = format!("memory@{node_memory_addr:x}");
            let memory_node = fdt.begin_node(&memory_node_name)?;
            fdt.property_string("device_type", "memory")?;
            fdt.property_array_u64("reg", &mem_reg_prop)?;
@@ -261,7 +259,7 @@ fn create_memory_node(
        if last_addr < super::layout::MEM_32BIT_RESERVED_START.raw_value() {
            // Case 1: all RAM is under the hole
            let mem_size = last_addr - super::layout::RAM_START.raw_value() + 1;
-            let mem_reg_prop = [super::layout::RAM_START.raw_value() as u64, mem_size as u64];
+            let mem_reg_prop = [super::layout::RAM_START.raw_value(), mem_size];
            let memory_node = fdt.begin_node("memory")?;
            fdt.property_string("device_type", "memory")?;
            fdt.property_array_u64("reg", &mem_reg_prop)?;
@@ -271,7 +269,7 @@ fn create_memory_node(
            // Region 1: RAM before the hole
            let mem_size = super::layout::MEM_32BIT_RESERVED_START.raw_value()
                - super::layout::RAM_START.raw_value();
-            let mem_reg_prop = [super::layout::RAM_START.raw_value() as u64, mem_size as u64];
+            let mem_reg_prop = [super::layout::RAM_START.raw_value(), mem_size];
            let memory_node_name = format!("memory@{:x}", super::layout::RAM_START.raw_value());
            let memory_node = fdt.begin_node(&memory_node_name)?;
            fdt.property_string("device_type", "memory")?;
@@ -280,10 +278,7 @@ fn create_memory_node(

            // Region 2: RAM after the hole
            let mem_size = last_addr - super::layout::RAM_64BIT_START.raw_value() + 1;
-            let mem_reg_prop = [
-                super::layout::RAM_64BIT_START.raw_value() as u64,
-                mem_size as u64,
-            ];
+            let mem_reg_prop = [super::layout::RAM_64BIT_START.raw_value(), mem_size];
            let memory_node_name =
                format!("memory@{:x}", super::layout::RAM_64BIT_START.raw_value());
            let memory_node = fdt.begin_node(&memory_node_name)?;
@@ -305,7 +300,7 @@ fn create_chosen_node(
    fdt.property_string("bootargs", cmdline)?;

    if let Some(initrd_config) = initrd {
-        let initrd_start = initrd_config.address.raw_value() as u64;
+        let initrd_start = initrd_config.address.raw_value();
        let initrd_end = initrd_config.address.raw_value() + initrd_config.size as u64;
        fdt.property_u64("linux,initrd-start", initrd_start)?;
        fdt.property_u64("linux,initrd-end", initrd_end)?;
@@ -541,16 +536,9 @@ fn create_devices_node<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::Buil
    Ok(())
 }

-fn create_pmu_node(fdt: &mut FdtWriter, cpu_nums: usize) -> FdtWriterResult<()> {
-    let num_cpus = cpu_nums as u64 as u32;
+fn create_pmu_node(fdt: &mut FdtWriter) -> FdtWriterResult<()> {
    let compatible = "arm,armv8-pmuv3";
-    let cpu_mask: u32 =
-        (((1 << num_cpus) - 1) << GIC_FDT_IRQ_PPI_CPU_SHIFT) & GIC_FDT_IRQ_PPI_CPU_MASK;
-    let irq = [
-        GIC_FDT_IRQ_TYPE_PPI,
-        AARCH64_PMU_IRQ,
-        cpu_mask | IRQ_TYPE_LEVEL_HI,
-    ];
+    let irq = [GIC_FDT_IRQ_TYPE_PPI, AARCH64_PMU_IRQ, IRQ_TYPE_LEVEL_HI];

    let pmu_node = fdt.begin_node("pmu")?;
    fdt.property_string("compatible", compatible)?;
@@ -679,7 +667,7 @@ fn create_pci_nodes(

                // See kernel document Documentation/devicetree/bindings/virtio/iommu.txt
                // for virtio-iommu node settings.
-                let virtio_iommu_node_name = format!("virtio_iommu@{:x}", virtio_iommu_bdf);
+                let virtio_iommu_node_name = format!("virtio_iommu@{virtio_iommu_bdf:x}");
                let virtio_iommu_node = fdt.begin_node(&virtio_iommu_node_name)?;
                fdt.property_u32("#iommu-cells", 1)?;
                fdt.property_string("compatible", "virtio,pci-iommu")?;
--- a/arch/src/aarch64/layout.rs
+++ b/arch/src/aarch64/layout.rs
@@ -98,6 +98,11 @@ pub const RAM_START: GuestAddress = GuestAddress(0x4000_0000);
 pub const MEM_32BIT_RESERVED_START: GuestAddress = GuestAddress(0xfc00_0000);
 pub const MEM_32BIT_RESERVED_SIZE: u64 = 0x0400_0000;

+/// TPM Address Range
+/// This Address range is specific to CRB Interface
+pub const TPM_START: GuestAddress = GuestAddress(0xfed4_0000);
+pub const TPM_SIZE: u64 = 0x1000;
+
 /// Start of 64-bit RAM.
 pub const RAM_64BIT_START: GuestAddress = GuestAddress(0x1_0000_0000);

--- a/arch/src/aarch64/mod.rs
+++ b/arch/src/aarch64/mod.rs
@@ -19,7 +19,7 @@ use std::collections::HashMap;
 use std::convert::TryInto;
 use std::fmt::Debug;
 use std::sync::{Arc, Mutex};
-use vm_memory::{Address, GuestAddress, GuestMemory, GuestUsize};
+use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic, GuestUsize};

 /// Errors thrown while configuring aarch64 system.
 #[derive(Debug)]
@@ -64,9 +64,9 @@ pub struct EntryPoint {
 pub fn configure_vcpu(
    vcpu: &Arc<dyn hypervisor::Vcpu>,
    id: u8,
-    kernel_entry_point: Option<EntryPoint>,
+    boot_setup: Option<(EntryPoint, &GuestMemoryAtomic<GuestMemoryMmap>)>,
 ) -> super::Result<u64> {
-    if let Some(kernel_entry_point) = kernel_entry_point {
+    if let Some((kernel_entry_point, _guest_memory)) = boot_setup {
        vcpu.setup_regs(
            id,
            kernel_entry_point.entry_addr.raw_value(),
@@ -108,7 +108,7 @@ pub fn arch_memory_regions(size: GuestUsize) -> Vec<(GuestAddress, usize, Region

    // RAM space
    // Case1: guest memory fits before the gap
-    if size as u64 <= ram_32bit_space_size {
+    if size <= ram_32bit_space_size {
        regions.push((layout::RAM_START, size as usize, RegionType::Ram));
    // Case2: guest memory extends beyond the gap
    } else {
@@ -231,7 +231,7 @@ mod tests {
            layout::MEM_32BIT_RESERVED_START.unchecked_offset_from(layout::RAM_START) as usize;
        assert_eq!(6, regions.len());
        assert_eq!(layout::RAM_START, regions[3].0);
-        assert_eq!(ram_32bit_space_size as usize, regions[3].1);
+        assert_eq!(ram_32bit_space_size, regions[3].1);
        assert_eq!(RegionType::Ram, regions[3].2);
        assert_eq!(RegionType::Reserved, regions[5].2);
        assert_eq!(RegionType::Ram, regions[4].2);
--- a/arch/src/aarch64/uefi.rs
+++ b/arch/src/aarch64/uefi.rs
@@ -34,9 +34,7 @@ where
    if uefi_size > 0x300000 {
        return Err(Error::UefiTooBig);
    }
-    uefi_image
-        .seek(SeekFrom::Start(0))
-        .map_err(|_| Error::SeekUefiStart)?;
+    uefi_image.rewind().map_err(|_| Error::SeekUefiStart)?;
    guest_mem
        .read_exact_from(guest_addr, uefi_image, uefi_size)
        .map_err(|_| Error::ReadUefiImage)
--- a/arch/src/lib.rs
+++ b/arch/src/lib.rs
@@ -99,7 +99,7 @@ pub use x86_64::{
 #[cfg(target_arch = "x86_64")]
 #[inline(always)]
 fn pagesize() -> usize {
-    // Trivially safe
+    // SAFETY: Trivially safe
    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
 }

@@ -145,7 +145,7 @@ pub const PAGE_SIZE: usize = 4096;

 impl fmt::Display for DeviceType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
    }
 }

--- a/arch/src/x86_64/layout.rs
+++ b/arch/src/x86_64/layout.rs
@@ -107,6 +107,11 @@ pub const KVM_TSS_SIZE: u64 = (3 * 4) << 10;
 pub const KVM_IDENTITY_MAP_START: GuestAddress = GuestAddress(KVM_TSS_START.0 + KVM_TSS_SIZE);
 pub const KVM_IDENTITY_MAP_SIZE: u64 = 4 << 10;

+/// TPM Address Range
+/// This Address range is specific to CRB Interface
+pub const TPM_START: GuestAddress = GuestAddress(0xfed4_0000);
+pub const TPM_SIZE: u64 = 0x1000;
+
 // IOAPIC
 pub const IOAPIC_START: GuestAddress = GuestAddress(0xfec0_0000);
 pub const IOAPIC_SIZE: u64 = 0x20;
--- a/arch/src/x86_64/mod.rs
+++ b/arch/src/x86_64/mod.rs
@@ -125,9 +125,11 @@ struct MemmapTableEntryWrapper(hvm_memmap_table_entry);
 #[derive(Copy, Clone, Default)]
 struct ModlistEntryWrapper(hvm_modlist_entry);

-// SAFETY: These data structures only contain a series of integers
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for StartInfoWrapper {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for MemmapTableEntryWrapper {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for ModlistEntryWrapper {}

 // This is a workaround to the Rust enforcement specifying that any implementation of a foreign
@@ -545,13 +547,30 @@ impl CpuidFeatureEntry {
 }

 pub fn generate_common_cpuid(
-    hypervisor: Arc<dyn hypervisor::Hypervisor>,
+    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,
 ) -> 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 {
+        // SAFETY: cpuid called with valid leaves
+        let hypervisor_cpuid = unsafe { x86_64::__cpuid(0x4000_0000) };
+
+        let mut identifier: [u8; 12] = [0; 12];
+        identifier[0..4].copy_from_slice(&hypervisor_cpuid.ebx.to_le_bytes()[..]);
+        identifier[4..8].copy_from_slice(&hypervisor_cpuid.ecx.to_le_bytes()[..]);
+        identifier[8..12].copy_from_slice(&hypervisor_cpuid.edx.to_le_bytes()[..]);
+
+        info!(
+            "Running under nested virtualisation. Hypervisor string: {}",
+            String::from_utf8_lossy(&identifier)
+        );
+    }
+
+    info!("Generating guest CPUID for with physical address size: {phys_bits}");
    let cpuid_patches = vec![
        // Patch tsc deadline timer bit
        CpuidPatch {
@@ -631,6 +650,20 @@ pub fn generate_common_cpuid(
                    }
                }
            }
+            // Copy host L2 cache details if not populated by KVM
+            0x8000_0006 => {
+                if entry.eax == 0 && entry.ebx == 0 && entry.ecx == 0 && entry.edx == 0 {
+                    // SAFETY: cpuid called with valid leaves
+                    if unsafe { std::arch::x86_64::__cpuid(0x8000_0000).eax } >= 0x8000_0006 {
+                        // SAFETY: cpuid called with valid leaves
+                        let leaf = unsafe { std::arch::x86_64::__cpuid(0x8000_0006) };
+                        entry.eax = leaf.eax;
+                        entry.ebx = leaf.ebx;
+                        entry.ecx = leaf.ecx;
+                        entry.edx = leaf.edx;
+                    }
+                }
+            }
            // Set CPU physical bits
            0x8000_0008 => {
                entry.eax = (entry.eax & 0xffff_ff00) | (phys_bits as u32 & 0xff);
@@ -661,6 +694,7 @@ pub fn generate_common_cpuid(
    // Copy CPU identification string
    for i in 0x8000_0002..=0x8000_0004 {
        cpuid.retain(|c| c.function != i);
+        // SAFETY: call cpuid with valid leaves
        let leaf = unsafe { std::arch::x86_64::__cpuid(i) };
        cpuid.push(CpuIdEntry {
            function: i,
@@ -725,8 +759,7 @@ pub fn generate_common_cpuid(
 pub fn configure_vcpu(
    vcpu: &Arc<dyn hypervisor::Vcpu>,
    id: u8,
-    kernel_entry_point: Option<EntryPoint>,
-    vm_memory: &GuestMemoryAtomic<GuestMemoryMmap>,
+    boot_setup: Option<(EntryPoint, &GuestMemoryAtomic<GuestMemoryMmap>)>,
    cpuid: Vec<CpuIdEntry>,
    kvm_hyperv: bool,
 ) -> super::Result<()> {
@@ -743,12 +776,12 @@ pub fn configure_vcpu(
    }

    regs::setup_msrs(vcpu).map_err(Error::MsrsConfiguration)?;
-    if let Some(kernel_entry_point) = kernel_entry_point {
+    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(&vm_memory.memory(), vcpu).map_err(Error::SregsConfiguration)?;
+            regs::setup_sregs(&guest_memory.memory(), vcpu).map_err(Error::SregsConfiguration)?;
        }
    }
    interrupts::set_lint(vcpu).map_err(|e| Error::LocalIntConfiguration(e.into()))?;
@@ -764,11 +797,11 @@ pub fn arch_memory_regions(size: GuestUsize) -> Vec<(GuestAddress, usize, Region
        .checked_add(layout::MEM_32BIT_DEVICES_SIZE)
        .expect("32-bit reserved region is too large");

-    let requested_memory_size = GuestAddress(size as u64);
+    let requested_memory_size = GuestAddress(size);
    let mut regions = Vec::new();

    // case1: guest memory fits before the gap
-    if size as u64 <= layout::MEM_32BIT_RESERVED_START.raw_value() {
+    if size <= layout::MEM_32BIT_RESERVED_START.raw_value() {
        regions.push((GuestAddress(0), size as usize, RegionType::Ram));
    // case2: guest memory extends beyond the gap
    } else {
@@ -865,7 +898,7 @@ fn configure_pvh(
    start_info.0.magic = XEN_HVM_START_MAGIC_VALUE;
    start_info.0.version = 1; // pvh has version 1
    start_info.0.nr_modules = 0;
-    start_info.0.cmdline_paddr = cmdline_addr.raw_value() as u64;
+    start_info.0.cmdline_paddr = cmdline_addr.raw_value();
    start_info.0.memmap_paddr = layout::MEMMAP_START.raw_value();

    if let Some(rsdp_addr) = rsdp_addr {
@@ -934,7 +967,7 @@ fn configure_pvh(
        add_memmap_entry(
            &mut memmap,
            sgx_epc_region.start().raw_value(),
-            sgx_epc_region.size() as u64,
+            sgx_epc_region.size(),
            E820_RESERVED,
        );
    }
@@ -1011,6 +1044,7 @@ pub fn initramfs_load_addr(
 }

 pub fn get_host_cpu_phys_bits() -> u8 {
+    // SAFETY: call cpuid with valid leaves
    unsafe {
        let leaf = x86_64::__cpuid(0x8000_0000);

@@ -1121,12 +1155,13 @@ fn update_cpuid_sgx(

    // Get host CPUID for leaf 0x12, subleaf 0x2. This is to retrieve EPC
    // properties such as confidentiality and integrity.
+    // SAFETY: call cpuid with valid leaves
    let leaf = unsafe { std::arch::x86_64::__cpuid_count(0x12, 0x2) };

    for (i, epc_section) in epc_sections.iter().enumerate() {
        let subleaf_idx = i + 2;
        let start = epc_section.start().raw_value();
-        let size = epc_section.size() as u64;
+        let size = epc_section.size();
        let eax = (start & 0xffff_f000) as u32 | 0x1;
        let ebx = (start >> 32) as u32;
        let ecx = (size & 0xffff_f000) as u32 | (leaf.ecx & 0xf);
@@ -1302,6 +1337,6 @@ mod tests {
        add_memmap_entry(&mut memmap, 0, 0x1000, E820_RAM);
        add_memmap_entry(&mut memmap, 0x10000, 0xa000, E820_RESERVED);

-        assert_eq!(format!("{:?}", memmap), format!("{:?}", expected_memmap));
+        assert_eq!(format!("{memmap:?}"), format!("{expected_memmap:?}"));
    }
 }
--- a/arch/src/x86_64/mptable.rs
+++ b/arch/src/x86_64/mptable.rs
@@ -37,11 +37,17 @@ struct MpfIntelWrapper(mpspec::mpf_intel);

 // SAFETY: These `mpspec` wrapper types are only data, reading them from data is a safe initialization.
 unsafe impl ByteValued for MpcBusWrapper {}
+// SAFETY: see above
 unsafe impl ByteValued for MpcCpuWrapper {}
+// SAFETY: see above
 unsafe impl ByteValued for MpcIntsrcWrapper {}
+// SAFETY: see above
 unsafe impl ByteValued for MpcIoapicWrapper {}
+// SAFETY: see above
 unsafe impl ByteValued for MpcTableWrapper {}
+// SAFETY: see above
 unsafe impl ByteValued for MpcLintsrcWrapper {}
+// SAFETY: see above
 unsafe impl ByteValued for MpfIntelWrapper {}

 #[derive(Debug)]
@@ -95,7 +101,7 @@ const CPU_FEATURE_APIC: u32 = 0x200;
 const CPU_FEATURE_FPU: u32 = 0x001;

 fn compute_checksum<T: Copy>(v: &T) -> u8 {
-    // Safe because we are only reading the bytes within the size of the `T` reference `v`.
+    // SAFETY: we are only reading the bytes within the size of the `T` reference `v`.
    let v_slice = unsafe { slice::from_raw_parts(v as *const T as *const u8, mem::size_of::<T>()) };
    let mut checksum: u8 = 0;
    for i in v_slice.iter() {
@@ -294,7 +300,7 @@ mod tests {
            mpspec::MP_IOAPIC => mem::size_of::<MpcIoapicWrapper>(),
            mpspec::MP_INTSRC => mem::size_of::<MpcIntsrcWrapper>(),
            mpspec::MP_LINTSRC => mem::size_of::<MpcLintsrcWrapper>(),
-            _ => panic!("unrecognized mpc table entry type: {}", type_),
+            _ => panic!("unrecognized mpc table entry type: {type_}"),
        }
    }

--- a/arch/src/x86_64/regs.rs
+++ b/arch/src/x86_64/regs.rs
@@ -124,7 +124,7 @@ pub fn configure_segments_and_sregs(
    mem: &GuestMemoryMmap,
    sregs: &mut SpecialRegisters,
 ) -> Result<()> {
-    let gdt_table: [u64; BOOT_GDT_MAX as usize] = {
+    let gdt_table: [u64; BOOT_GDT_MAX] = {
        // Configure GDT entries as specified by PVH boot protocol
        [
            gdt_entry(0, 0, 0),               // NULL
--- a/arch/src/x86_64/smbios.rs
+++ b/arch/src/x86_64/smbios.rs
@@ -48,10 +48,10 @@ impl Display for Error {
            Clear => "Failure while zeroing out the memory for the SMBIOS table".to_string(),
            WriteSmbiosEp => "Failure to write SMBIOS entrypoint structure".to_string(),
            WriteData => "Failure to write additional data to memory".to_string(),
-            ParseUuid(e) => format!("Failure to parse uuid: {}", e),
+            ParseUuid(e) => format!("Failure to parse uuid: {e}"),
        };

-        write!(f, "SMBIOS error: {}", description)
+        write!(f, "SMBIOS error: {description}")
    }
 }

@@ -67,7 +67,7 @@ const PCI_SUPPORTED: u64 = 1 << 7;
 const IS_VIRTUAL_MACHINE: u8 = 1 << 4;

 fn compute_checksum<T: Copy>(v: &T) -> u8 {
-    // Safe because we are only reading the bytes within the size of the `T` reference `v`.
+    // SAFETY: we are only reading the bytes within the size of the `T` reference `v`.
    let v_slice = unsafe { slice::from_raw_parts(v as *const T as *const u8, mem::size_of::<T>()) };
    let mut checksum: u8 = 0;
    for i in v_slice.iter() {
@@ -145,11 +145,15 @@ struct SmbiosEndOfTable {
    handle: u16,
 }

-// SAFETY: These data structures only contain a series of integers
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for Smbios30Entrypoint {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for SmbiosBiosInfo {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for SmbiosSysInfo {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for SmbiosOemStrings {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for SmbiosEndOfTable {}

 fn write_and_incr<T: ByteValued>(
--- a/arch/src/x86_64/tdx/mod.rs
+++ b/arch/src/x86_64/tdx/mod.rs
@@ -4,7 +4,9 @@
 use crate::GuestMemoryMmap;
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom};
+use std::str::FromStr;
 use thiserror::Error;
+use uuid::Uuid;
 use vm_memory::{ByteValued, Bytes, GuestAddress, GuestMemoryError};

 #[derive(Error, Debug)]
@@ -13,6 +15,8 @@ pub enum TdvfError {
    ReadDescriptor(#[source] std::io::Error),
    #[error("Failed read TDVF descriptor offset: {0}")]
    ReadDescriptorOffset(#[source] std::io::Error),
+    #[error("Failed read GUID table: {0}")]
+    ReadGuidTable(#[source] std::io::Error),
    #[error("Invalid descriptor signature")]
    InvalidDescriptorSignature,
    #[error("Invalid descriptor size")]
@@ -21,8 +25,13 @@ pub enum TdvfError {
    InvalidDescriptorVersion,
    #[error("Failed to write HOB details to guest memory: {0}")]
    GuestMemoryWriteHob(#[source] GuestMemoryError),
+    #[error("Failed to create Uuid: {0}")]
+    UuidCreation(#[source] uuid::Error),
 }

+const TABLE_FOOTER_GUID: &str = "96b582de-1fb2-45f7-baea-a366c55a082d";
+const TDVF_METADATA_OFFSET_GUID: &str = "e47a6535-984a-4798-865e-4685a7bf8ec2";
+
 // TDVF_DESCRIPTOR
 #[repr(packed)]
 #[derive(Default)]
@@ -64,7 +73,72 @@ impl Default for TdvfSectionType {
    }
 }

-pub fn parse_tdvf_sections(file: &mut File) -> Result<Vec<TdvfSection>, TdvfError> {
+fn tdvf_descriptor_offset(file: &mut File) -> Result<(SeekFrom, bool), TdvfError> {
+    // Let's first try to identify the presence of the table footer GUID
+    file.seek(SeekFrom::End(-0x30))
+        .map_err(TdvfError::ReadGuidTable)?;
+    let mut table_footer_guid: [u8; 16] = [0; 16];
+    file.read_exact(&mut table_footer_guid)
+        .map_err(TdvfError::ReadGuidTable)?;
+    let uuid =
+        Uuid::from_slice_le(table_footer_guid.as_slice()).map_err(TdvfError::UuidCreation)?;
+    let expected_uuid = Uuid::from_str(TABLE_FOOTER_GUID).map_err(TdvfError::UuidCreation)?;
+    if uuid == expected_uuid {
+        // Retrieve the table size
+        file.seek(SeekFrom::End(-0x32))
+            .map_err(TdvfError::ReadGuidTable)?;
+        let mut table_size: [u8; 2] = [0; 2];
+        file.read_exact(&mut table_size)
+            .map_err(TdvfError::ReadGuidTable)?;
+        let table_size = u16::from_le_bytes(table_size) as usize;
+        let mut table: Vec<u8> = vec![0; table_size];
+
+        // Read the entire table
+        file.seek(SeekFrom::End(-(table_size as i64 + 0x20)))
+            .map_err(TdvfError::ReadGuidTable)?;
+        file.read_exact(table.as_mut_slice())
+            .map_err(TdvfError::ReadGuidTable)?;
+
+        // Let's start from the top and go backward down the table.
+        // We start after the footer GUID and the table length.
+        let mut offset = table_size - 18;
+
+        debug!("Parsing GUIDed structure");
+        while offset >= 18 {
+            let entry_uuid = Uuid::from_slice_le(&table[offset - 16..offset])
+                .map_err(TdvfError::UuidCreation)?;
+            let entry_size =
+                u16::from_le_bytes(table[offset - 18..offset - 16].try_into().unwrap()) as usize;
+            debug!(
+                "Entry GUID = {}, size = {}",
+                entry_uuid.hyphenated().to_string(),
+                entry_size
+            );
+
+            // Avoid going through an infinite loop if the entry size is 0
+            if entry_size == 0 {
+                break;
+            }
+
+            offset -= entry_size;
+
+            let expected_uuid =
+                Uuid::from_str(TDVF_METADATA_OFFSET_GUID).map_err(TdvfError::UuidCreation)?;
+            if entry_uuid == expected_uuid && entry_size == 22 {
+                return Ok((
+                    SeekFrom::End(
+                        -(u32::from_le_bytes(table[offset..offset + 4].try_into().unwrap()) as i64),
+                    ),
+                    true,
+                ));
+            }
+        }
+    }
+
+    // If we end up here, this means the firmware doesn't support the new way
+    // of exposing the TDVF descriptor offset through the table of GUIDs.
+    // That's why we fallback onto the deprecated method.
+
    // The 32-bit offset to the TDVF metadata is located 32 bytes from
    // the end of the file.
    // See "TDVF Metadata Pointer" in "TDX Virtual Firmware Design Guide
@@ -74,13 +148,21 @@ pub fn parse_tdvf_sections(file: &mut File) -> Result<Vec<TdvfSection>, TdvfErro
    let mut descriptor_offset: [u8; 4] = [0; 4];
    file.read_exact(&mut descriptor_offset)
        .map_err(TdvfError::ReadDescriptorOffset)?;
-    let descriptor_offset = u32::from_le_bytes(descriptor_offset) as u64;

-    file.seek(SeekFrom::Start(descriptor_offset))
+    Ok((
+        SeekFrom::Start(u32::from_le_bytes(descriptor_offset) as u64),
+        false,
+    ))
+}
+
+pub fn parse_tdvf_sections(file: &mut File) -> Result<(Vec<TdvfSection>, bool), TdvfError> {
+    let (descriptor_offset, guid_found) = tdvf_descriptor_offset(file)?;
+
+    file.seek(descriptor_offset)
        .map_err(TdvfError::ReadDescriptor)?;

    let mut descriptor: TdvfDescriptor = Default::default();
-    // Safe as we read exactly the size of the descriptor header
+    // SAFETY: we read exactly the size of the descriptor header
    file.read_exact(unsafe {
        std::slice::from_raw_parts_mut(
            &mut descriptor as *mut _ as *mut u8,
@@ -107,7 +189,7 @@ pub fn parse_tdvf_sections(file: &mut File) -> Result<Vec<TdvfSection>, TdvfErro
    let mut sections = Vec::new();
    sections.resize_with(descriptor.num_sections as usize, TdvfSection::default);

-    // Safe as we read exactly the advertised sections
+    // SAFETY: we read exactly the advertised sections
    file.read_exact(unsafe {
        std::slice::from_raw_parts_mut(
            sections.as_mut_ptr() as *mut u8,
@@ -116,7 +198,7 @@ pub fn parse_tdvf_sections(file: &mut File) -> Result<Vec<TdvfSection>, TdvfErro
    })
    .map_err(TdvfError::ReadDescriptor)?;

-    Ok(sections)
+    Ok((sections, guid_found))
 }

 #[repr(u16)]
@@ -211,12 +293,17 @@ struct TdPayload {
    payload_info: PayloadInfo,
 }

-// SAFETY: These data structures only contain a series of integers
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for HobHeader {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for HobHandoffInfoTable {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for HobResourceDescriptor {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for HobGuidType {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for PayloadInfo {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for TdPayload {}

 pub struct TdHob {
@@ -312,12 +399,19 @@ impl TdHob {
        physical_start: u64,
        resource_length: u64,
        ram: bool,
+        guid_found: bool,
    ) -> Result<(), TdvfError> {
        self.add_resource(
            mem,
            physical_start,
            resource_length,
            if ram {
+                if guid_found {
+                    0x7 /* EFI_RESOURCE_MEMORY_UNACCEPTED */
+                } else {
+                    0 /* EFI_RESOURCE_SYSTEM_MEMORY */
+                }
+            } else if guid_found {
                0 /* EFI_RESOURCE_SYSTEM_MEMORY */
            } else {
                0x5 /*EFI_RESOURCE_MEMORY_RESERVED */
@@ -445,9 +539,9 @@ mod tests {
    #[ignore]
    fn test_parse_tdvf_sections() {
        let mut f = std::fs::File::open("tdvf.fd").unwrap();
-        let sections = parse_tdvf_sections(&mut f).unwrap();
+        let (sections, _) = parse_tdvf_sections(&mut f).unwrap();
        for section in sections {
-            eprintln!("{:x?}", section)
+            eprintln!("{section:x?}")
        }
    }
 }
--- a/block_util/Cargo.toml
+++ b/block_util/Cargo.toml
@@ -8,17 +8,18 @@ edition = "2021"
 default = []

 [dependencies]
-io-uring = "0.5.6"
-libc = "0.2.133"
+io-uring = "0.5.11"
+libc = "0.2.139"
 log = "0.4.17"
 qcow = { path = "../qcow" }
-thiserror = "1.0.37"
-versionize = "0.1.6"
+smallvec = "1.10.0"
+thiserror = "1.0.38"
+versionize = "0.1.9"
 versionize_derive = "0.1.4"
 vhdx = { path = "../vhdx" }
 virtio-bindings = { version = "0.1.0", features = ["virtio-v5_0_0"] }
-virtio-queue = "0.6.1"
-vm-memory = { version = "0.9.0", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
+virtio-queue = "0.7.0"
+vm-memory = { version = "0.10.0", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
 vm-virtio = { path = "../vm-virtio" }
-vmm-sys-util = "0.10.0"
+vmm-sys-util = "0.11.0"

--- a/block_util/src/async_io.rs
+++ b/block_util/src/async_io.rs
@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause

 use libc::{ioctl, S_IFBLK, S_IFMT};
-use std::convert::TryInto;
 use std::fs::File;
 use std::os::unix::io::AsRawFd;
 use thiserror::Error;
@@ -54,19 +53,21 @@ enum BlockSize {
 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
-    #[allow(clippy::useless_conversion)]
    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(),
@@ -75,9 +76,7 @@ impl DiskTopology {
                    BlockSize::PhysicalBlock => BLKPBSZGET(),
                    BlockSize::MinimumIo => BLKIOMIN(),
                    BlockSize::OptimalIo => BLKIOOPT(),
-                }
-                .try_into()
-                .unwrap(),
+                } as _,
                &mut block_size,
            )
        };
@@ -132,15 +131,15 @@ pub trait AsyncIo: Send {
    fn read_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()>;
    fn write_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()>;
    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()>;
-    fn complete(&mut self) -> Vec<(u64, i32)>;
+    fn next_completed_request(&mut self) -> Option<(u64, i32)>;
 }
--- a/block_util/src/fixed_vhd_async.rs
+++ b/block_util/src/fixed_vhd_async.rs
@@ -64,7 +64,7 @@ impl AsyncIo for FixedVhdAsync {
    fn read_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        if offset as u64 >= self.size {
@@ -83,7 +83,7 @@ impl AsyncIo for FixedVhdAsync {
    fn write_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        if offset as u64 >= self.size {
@@ -104,7 +104,7 @@ impl AsyncIo for FixedVhdAsync {
        self.raw_file_async.fsync(user_data)
    }

-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        self.raw_file_async.complete()
+    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
+        self.raw_file_async.next_completed_request()
    }
 }
--- a/block_util/src/fixed_vhd_sync.rs
+++ b/block_util/src/fixed_vhd_sync.rs
@@ -62,7 +62,7 @@ impl AsyncIo for FixedVhdSync {
    fn read_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        if offset as u64 >= self.size {
@@ -81,7 +81,7 @@ impl AsyncIo for FixedVhdSync {
    fn write_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        if offset as u64 >= self.size {
@@ -101,7 +101,7 @@ impl AsyncIo for FixedVhdSync {
        self.raw_file_sync.fsync(user_data)
    }

-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        self.raw_file_sync.complete()
+    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
+        self.raw_file_sync.next_completed_request()
    }
 }
--- a/block_util/src/lib.rs
+++ b/block_util/src/lib.rs
@@ -22,8 +22,10 @@ pub mod vhdx_sync;

 use crate::async_io::{AsyncIo, AsyncIoError, AsyncIoResult};
 use io_uring::{opcode, IoUring, Probe};
+use smallvec::SmallVec;
 use std::alloc::{alloc_zeroed, dealloc, Layout};
 use std::cmp;
+use std::collections::VecDeque;
 use std::convert::TryInto;
 use std::fs::File;
 use std::io::{self, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
@@ -32,6 +34,7 @@ use std::path::Path;
 use std::result;
 use std::sync::Arc;
 use std::sync::MutexGuard;
+use std::time::Instant;
 use thiserror::Error;
 use versionize::{VersionMap, Versionize, VersionizeResult};
 use versionize_derive::Versionize;
@@ -51,23 +54,23 @@ pub const SECTOR_SIZE: u64 = 0x01 << SECTOR_SHIFT;

 #[derive(Error, Debug)]
 pub enum Error {
-    #[error("Guest gave us bad memory addresses.")]
+    #[error("Guest gave us bad memory addresses")]
    GuestMemory(GuestMemoryError),
-    #[error("Guest gave us offsets that would have overflowed a usize.")]
+    #[error("Guest gave us offsets that would have overflowed a usize")]
    CheckedOffset(GuestAddress, usize),
-    #[error("Guest gave us a write only descriptor that protocol says to read from.")]
+    #[error("Guest gave us a write only descriptor that protocol says to read from")]
    UnexpectedWriteOnlyDescriptor,
-    #[error("Guest gave us a read only descriptor that protocol says to write to.")]
+    #[error("Guest gave us a read only descriptor that protocol says to write to")]
    UnexpectedReadOnlyDescriptor,
-    #[error("Guest gave us too few descriptors in a descriptor chain.")]
+    #[error("Guest gave us too few descriptors in a descriptor chain")]
    DescriptorChainTooShort,
-    #[error("Guest gave us a descriptor that was too short to use.")]
+    #[error("Guest gave us a descriptor that was too short to use")]
    DescriptorLengthTooSmall,
-    #[error("Getting a block's metadata fails for any reason.")]
+    #[error("Getting a block's metadata fails for any reason")]
    GetFileMetadata,
-    #[error("The requested operation would cause a seek beyond disk end.")]
+    #[error("The requested operation would cause a seek beyond disk end")]
    InvalidOffset,
-    #[error("The requested operation does not support multiple descriptors.")]
+    #[error("The requested operation does not support multiple descriptors")]
    TooManyDescriptors,
 }

@@ -195,10 +198,11 @@ pub struct AlignedOperation {
 pub struct Request {
    pub request_type: RequestType,
    pub sector: u64,
-    pub data_descriptors: Vec<(GuestAddress, u32)>,
+    pub data_descriptors: SmallVec<[(GuestAddress, u32); 1]>,
    pub status_addr: GuestAddress,
    pub writeback: bool,
    pub aligned_operations: Vec<AlignedOperation>,
+    pub start: Instant,
 }

 impl Request {
@@ -226,10 +230,11 @@ impl Request {
        let mut req = Request {
            request_type: request_type(desc_chain.memory(), hdr_desc_addr)?,
            sector: sector(desc_chain.memory(), hdr_desc_addr)?,
-            data_descriptors: Vec::new(),
+            data_descriptors: SmallVec::with_capacity(1),
            status_addr: GuestAddress(0),
            writeback: true,
            aligned_operations: Vec::new(),
+            start: Instant::now(),
        };

        let status_desc;
@@ -249,6 +254,7 @@ impl Request {
                return Err(Error::DescriptorChainTooShort);
            }
        } else {
+            req.data_descriptors.reserve_exact(1);
            while desc.has_next() {
                if desc.is_write_only() && req.request_type == RequestType::Out {
                    return Err(Error::UnexpectedWriteOnlyDescriptor);
@@ -353,7 +359,8 @@ impl Request {
        let request_type = self.request_type;
        let offset = (sector << SECTOR_SHIFT) as libc::off_t;

-        let mut iovecs = Vec::new();
+        let mut iovecs: SmallVec<[libc::iovec; 1]> =
+            SmallVec::with_capacity(self.data_descriptors.len());
        for (data_addr, data_len) in &self.data_descriptors {
            if *data_len == 0 {
                continue;
@@ -381,7 +388,7 @@ impl Request {
            let iov_base = if (origin_ptr as u64) % SECTOR_SIZE != 0 {
                let layout =
                    Layout::from_size_align(*data_len as usize, SECTOR_SIZE as usize).unwrap();
-                // Safe because layout has non-zero size
+                // SAFETY: layout has non-zero size
                let aligned_ptr = unsafe { alloc_zeroed(layout) };
                if aligned_ptr.is_null() {
                    return Err(ExecuteError::TemporaryBufferAllocation(
@@ -392,7 +399,7 @@ impl Request {
                // We need to perform the copy beforehand in case we're writing
                // data out.
                if request_type == RequestType::Out {
-                    // Safe because destination buffer has been allocated with
+                    // 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)
@@ -430,12 +437,12 @@ impl Request {
                        .mark_dirty(0, *data_len as usize);
                }
                disk_image
-                    .read_vectored(offset, iovecs, user_data)
+                    .read_vectored(offset, &iovecs, user_data)
                    .map_err(ExecuteError::AsyncRead)?;
            }
            RequestType::Out => {
                disk_image
-                    .write_vectored(offset, iovecs, user_data)
+                    .write_vectored(offset, &iovecs, user_data)
                    .map_err(ExecuteError::AsyncWrite)?;
            }
            RequestType::Flush => {
@@ -467,7 +474,7 @@ impl Request {
            // We need to perform the copy after the data has been read inside
            // the aligned buffer in case we're reading data in.
            if self.request_type == RequestType::In {
-                // Safe because origin buffer has been allocated with the
+                // SAFETY: origin buffer has been allocated with the
                // proper size.
                unsafe {
                    std::ptr::copy(
@@ -479,7 +486,7 @@ impl Request {
            }

            // Free the temporary aligned buffer.
-            // Safe because aligned_ptr was allocated by alloc_zeroed with the same
+            // SAFETY: aligned_ptr was allocated by alloc_zeroed with the same
            // layout
            unsafe {
                dealloc(
@@ -528,8 +535,9 @@ pub struct VirtioBlockGeometry {
    pub sectors: u8,
 }

-// SAFETY: these data structures only contain a series of integers
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for VirtioBlockConfig {}
+// SAFETY: data structure only contain a series of integers
 unsafe impl ByteValued for VirtioBlockGeometry {}

 /// Check if io_uring for block device can be used on the current system, as
@@ -566,15 +574,15 @@ pub fn block_io_uring_is_supported() -> bool {
        return false;
    }

-    // Check IORING_OP_READ is supported
-    if !probe.is_supported(opcode::Read::CODE) {
-        info!("{} IORING_OP_READ operation not supported", error_msg);
+    // 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_WRITE is supported
-    if !probe.is_supported(opcode::Write::CODE) {
-        info!("{} IORING_OP_WRITE operation not supported", error_msg);
+    // Check IORING_OP_WRITEV is supported
+    if !probe.is_supported(opcode::Writev::CODE) {
+        info!("{} IORING_OP_WRITEV operation not supported", error_msg);
        return false;
    }

@@ -588,14 +596,15 @@ where
    fn read_vectored_sync(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
        eventfd: &EventFd,
-        completion_list: &mut Vec<(u64, i32)>,
+        completion_list: &mut VecDeque<(u64, i32)>,
    ) -> AsyncIoResult<()> {
        // Convert libc::iovec into IoSliceMut
        let mut slices = Vec::new();
        for iovec in iovecs.iter() {
+            // SAFETY: on Linux IoSliceMut wraps around libc::iovec
            slices.push(IoSliceMut::new(unsafe { std::mem::transmute(*iovec) }));
        }

@@ -611,7 +620,7 @@ where
                .map_err(AsyncIoError::ReadVectored)?
        };

-        completion_list.push((user_data, result as i32));
+        completion_list.push_back((user_data, result as i32));
        eventfd.write(1).unwrap();

        Ok(())
@@ -620,14 +629,15 @@ where
    fn write_vectored_sync(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
        eventfd: &EventFd,
-        completion_list: &mut Vec<(u64, i32)>,
+        completion_list: &mut VecDeque<(u64, i32)>,
    ) -> AsyncIoResult<()> {
        // Convert libc::iovec into IoSlice
        let mut slices = Vec::new();
        for iovec in iovecs.iter() {
+            // SAFETY: on Linux IoSliceMut wraps around libc::iovec
            slices.push(IoSlice::new(unsafe { std::mem::transmute(*iovec) }));
        }

@@ -643,7 +653,7 @@ where
                .map_err(AsyncIoError::WriteVectored)?
        };

-        completion_list.push((user_data, result as i32));
+        completion_list.push_back((user_data, result as i32));
        eventfd.write(1).unwrap();

        Ok(())
@@ -653,7 +663,7 @@ where
        &mut self,
        user_data: Option<u64>,
        eventfd: &EventFd,
-        completion_list: &mut Vec<(u64, i32)>,
+        completion_list: &mut VecDeque<(u64, i32)>,
    ) -> AsyncIoResult<()> {
        let result: i32 = {
            let mut file = self.file();
@@ -665,7 +675,7 @@ where
        };

        if let Some(user_data) = user_data {
-            completion_list.push((user_data, result));
+            completion_list.push_back((user_data, result));
            eventfd.write(1).unwrap();
        }

--- a/block_util/src/qcow_sync.rs
+++ b/block_util/src/qcow_sync.rs
@@ -5,6 +5,7 @@
 use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
 use crate::AsyncAdaptor;
 use qcow::{QcowFile, RawFile, Result as QcowResult};
+use std::collections::VecDeque;
 use std::fs::File;
 use std::io::{Seek, SeekFrom};
 use std::sync::{Arc, Mutex, MutexGuard};
@@ -26,7 +27,7 @@ impl DiskFile for QcowDiskSync {
    fn size(&mut self) -> DiskFileResult<u64> {
        let mut file = self.qcow_file.lock().unwrap();

-        Ok(file.seek(SeekFrom::End(0)).map_err(DiskFileError::Size)? as u64)
+        file.seek(SeekFrom::End(0)).map_err(DiskFileError::Size)
    }

    fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
@@ -37,7 +38,7 @@ impl DiskFile for QcowDiskSync {
 pub struct QcowSync {
    qcow_file: Arc<Mutex<QcowFile>>,
    eventfd: EventFd,
-    completion_list: Vec<(u64, i32)>,
+    completion_list: VecDeque<(u64, i32)>,
 }

 impl QcowSync {
@@ -46,7 +47,7 @@ impl QcowSync {
            qcow_file,
            eventfd: EventFd::new(libc::EFD_NONBLOCK)
                .expect("Failed creating EventFd for QcowSync"),
-            completion_list: Vec::new(),
+            completion_list: VecDeque::new(),
        }
    }
 }
@@ -65,7 +66,7 @@ impl AsyncIo for QcowSync {
    fn read_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        self.qcow_file.read_vectored_sync(
@@ -80,7 +81,7 @@ impl AsyncIo for QcowSync {
    fn write_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        self.qcow_file.write_vectored_sync(
@@ -97,7 +98,7 @@ impl AsyncIo for QcowSync {
            .fsync_sync(user_data, &self.eventfd, &mut self.completion_list)
    }

-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        self.completion_list.drain(..).collect()
+    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
+        self.completion_list.pop_front()
    }
 }
--- a/block_util/src/raw_async.rs
+++ b/block_util/src/raw_async.rs
@@ -23,10 +23,9 @@ impl RawFileDisk {

 impl DiskFile for RawFileDisk {
    fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self
-            .file
+        self.file
            .seek(SeekFrom::End(0))
-            .map_err(DiskFileError::Size)? as u64)
+            .map_err(DiskFileError::Size)
    }

    fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
@@ -77,12 +76,12 @@ impl AsyncIo for RawFileAsync {
    fn read_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        let (submitter, mut sq, _) = self.io_uring.split();

-        // Safe because we know the file descriptor is valid and we
+        // SAFETY: we know the file descriptor is valid and we
        // relied on vm-memory to provide the buffer address.
        let _ = unsafe {
            sq.push(
@@ -105,12 +104,12 @@ impl AsyncIo for RawFileAsync {
    fn write_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        let (submitter, mut sq, _) = self.io_uring.split();

-        // Safe because we know the file descriptor is valid and we
+        // SAFETY: we know the file descriptor is valid and we
        // relied on vm-memory to provide the buffer address.
        let _ = unsafe {
            sq.push(
@@ -134,7 +133,7 @@ impl AsyncIo for RawFileAsync {
        if let Some(user_data) = user_data {
            let (submitter, mut sq, _) = self.io_uring.split();

-            // Safe because we know the file descriptor is valid.
+            // SAFETY: we know the file descriptor is valid.
            let _ = unsafe {
                sq.push(
                    &opcode::Fsync::new(types::Fd(self.fd))
@@ -149,20 +148,17 @@ impl AsyncIo for RawFileAsync {
            sq.sync();
            submitter.submit().map_err(AsyncIoError::Fsync)?;
        } else {
+            // SAFETY: FFI call with a valid fd
            unsafe { libc::fsync(self.fd) };
        }

        Ok(())
    }

-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        let mut completion_list = Vec::new();
-
-        let cq = self.io_uring.completion();
-        for cq_entry in cq {
-            completion_list.push((cq_entry.user_data(), cq_entry.result()));
-        }
-
-        completion_list
+    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
+        self.io_uring
+            .completion()
+            .next()
+            .map(|entry| (entry.user_data(), entry.result()))
    }
 }
--- a/block_util/src/raw_sync.rs
+++ b/block_util/src/raw_sync.rs
@@ -5,6 +5,7 @@
 use crate::async_io::{
    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult, DiskTopology,
 };
+use std::collections::VecDeque;
 use std::fs::File;
 use std::io::{Seek, SeekFrom};
 use std::os::unix::io::{AsRawFd, RawFd};
@@ -22,10 +23,9 @@ impl RawFileDiskSync {

 impl DiskFile for RawFileDiskSync {
    fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self
-            .file
+        self.file
            .seek(SeekFrom::End(0))
-            .map_err(DiskFileError::Size)? as u64)
+            .map_err(DiskFileError::Size)
    }

    fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
@@ -45,7 +45,7 @@ impl DiskFile for RawFileDiskSync {
 pub struct RawFileSync {
    fd: RawFd,
    eventfd: EventFd,
-    completion_list: Vec<(u64, i32)>,
+    completion_list: VecDeque<(u64, i32)>,
 }

 impl RawFileSync {
@@ -53,7 +53,7 @@ impl RawFileSync {
        RawFileSync {
            fd,
            eventfd: EventFd::new(libc::EFD_NONBLOCK).expect("Failed creating EventFd for RawFile"),
-            completion_list: Vec::new(),
+            completion_list: VecDeque::new(),
        }
    }
 }
@@ -66,9 +66,10 @@ impl AsyncIo for RawFileSync {
    fn read_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
+        // SAFETY: FFI call with valid arguments
        let result = unsafe {
            libc::preadv(
                self.fd as libc::c_int,
@@ -81,7 +82,7 @@ impl AsyncIo for RawFileSync {
            return Err(AsyncIoError::ReadVectored(std::io::Error::last_os_error()));
        }

-        self.completion_list.push((user_data, result as i32));
+        self.completion_list.push_back((user_data, result as i32));
        self.eventfd.write(1).unwrap();

        Ok(())
@@ -90,9 +91,10 @@ impl AsyncIo for RawFileSync {
    fn write_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
+        // SAFETY: FFI call with valid arguments
        let result = unsafe {
            libc::pwritev(
                self.fd as libc::c_int,
@@ -105,27 +107,28 @@ impl AsyncIo for RawFileSync {
            return Err(AsyncIoError::WriteVectored(std::io::Error::last_os_error()));
        }

-        self.completion_list.push((user_data, result as i32));
+        self.completion_list.push_back((user_data, result as i32));
        self.eventfd.write(1).unwrap();

        Ok(())
    }

    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
+        // SAFETY: FFI call
        let result = unsafe { libc::fsync(self.fd as libc::c_int) };
        if result < 0 {
            return Err(AsyncIoError::Fsync(std::io::Error::last_os_error()));
        }

        if let Some(user_data) = user_data {
-            self.completion_list.push((user_data, result as i32));
+            self.completion_list.push_back((user_data, result));
            self.eventfd.write(1).unwrap();
        }

        Ok(())
    }

-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        self.completion_list.drain(..).collect()
+    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
+        self.completion_list.pop_front()
    }
 }
--- a/block_util/src/vhdx_sync.rs
+++ b/block_util/src/vhdx_sync.rs
@@ -4,6 +4,7 @@

 use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
 use crate::AsyncAdaptor;
+use std::collections::VecDeque;
 use std::fs::File;
 use std::sync::{Arc, Mutex, MutexGuard};
 use vhdx::vhdx::{Result as VhdxResult, Vhdx};
@@ -37,7 +38,7 @@ impl DiskFile for VhdxDiskSync {
 pub struct VhdxSync {
    vhdx_file: Arc<Mutex<Vhdx>>,
    eventfd: EventFd,
-    completion_list: Vec<(u64, i32)>,
+    completion_list: VecDeque<(u64, i32)>,
 }

 impl VhdxSync {
@@ -45,7 +46,7 @@ impl VhdxSync {
        Ok(VhdxSync {
            vhdx_file,
            eventfd: EventFd::new(libc::EFD_NONBLOCK)?,
-            completion_list: Vec::new(),
+            completion_list: VecDeque::new(),
        })
    }
 }
@@ -64,7 +65,7 @@ impl AsyncIo for VhdxSync {
    fn read_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        self.vhdx_file.read_vectored_sync(
@@ -79,7 +80,7 @@ impl AsyncIo for VhdxSync {
    fn write_vectored(
        &mut self,
        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
+        iovecs: &[libc::iovec],
        user_data: u64,
    ) -> AsyncIoResult<()> {
        self.vhdx_file.write_vectored_sync(
@@ -96,7 +97,7 @@ impl AsyncIo for VhdxSync {
            .fsync_sync(user_data, &self.eventfd, &mut self.completion_list)
    }

-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        self.completion_list.drain(..).collect()
+    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
+        self.completion_list.pop_front()
    }
 }
--- a/build.rs
+++ b/build.rs
@@ -3,13 +3,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //

-#[macro_use(crate_version)]
-extern crate clap;
-
 use std::process::Command;

 fn main() {
-    let mut version = "v".to_owned() + crate_version!();
+    let mut version = "v".to_owned() + env!("CARGO_PKG_VERSION");

    if let Ok(git_out) = Command::new("git").args(["describe", "--dirty"]).output() {
        if git_out.status.success() {
@@ -23,5 +20,5 @@ fn main() {
    // variable BUILT_VERSION, so that it can be reused from the binary.
    // Particularly, this is used from src/main.rs to display the exact
    // version.
-    println!("cargo:rustc-env=BUILT_VERSION={}", version);
+    println!("cargo:rustc-env=BUILT_VERSION={version}");
 }
--- a/devices/Cargo.toml
+++ b/devices/Cargo.toml
@@ -6,19 +6,22 @@ edition = "2021"

 [dependencies]
 acpi_tables = { path = "../acpi_tables" }
-anyhow = "1.0.65"
+anyhow = "1.0.68"
 arch = { path = "../arch" }
 bitflags = "1.3.2"
 byteorder = "1.4.3"
 hypervisor = { path = "../hypervisor" }
-libc = "0.2.133"
+libc = "0.2.139"
 log = "0.4.17"
-versionize = "0.1.6"
+phf = { version = "0.11.1", features = ["macros"] }
+thiserror = "1.0.38"
+tpm = { path = "../tpm" }
+versionize = "0.1.9"
 versionize_derive = "0.1.4"
 vm-device = { path = "../vm-device" }
-vm-memory = "0.9.0"
+vm-memory = "0.10.0"
 vm-migration = { path = "../vm-migration" }
-vmm-sys-util = "0.10.0"
+vmm-sys-util = "0.11.0"

 [target.'cfg(target_arch = "aarch64")'.dependencies]
 arch = { path = "../arch" }
--- a/devices/src/acpi.rs
+++ b/devices/src/acpi.rs
@@ -114,7 +114,7 @@ impl Aml for AcpiGedDevice {
                    &aml::ResourceTemplate::new(vec![&aml::AddressSpace::new_memory(
                        aml::AddressSpaceCachable::NotCacheable,
                        true,
-                        self.address.0 as u64,
+                        self.address.0,
                        self.address.0 + GED_DEVICE_ACPI_SIZE as u64 - 1,
                    )]),
                ),
--- a/devices/src/gic.rs
+++ b/devices/src/gic.rs
@@ -8,7 +8,7 @@ use anyhow::anyhow;
 use arch::layout;
 use hypervisor::{
    arch::aarch64::gic::{Vgic, VgicConfig},
-    CpuState,
+    CpuState, GicState,
 };
 use std::result;
 use std::sync::{Arc, Mutex};
@@ -25,6 +25,7 @@ type Result<T> = result::Result<T, Error>;
 // Reserve 32 IRQs for legacy devices.
 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 device. It wraps a hypervisor-emulated GIC device (Vgic) provided by the
@@ -39,8 +40,9 @@ pub struct Gic {

 impl Gic {
    pub fn new(
-        _vcpu_count: u8,
+        vcpu_count: u8,
        interrupt_manager: Arc<dyn InterruptManager<GroupConfig = MsiIrqGroupConfig>>,
+        vm: Arc<dyn hypervisor::Vm>,
    ) -> Result<Gic> {
        let interrupt_source_group = interrupt_manager
            .create_group(MsiIrqGroupConfig {
@@ -49,45 +51,34 @@ impl Gic {
            })
            .map_err(Error::CreateInterruptSourceGroup)?;

-        Ok(Gic {
+        let vgic = vm
+            .create_vgic(Gic::create_default_config(vcpu_count as u64))
+            .map_err(Error::CreateGic)?;
+
+        let gic = Gic {
            interrupt_source_group,
-            vgic: None,
-        })
+            vgic: Some(vgic),
+        };
+        gic.enable()?;
+
+        Ok(gic)
    }

-    /// Default config implied by arch::layout
-    pub fn create_default_config(vcpu_count: u64) -> VgicConfig {
-        let redists_size = layout::GIC_V3_REDIST_SIZE * vcpu_count;
-        let redists_addr = layout::GIC_V3_DIST_START.raw_value() - redists_size;
-        VgicConfig {
-            vcpu_count,
-            dist_addr: layout::GIC_V3_DIST_START.raw_value(),
-            dist_size: layout::GIC_V3_DIST_SIZE,
-            redists_addr,
-            redists_size,
-            msi_addr: redists_addr - layout::GIC_V3_ITS_SIZE,
-            msi_size: layout::GIC_V3_ITS_SIZE,
-            nr_irqs: layout::IRQ_NUM,
-        }
-    }
-
-    pub fn create_vgic(
+    pub fn restore_vgic(
        &mut self,
-        vm: &Arc<dyn hypervisor::Vm>,
-        config: VgicConfig,
-    ) -> Result<Arc<Mutex<dyn Vgic>>> {
-        let vgic = vm.create_vgic(config).map_err(Error::CreateGic)?;
-        self.vgic = Some(vgic.clone());
-        Ok(vgic.clone())
+        state: Option<GicState>,
+        saved_vcpu_states: &[CpuState],
+    ) -> Result<()> {
+        self.set_gicr_typers(saved_vcpu_states);
+        self.vgic
+            .clone()
+            .unwrap()
+            .lock()
+            .unwrap()
+            .set_state(&state.unwrap())
+            .map_err(Error::RestoreGic)
    }

-    pub fn set_gicr_typers(&mut self, vcpu_states: &[CpuState]) {
-        let vgic = self.vgic.as_ref().unwrap().clone();
-        vgic.lock().unwrap().set_gicr_typers(vcpu_states);
-    }
-}
-
-impl InterruptController for Gic {
    fn enable(&self) -> Result<()> {
        // Set irqfd for legacy interrupts
        self.interrupt_source_group
@@ -113,6 +104,33 @@ impl InterruptController for Gic {
        Ok(())
    }

+    /// Default config implied by arch::layout
+    pub fn create_default_config(vcpu_count: u64) -> VgicConfig {
+        let redists_size = layout::GIC_V3_REDIST_SIZE * vcpu_count;
+        let redists_addr = layout::GIC_V3_DIST_START.raw_value() - redists_size;
+        VgicConfig {
+            vcpu_count,
+            dist_addr: layout::GIC_V3_DIST_START.raw_value(),
+            dist_size: layout::GIC_V3_DIST_SIZE,
+            redists_addr,
+            redists_size,
+            msi_addr: redists_addr - layout::GIC_V3_ITS_SIZE,
+            msi_size: layout::GIC_V3_ITS_SIZE,
+            nr_irqs: layout::IRQ_NUM,
+        }
+    }
+
+    pub fn get_vgic(&mut self) -> Result<Arc<Mutex<dyn Vgic>>> {
+        Ok(self.vgic.clone().unwrap())
+    }
+
+    pub fn set_gicr_typers(&mut self, vcpu_states: &[CpuState]) {
+        let vgic = self.vgic.as_ref().unwrap().clone();
+        vgic.lock().unwrap().set_gicr_typers(vcpu_states);
+    }
+}
+
+impl InterruptController for Gic {
    // This should be called anytime an interrupt needs to be injected into the
    // running guest.
    fn service_irq(&mut self, irq: usize) -> Result<()> {
@@ -128,27 +146,15 @@ impl InterruptController for Gic {
    }
 }

-pub const GIC_V3_ITS_SNAPSHOT_ID: &str = "gic-v3-its";
 impl Snapshottable for Gic {
    fn id(&self) -> String {
-        GIC_V3_ITS_SNAPSHOT_ID.to_string()
+        GIC_SNAPSHOT_ID.to_string()
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
        let vgic = self.vgic.as_ref().unwrap().clone();
        let state = vgic.lock().unwrap().state().unwrap();
-        Snapshot::new_from_state(&self.id(), &state)
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        let vgic = self.vgic.as_ref().unwrap().clone();
-        vgic.lock()
-            .unwrap()
-            .set_state(&snapshot.to_state(&self.id())?)
-            .map_err(|e| {
-                MigratableError::Restore(anyhow!("Could not restore GICv3ITS state {:?}", e))
-            })?;
-        Ok(())
+        Snapshot::new_from_state(&state)
    }
 }

--- a/devices/src/interrupt_controller.rs
+++ b/devices/src/interrupt_controller.rs
@@ -24,8 +24,12 @@ pub enum Error {
    UpdateInterrupt(io::Error),
    /// Failed enabling the interrupt.
    EnableInterrupt(io::Error),
+    #[cfg(target_arch = "aarch64")]
    /// Failed creating GIC device.
    CreateGic(hypervisor::HypervisorVmError),
+    #[cfg(target_arch = "aarch64")]
+    /// Failed restoring GIC device.
+    RestoreGic(hypervisor::arch::aarch64::gic::Error),
 }

 type Result<T> = result::Result<T, Error>;
@@ -55,8 +59,6 @@ pub struct MsiMessage {
 // IOAPIC (X86) or GIC (Arm).
 pub trait InterruptController: Send {
    fn service_irq(&mut self, irq: usize) -> Result<()>;
-    #[cfg(target_arch = "aarch64")]
-    fn enable(&self) -> Result<()>;
    #[cfg(target_arch = "x86_64")]
    fn end_of_interrupt(&mut self, vec: u8);
    fn notifier(&self, irq: usize) -> Option<EventFd>;
--- a/devices/src/ioapic.rs
+++ b/devices/src/ioapic.rs
@@ -10,7 +10,6 @@
 // See https://pdos.csail.mit.edu/6.828/2016/readings/ia32/ioapic.pdf for a specification.

 use super::interrupt_controller::{Error, InterruptController};
-use anyhow::anyhow;
 use byteorder::{ByteOrder, LittleEndian};
 use std::result;
 use std::sync::{Arc, Barrier};
@@ -194,6 +193,7 @@ impl Ioapic {
        id: String,
        apic_address: GuestAddress,
        interrupt_manager: Arc<dyn InterruptManager<GroupConfig = MsiIrqGroupConfig>>,
+        state: Option<IoapicState>,
    ) -> Result<Ioapic> {
        let interrupt_source_group = interrupt_manager
            .create_group(MsiIrqGroupConfig {
@@ -202,17 +202,47 @@ impl Ioapic {
            })
            .map_err(Error::CreateInterruptSourceGroup)?;

+        let (id_reg, reg_sel, reg_entries, used_entries, apic_address) = if let Some(state) = &state
+        {
+            (
+                state.id_reg,
+                state.reg_sel,
+                state.reg_entries,
+                state.used_entries,
+                GuestAddress(state.apic_address),
+            )
+        } else {
+            (
+                0,
+                0,
+                [0x10000; NUM_IOAPIC_PINS],
+                [false; NUM_IOAPIC_PINS],
+                apic_address,
+            )
+        };
+
        // The IOAPIC is created with entries already masked. The guest will be
        // in charge of unmasking them if/when necessary.
-        Ok(Ioapic {
+        let ioapic = Ioapic {
            id,
-            id_reg: 0,
-            reg_sel: 0,
-            reg_entries: [0x10000; NUM_IOAPIC_PINS],
-            used_entries: [false; NUM_IOAPIC_PINS],
+            id_reg,
+            reg_sel,
+            reg_entries,
+            used_entries,
            apic_address,
            interrupt_source_group,
-        })
+        };
+
+        // When restoring the Ioapic, we must enable used entries.
+        if state.is_some() {
+            for (irq, entry) in ioapic.used_entries.iter().enumerate() {
+                if *entry {
+                    ioapic.update_entry(irq)?;
+                }
+            }
+        }
+
+        Ok(ioapic)
    }

    fn ioapic_write(&mut self, val: u32) {
@@ -299,21 +329,6 @@ impl Ioapic {
        }
    }

-    fn set_state(&mut self, state: &IoapicState) -> Result<()> {
-        self.id_reg = state.id_reg;
-        self.reg_sel = state.reg_sel;
-        self.reg_entries = state.reg_entries;
-        self.used_entries = state.used_entries;
-        self.apic_address = GuestAddress(state.apic_address);
-        for (irq, entry) in self.used_entries.iter().enumerate() {
-            if *entry {
-                self.update_entry(irq)?;
-            }
-        }
-
-        Ok(())
-    }
-
    fn update_entry(&self, irq: usize) -> Result<()> {
        let entry = self.reg_entries[irq];

@@ -423,18 +438,7 @@ impl Snapshottable for Ioapic {
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_versioned_state(&self.id, &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_versioned_state(&self.id)?)
-            .map_err(|e| {
-                MigratableError::Restore(anyhow!(
-                    "Could not restore state for {}: {:?}",
-                    self.id,
-                    e
-                ))
-            })
+        Snapshot::new_from_versioned_state(&self.state())
    }
 }

--- a/devices/src/legacy/cmos.rs
+++ b/devices/src/legacy/cmos.rs
@@ -97,7 +97,7 @@ impl BusDevice for Cmos {
                let day;
                let month;
                let year;
-                // The clock_gettime and gmtime_r calls are safe as long as the structs they are
+                // SAFETY: The clock_gettime and gmtime_r calls are safe as long as the structs they are
                // given are large enough, and neither of them fail. It is safe to zero initialize
                // the tm and timespec struct because it contains only plain data.
                let update_in_progress = unsafe {
--- a/devices/src/legacy/debug_port.rs
+++ b/devices/src/legacy/debug_port.rs
@@ -40,11 +40,11 @@ impl DebugIoPortRange {
 impl fmt::Display for DebugIoPortRange {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
-            DebugIoPortRange::Firmware => write!(f, "{}: Firmware", DEBUG_IOPORT_PREFIX),
-            DebugIoPortRange::Bootloader => write!(f, "{}: Bootloader", DEBUG_IOPORT_PREFIX),
-            DebugIoPortRange::Kernel => write!(f, "{}: Kernel", DEBUG_IOPORT_PREFIX),
-            DebugIoPortRange::Userspace => write!(f, "{}: Userspace", DEBUG_IOPORT_PREFIX),
-            DebugIoPortRange::Custom => write!(f, "{}: Custom", DEBUG_IOPORT_PREFIX),
+            DebugIoPortRange::Firmware => write!(f, "{DEBUG_IOPORT_PREFIX}: Firmware"),
+            DebugIoPortRange::Bootloader => write!(f, "{DEBUG_IOPORT_PREFIX}: Bootloader"),
+            DebugIoPortRange::Kernel => write!(f, "{DEBUG_IOPORT_PREFIX}: Kernel"),
+            DebugIoPortRange::Userspace => write!(f, "{DEBUG_IOPORT_PREFIX}: Userspace"),
+            DebugIoPortRange::Custom => write!(f, "{DEBUG_IOPORT_PREFIX}: Custom"),
        }
    }
 }
--- a/devices/src/legacy/gpio_pl061.rs
+++ b/devices/src/legacy/gpio_pl061.rs
@@ -51,13 +51,13 @@ pub enum Error {
 impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
-            Error::BadWriteOffset(offset) => write!(f, "Bad Write Offset: {}", offset),
+            Error::BadWriteOffset(offset) => write!(f, "Bad Write Offset: {offset}"),
            Error::GpioInterruptDisabled => write!(f, "GPIO interrupt disabled by guest driver.",),
            Error::GpioInterruptFailure(ref e) => {
-                write!(f, "Could not trigger GPIO interrupt: {}.", e)
+                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 triggerd: {key}.")
            }
        }
    }
@@ -106,18 +106,39 @@ impl VersionMapped for GpioState {}

 impl Gpio {
    /// Constructs an PL061 GPIO device.
-    pub fn new(id: String, interrupt: Arc<dyn InterruptSourceGroup>) -> Self {
+    pub fn new(
+        id: String,
+        interrupt: Arc<dyn InterruptSourceGroup>,
+        state: Option<GpioState>,
+    ) -> Self {
+        let (data, old_in_data, dir, isense, ibe, iev, im, istate, afsel) =
+            if let Some(state) = state {
+                (
+                    state.data,
+                    state.old_in_data,
+                    state.dir,
+                    state.isense,
+                    state.ibe,
+                    state.iev,
+                    state.im,
+                    state.istate,
+                    state.afsel,
+                )
+            } else {
+                (0, 0, 0, 0, 0, 0, 0, 0, 0)
+            };
+
        Self {
            id,
-            data: 0,
-            old_in_data: 0,
-            dir: 0,
-            isense: 0,
-            ibe: 0,
-            iev: 0,
-            im: 0,
-            istate: 0,
-            afsel: 0,
+            data,
+            old_in_data,
+            dir,
+            isense,
+            ibe,
+            iev,
+            im,
+            istate,
+            afsel,
            interrupt,
        }
    }
@@ -136,24 +157,12 @@ impl Gpio {
        }
    }

-    fn set_state(&mut self, state: &GpioState) {
-        self.data = state.data;
-        self.old_in_data = state.old_in_data;
-        self.dir = state.dir;
-        self.isense = state.isense;
-        self.ibe = state.ibe;
-        self.iev = state.iev;
-        self.im = state.im;
-        self.istate = state.istate;
-        self.afsel = state.afsel;
-    }
-
    fn pl061_internal_update(&mut self) {
        // FIXME:
        //  Missing Output Interrupt Emulation.

        // Input Edging Interrupt Emulation.
-        let changed = ((self.old_in_data ^ self.data) & !self.dir) as u32;
+        let changed = (self.old_in_data ^ self.data) & !self.dir;
        if changed > 0 {
            self.old_in_data = self.data;
            for i in 0..N_GPIOS {
@@ -319,12 +328,7 @@ impl Snapshottable for Gpio {
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_versioned_state(&self.id, &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_versioned_state(&self.id)?);
-        Ok(())
+        Snapshot::new_from_versioned_state(&self.state())
    }
 }

@@ -378,6 +382,7 @@ mod tests {
        let mut gpio = Gpio::new(
            String::from(GPIO_NAME),
            Arc::new(TestInterrupt::new(intr_evt.try_clone().unwrap())),
+            None,
        );
        let mut data = [0; 4];

--- a/devices/src/legacy/rtc_pl031.rs
+++ b/devices/src/legacy/rtc_pl031.rs
@@ -48,8 +48,8 @@ pub enum Error {
 impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
-            Error::BadWriteOffset(offset) => write!(f, "Bad Write Offset: {}", offset),
-            Error::InterruptFailure(e) => write!(f, "Failed to trigger interrupt: {}", e),
+            Error::BadWriteOffset(offset) => write!(f, "Bad Write Offset: {offset}"),
+            Error::InterruptFailure(e) => write!(f, "Failed to trigger interrupt: {e}"),
        }
    }
 }
@@ -61,12 +61,10 @@ pub enum ClockType {
    /// Equivalent to `libc::CLOCK_MONOTONIC`.
    Monotonic,
    /// Equivalent to `libc::CLOCK_REALTIME`.
-    #[allow(dead_code)]
    Real,
    /// Equivalent to `libc::CLOCK_PROCESS_CPUTIME_ID`.
    ProcessCpu,
    /// Equivalent to `libc::CLOCK_THREAD_CPUTIME_ID`.
-    #[allow(dead_code)]
    ThreadCpu,
 }

@@ -101,7 +99,7 @@ pub struct LocalTime {

 impl LocalTime {
    /// Returns the [LocalTime](struct.LocalTime.html) structure for the calling moment.
-    #[allow(dead_code)]
+    #[cfg(test)]
    pub fn now() -> LocalTime {
        let mut timespec = libc::timespec {
            tv_sec: 0,
@@ -121,7 +119,7 @@ impl LocalTime {
            tm_zone: std::ptr::null(),
        };

-        // Safe because the parameters are valid.
+        // SAFETY: the parameters are valid.
        unsafe {
            libc::clock_gettime(libc::CLOCK_REALTIME, &mut timespec);
            libc::localtime_r(&timespec.tv_sec, &mut tm);
@@ -173,22 +171,6 @@ impl Default for TimestampUs {
    }
 }

-/// Returns a timestamp in nanoseconds from a monotonic clock.
-///
-/// Uses `_rdstc` on `x86_64` and [`get_time`](fn.get_time.html) on other architectures.
-#[allow(dead_code)]
-pub fn timestamp_cycles() -> u64 {
-    #[cfg(target_arch = "x86_64")]
-    // Safe because there's nothing that can go wrong with this call.
-    unsafe {
-        std::arch::x86_64::_rdtsc() as u64
-    }
-    #[cfg(not(target_arch = "x86_64"))]
-    {
-        get_time(ClockType::Monotonic)
-    }
-}
-
 /// Returns a timestamp in nanoseconds based on the provided clock type.
 ///
 /// # Arguments
@@ -199,7 +181,7 @@ pub fn get_time(clock_type: ClockType) -> u64 {
        tv_sec: 0,
        tv_nsec: 0,
    };
-    // Safe because the parameters are valid.
+    // SAFETY: the parameters are valid.
    unsafe { libc::clock_gettime(clock_type.into(), &mut time_struct) };
    seconds_to_nanoseconds(time_struct.tv_sec).unwrap() as u64 + (time_struct.tv_nsec as u64)
 }
@@ -525,7 +507,6 @@ mod tests {
        ($test_name: ident, $write_fn_name: ident, $read_fn_name: ident, $is_be: expr, $data_type: ty) => {
            #[test]
            fn $test_name() {
-                #[allow(overflowing_literals)]
                let test_cases = [
                    (
                        0x0123_4567_89AB_CDEF as u64,
--- a/devices/src/legacy/serial.rs
+++ b/devices/src/legacy/serial.rs
@@ -63,7 +63,6 @@ pub struct Serial {
    id: String,
    interrupt_enable: u8,
    interrupt_identification: u8,
-    interrupt: Arc<dyn InterruptSourceGroup>,
    line_control: u8,
    line_status: u8,
    modem_control: u8,
@@ -71,6 +70,7 @@ pub struct Serial {
    scratch: u8,
    baud_divisor: u16,
    in_buffer: VecDeque<u8>,
+    interrupt: Arc<dyn InterruptSourceGroup>,
    out: Option<Box<dyn io::Write + Send>>,
 }

@@ -93,19 +93,56 @@ impl Serial {
        id: String,
        interrupt: Arc<dyn InterruptSourceGroup>,
        out: Option<Box<dyn io::Write + Send>>,
+        state: Option<SerialState>,
    ) -> Serial {
+        let (
+            interrupt_enable,
+            interrupt_identification,
+            line_control,
+            line_status,
+            modem_control,
+            modem_status,
+            scratch,
+            baud_divisor,
+            in_buffer,
+        ) = if let Some(state) = state {
+            (
+                state.interrupt_enable,
+                state.interrupt_identification,
+                state.line_control,
+                state.line_status,
+                state.modem_control,
+                state.modem_status,
+                state.scratch,
+                state.baud_divisor,
+                state.in_buffer.into(),
+            )
+        } else {
+            (
+                0,
+                DEFAULT_INTERRUPT_IDENTIFICATION,
+                DEFAULT_LINE_CONTROL,
+                DEFAULT_LINE_STATUS,
+                DEFAULT_MODEM_CONTROL,
+                DEFAULT_MODEM_STATUS,
+                0,
+                DEFAULT_BAUD_DIVISOR,
+                VecDeque::new(),
+            )
+        };
+
        Serial {
            id,
-            interrupt_enable: 0,
-            interrupt_identification: DEFAULT_INTERRUPT_IDENTIFICATION,
+            interrupt_enable,
+            interrupt_identification,
+            line_control,
+            line_status,
+            modem_control,
+            modem_status,
+            scratch,
+            baud_divisor,
+            in_buffer,
            interrupt,
-            line_control: DEFAULT_LINE_CONTROL,
-            line_status: DEFAULT_LINE_STATUS,
-            modem_control: DEFAULT_MODEM_CONTROL,
-            modem_status: DEFAULT_MODEM_STATUS,
-            scratch: 0,
-            baud_divisor: DEFAULT_BAUD_DIVISOR,
-            in_buffer: VecDeque::new(),
            out,
        }
    }
@@ -115,13 +152,18 @@ impl Serial {
        id: String,
        interrupt: Arc<dyn InterruptSourceGroup>,
        out: Box<dyn io::Write + Send>,
+        state: Option<SerialState>,
    ) -> Serial {
-        Self::new(id, interrupt, Some(out))
+        Self::new(id, interrupt, Some(out), state)
    }

    /// Constructs a Serial port with no connected output.
-    pub fn new_sink(id: String, interrupt: Arc<dyn InterruptSourceGroup>) -> Serial {
-        Self::new(id, interrupt, None)
+    pub fn new_sink(
+        id: String,
+        interrupt: Arc<dyn InterruptSourceGroup>,
+        state: Option<SerialState>,
+    ) -> Serial {
+        Self::new(id, interrupt, None, state)
    }

    pub fn set_out(&mut self, out: Box<dyn io::Write + Send>) {
@@ -199,7 +241,7 @@ impl Serial {
    }

    fn handle_write(&mut self, offset: u8, v: u8) -> Result<()> {
-        match offset as u8 {
+        match offset {
            DLAB_LOW if self.is_dlab_set() => {
                self.baud_divisor = (self.baud_divisor & 0xff00) | u16::from(v)
            }
@@ -242,18 +284,6 @@ impl Serial {
            in_buffer: self.in_buffer.clone().into(),
        }
    }
-
-    fn set_state(&mut self, state: &SerialState) {
-        self.interrupt_enable = state.interrupt_enable;
-        self.interrupt_identification = state.interrupt_identification;
-        self.line_control = state.line_control;
-        self.line_status = state.line_status;
-        self.modem_control = state.modem_control;
-        self.modem_status = state.modem_status;
-        self.scratch = state.scratch;
-        self.baud_divisor = state.baud_divisor;
-        self.in_buffer = state.in_buffer.clone().into();
-    }
 }

 impl BusDevice for Serial {
@@ -304,12 +334,7 @@ impl Snapshottable for Serial {
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_versioned_state(&self.id, &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_versioned_state(&self.id)?);
-        Ok(())
+        Snapshot::new_from_versioned_state(&self.state())
    }
 }

@@ -384,6 +409,7 @@ mod tests {
            String::from(SERIAL_NAME),
            Arc::new(TestInterrupt::new(intr_evt.try_clone().unwrap())),
            Box::new(serial_out.clone()),
+            None,
        );

        serial.write(0, DATA as u64, &[b'x', b'y']);
@@ -404,6 +430,7 @@ mod tests {
            String::from(SERIAL_NAME),
            Arc::new(TestInterrupt::new(intr_evt.try_clone().unwrap())),
            Box::new(serial_out),
+            None,
        );

        // write 1 to the interrupt event fd, so that read doesn't block in case the event fd
@@ -440,6 +467,7 @@ mod tests {
        let mut serial = Serial::new_sink(
            String::from(SERIAL_NAME),
            Arc::new(TestInterrupt::new(intr_evt.try_clone().unwrap())),
+            None,
        );

        // write 1 to the interrupt event fd, so that read doesn't block in case the event fd
@@ -462,6 +490,7 @@ mod tests {
        let mut serial = Serial::new_sink(
            String::from(SERIAL_NAME),
            Arc::new(TestInterrupt::new(intr_evt.try_clone().unwrap())),
+            None,
        );

        serial.write(0, LCR as u64, &[LCR_DLAB_BIT]);
@@ -483,6 +512,7 @@ mod tests {
        let mut serial = Serial::new_sink(
            String::from(SERIAL_NAME),
            Arc::new(TestInterrupt::new(intr_evt.try_clone().unwrap())),
+            None,
        );

        serial.write(0, MCR as u64, &[MCR_LOOP_BIT]);
@@ -509,6 +539,7 @@ mod tests {
        let mut serial = Serial::new_sink(
            String::from(SERIAL_NAME),
            Arc::new(TestInterrupt::new(intr_evt.try_clone().unwrap())),
+            None,
        );

        serial.write(0, SCR as u64, &[0x12]);
--- a/devices/src/legacy/uart_pl011.rs
+++ b/devices/src/legacy/uart_pl011.rs
@@ -60,11 +60,11 @@ pub enum Error {
 impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
-            Error::BadWriteOffset(offset) => write!(f, "pl011_write: Bad Write Offset: {}", offset),
+            Error::BadWriteOffset(offset) => write!(f, "pl011_write: Bad Write Offset: {offset}"),
            Error::DmaNotImplemented => write!(f, "pl011: DMA not implemented."),
-            Error::InterruptFailure(e) => write!(f, "Failed to trigger interrupt: {}", e),
-            Error::WriteAllFailure(e) => write!(f, "Failed to write: {}", e),
-            Error::FlushFailure(e) => write!(f, "Failed to flush: {}", e),
+            Error::InterruptFailure(e) => write!(f, "Failed to trigger interrupt: {e}"),
+            Error::WriteAllFailure(e) => write!(f, "Failed to write: {e}"),
+            Error::FlushFailure(e) => write!(f, "Failed to flush: {e}"),
        }
    }
 }
@@ -122,24 +122,79 @@ impl Pl011 {
        irq: Arc<dyn InterruptSourceGroup>,
        out: Option<Box<dyn io::Write + Send>>,
        timestamp: Instant,
+        state: Option<Pl011State>,
    ) -> Self {
+        let (
+            flags,
+            lcr,
+            rsr,
+            cr,
+            dmacr,
+            debug,
+            int_enabled,
+            int_level,
+            read_fifo,
+            ilpr,
+            ibrd,
+            fbrd,
+            ifl,
+            read_count,
+            read_trigger,
+        ) = if let Some(state) = state {
+            (
+                state.flags,
+                state.lcr,
+                state.rsr,
+                state.cr,
+                state.dmacr,
+                state.debug,
+                state.int_enabled,
+                state.int_level,
+                state.read_fifo.into(),
+                state.ilpr,
+                state.ibrd,
+                state.fbrd,
+                state.ifl,
+                state.read_count,
+                state.read_trigger,
+            )
+        } else {
+            (
+                0x90,
+                0,
+                0,
+                0x300,
+                0,
+                0,
+                0,
+                0,
+                VecDeque::new(),
+                0,
+                0,
+                0,
+                0x12,
+                0,
+                1,
+            )
+        };
+
        Self {
            id,
-            flags: 0x90u32,
-            lcr: 0u32,
-            rsr: 0u32,
-            cr: 0x300u32,
-            dmacr: 0u32,
-            debug: 0u32,
-            int_enabled: 0u32,
-            int_level: 0u32,
-            read_fifo: VecDeque::new(),
-            ilpr: 0u32,
-            ibrd: 0u32,
-            fbrd: 0u32,
-            ifl: 0x12u32,
-            read_count: 0u32,
-            read_trigger: 1u32,
+            flags,
+            lcr,
+            rsr,
+            cr,
+            dmacr,
+            debug,
+            int_enabled,
+            int_level,
+            read_fifo,
+            ilpr,
+            ibrd,
+            fbrd,
+            ifl,
+            read_count,
+            read_trigger,
            irq,
            out,
            timestamp,
@@ -170,24 +225,6 @@ impl Pl011 {
        }
    }

-    fn set_state(&mut self, state: &Pl011State) {
-        self.flags = state.flags;
-        self.lcr = state.lcr;
-        self.rsr = state.rsr;
-        self.cr = state.cr;
-        self.dmacr = state.dmacr;
-        self.debug = state.debug;
-        self.int_enabled = state.int_enabled;
-        self.int_level = state.int_level;
-        self.read_fifo = state.read_fifo.clone().into();
-        self.ilpr = state.ilpr;
-        self.ibrd = state.ibrd;
-        self.fbrd = state.fbrd;
-        self.ifl = state.ifl;
-        self.read_count = state.read_count;
-        self.read_trigger = state.read_trigger;
-    }
-
    /// Queues raw bytes for the guest to read and signals the interrupt
    pub fn queue_input_bytes(&mut self, c: &[u8]) -> vmm_sys_util::errno::Result<()> {
        self.read_fifo.extend(c);
@@ -417,12 +454,7 @@ impl Snapshottable for Pl011 {
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_versioned_state(&self.id, &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_versioned_state(&self.id)?);
-        Ok(())
+        Snapshot::new_from_versioned_state(&self.state())
    }
 }

@@ -498,12 +530,13 @@ mod tests {
            Arc::new(TestInterrupt::new(intr_evt.try_clone().unwrap())),
            Some(Box::new(pl011_out.clone())),
            Instant::now(),
+            None,
        );

-        pl011.write(0, UARTDR as u64, &[b'x', b'y']);
-        pl011.write(0, UARTDR as u64, &[b'a']);
-        pl011.write(0, UARTDR as u64, &[b'b']);
-        pl011.write(0, UARTDR as u64, &[b'c']);
+        pl011.write(0, UARTDR, &[b'x', b'y']);
+        pl011.write(0, UARTDR, &[b'a']);
+        pl011.write(0, UARTDR, &[b'b']);
+        pl011.write(0, UARTDR, &[b'c']);
        assert_eq!(
            pl011_out.buf.lock().unwrap().as_slice(),
            &[b'x', b'a', b'b', b'c']
@@ -519,6 +552,7 @@ mod tests {
            Arc::new(TestInterrupt::new(intr_evt.try_clone().unwrap())),
            Some(Box::new(pl011_out)),
            Instant::now(),
+            None,
        );

        // write 1 to the interrupt event fd, so that read doesn't block in case the event fd
@@ -529,11 +563,11 @@ mod tests {
        assert_eq!(intr_evt.read().unwrap(), 2);

        let mut data = [0u8];
-        pl011.read(0, UARTDR as u64, &mut data);
+        pl011.read(0, UARTDR, &mut data);
        assert_eq!(data[0], b'a');
-        pl011.read(0, UARTDR as u64, &mut data);
+        pl011.read(0, UARTDR, &mut data);
        assert_eq!(data[0], b'b');
-        pl011.read(0, UARTDR as u64, &mut data);
+        pl011.read(0, UARTDR, &mut data);
        assert_eq!(data[0], b'c');
    }
 }
--- a/devices/src/lib.rs
+++ b/devices/src/lib.rs
@@ -19,6 +19,7 @@ pub mod interrupt_controller;
 #[cfg(target_arch = "x86_64")]
 pub mod ioapic;
 pub mod legacy;
+pub mod tpm;

 pub use self::acpi::{AcpiGedDevice, AcpiPmTimerDevice, AcpiShutdownDevice};

@@ -32,11 +33,9 @@ bitflags! {
    }
 }

-#[allow(unused_macros)]
 #[cfg(target_arch = "aarch64")]
 macro_rules! generate_read_fn {
    ($fn_name: ident, $data_type: ty, $byte_type: ty, $type_size: expr, $endian_type: ident) => {
-        #[allow(dead_code)]
        pub fn $fn_name(input: &[$byte_type]) -> $data_type {
            assert!($type_size == std::mem::size_of::<$data_type>());
            let mut array = [0u8; $type_size];
@@ -48,11 +47,9 @@ macro_rules! generate_read_fn {
    };
 }

-#[allow(unused_macros)]
 #[cfg(target_arch = "aarch64")]
 macro_rules! generate_write_fn {
    ($fn_name: ident, $data_type: ty, $byte_type: ty, $endian_type: ident) => {
-        #[allow(dead_code)]
        pub fn $fn_name(buf: &mut [$byte_type], n: $data_type) {
            for (byte, read) in buf
                .iter_mut()
--- a/devices/src/tpm.rs
+++ b/devices/src/tpm.rs
@@ -0,0 +1,467 @@
+// Copyright © 2022, Microsoft Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+use anyhow::anyhow;
+#[cfg(target_arch = "aarch64")]
+use arch::aarch64::layout::{TPM_SIZE, TPM_START};
+#[cfg(target_arch = "x86_64")]
+use arch::x86_64::layout::{TPM_SIZE, TPM_START};
+use phf::phf_map;
+use std::cmp;
+use std::sync::{Arc, Barrier};
+use thiserror::Error;
+use tpm::emulator::{BackendCmd, Emulator};
+use tpm::TPM_CRB_BUFFER_MAX;
+use tpm::TPM_SUCCESS;
+use vm_device::BusDevice;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("Emulator doesn't implement min required capabilities: {0}")]
+    CheckCaps(#[source] anyhow::Error),
+    #[error("Failed to initialize tpm: {0}")]
+    Init(#[source] anyhow::Error),
+    #[error("Failed to deliver tpm Command: {0}")]
+    DeliverRequest(#[source] anyhow::Error),
+}
+type Result<T> = anyhow::Result<T, Error>;
+
+/* crb 32-bit registers */
+const CRB_LOC_STATE: u32 = 0x0;
+//Register Fields
+// Field => (start, length)
+// start: lowest bit in the bit field numbered from 0
+// length: length of the bit field
+const CRB_LOC_STATE_FIELDS: phf::Map<&str, [u32; 2]> = phf_map! {
+    "tpmEstablished" => [0, 1],
+    "locAssigned" => [1,1],
+    "activeLocality"=> [2, 3],
+    "reserved" => [5, 2],
+    "tpmRegValidSts" => [7, 1]
+};
+const CRB_LOC_CTRL: u32 = 0x08;
+const CRB_LOC_CTRL_REQUEST_ACCESS: u32 = 1 << 0;
+const CRB_LOC_CTRL_RELINQUISH: u32 = 1 << 1;
+const CRB_LOC_CTRL_RESET_ESTABLISHMENT_BIT: u32 = 1 << 3;
+const CRB_LOC_STS: u32 = 0x0C;
+const CRB_LOC_STS_FIELDS: phf::Map<&str, [u32; 2]> = phf_map! {
+    "Granted" => [0, 1],
+    "beenSeized" => [1,1]
+};
+const CRB_INTF_ID: u32 = 0x30;
+const CRB_INTF_ID_FIELDS: phf::Map<&str, [u32; 2]> = phf_map! {
+    "InterfaceType" => [0, 4],
+    "InterfaceVersion" => [4, 4],
+    "CapLocality" =>  [8, 1],
+    "CapCRBIdleBypass" => [9, 1],
+    "Reserved1" => [10, 1],
+    "CapDataXferSizeSupport" => [11, 2],
+    "CapFIFO" =>  [13, 1],
+    "CapCRB" => [14, 1],
+    "CapIFRes" => [15, 2],
+    "InterfaceSelector" => [17, 2],
+    "IntfSelLock" =>  [19, 1],
+    "Reserved2" => [20, 4],
+    "RID" => [24, 8]
+};
+const CRB_INTF_ID2: u32 = 0x34;
+const CRB_INTF_ID2_FIELDS: phf::Map<&str, [u32; 2]> = phf_map! {
+    "VID" => [0, 16],
+    "DID" => [16, 16]
+};
+const CRB_CTRL_REQ: u32 = 0x40;
+const CRB_CTRL_REQ_CMD_READY: u32 = 1 << 0;
+const CRB_CTRL_REQ_GO_IDLE: u32 = 1 << 1;
+const CRB_CTRL_STS: u32 = 0x44;
+const CRB_CTRL_STS_FIELDS: phf::Map<&str, [u32; 2]> = phf_map! {
+    "tpmSts" => [0, 1],
+    "tpmIdle" => [1, 1]
+};
+const CRB_CTRL_CANCEL: u32 = 0x48;
+const CRB_CANCEL_INVOKE: u32 = 1 << 0;
+const CRB_CTRL_START: u32 = 0x4C;
+const CRB_START_INVOKE: u32 = 1 << 0;
+const CRB_CTRL_CMD_LADDR: u32 = 0x5C;
+const CRB_CTRL_CMD_HADDR: u32 = 0x60;
+const CRB_CTRL_RSP_SIZE: u32 = 0x64;
+const CRB_CTRL_RSP_ADDR: u32 = 0x68;
+const CRB_DATA_BUFFER: u32 = 0x80;
+
+const TPM_CRB_NO_LOCALITY: u32 = 0xff;
+
+const TPM_CRB_ADDR_BASE: u32 = TPM_START.0 as u32;
+const TPM_CRB_ADDR_SIZE: usize = TPM_SIZE as usize;
+
+const TPM_CRB_R_MAX: u32 = CRB_DATA_BUFFER;
+
+// CRB Protocol details
+const CRB_INTF_TYPE_CRB_ACTIVE: u32 = 0b1;
+const CRB_INTF_VERSION_CRB: u32 = 0b1;
+const CRB_INTF_CAP_LOCALITY_0_ONLY: u32 = 0b0;
+const CRB_INTF_CAP_IDLE_FAST: u32 = 0b0;
+const CRB_INTF_CAP_XFER_SIZE_64: u32 = 0b11;
+const CRB_INTF_CAP_FIFO_NOT_SUPPORTED: u32 = 0b0;
+const CRB_INTF_CAP_CRB_SUPPORTED: u32 = 0b1;
+const CRB_INTF_IF_SELECTOR_CRB: u32 = 0b1;
+const PCI_VENDOR_ID_IBM: u32 = 0x1014;
+const CRB_CTRL_CMD_SIZE_REG: u32 = 0x58;
+const CRB_CTRL_CMD_SIZE: usize = TPM_CRB_ADDR_SIZE - CRB_DATA_BUFFER as usize;
+
+fn get_fields_map(reg: u32) -> phf::Map<&'static str, [u32; 2]> {
+    match reg {
+        CRB_LOC_STATE => CRB_LOC_STATE_FIELDS,
+        CRB_LOC_STS => CRB_LOC_STS_FIELDS,
+        CRB_INTF_ID => CRB_INTF_ID_FIELDS,
+        CRB_INTF_ID2 => CRB_INTF_ID2_FIELDS,
+        CRB_CTRL_STS => CRB_CTRL_STS_FIELDS,
+        _ => {
+            panic!("Fields in '{reg:?}' register were accessed which are Invalid");
+        }
+    }
+}
+
+/// Set a particular field in a Register
+fn set_reg_field(regs: &mut [u32; TPM_CRB_R_MAX as usize], reg: u32, field: &str, value: u32) {
+    let reg_fields = get_fields_map(reg);
+    if reg_fields.contains_key(field) {
+        let start = reg_fields.get(field).unwrap()[0];
+        let len = reg_fields.get(field).unwrap()[1];
+        let mask = (!(0_u32) >> (32 - len)) << start;
+        regs[reg as usize] = (regs[reg as usize] & !mask) | ((value << start) & mask);
+    } else {
+        error!(
+            "Failed to tpm Register. {:?} is not a valid field in Reg {:#X}",
+            field, reg
+        )
+    }
+}
+
+/// Get the value of a particular field in a Register
+fn get_reg_field(regs: &[u32; TPM_CRB_R_MAX as usize], reg: u32, field: &str) -> u32 {
+    let reg_fields = get_fields_map(reg);
+    if reg_fields.contains_key(field) {
+        let start = reg_fields.get(field).unwrap()[0];
+        let len = reg_fields.get(field).unwrap()[1];
+        let mask = (!(0_u32) >> (32 - len)) << start;
+        (regs[reg as usize] & mask) >> start
+    } else {
+        // TODO: Sensible return value if fields do not exist
+        0x0
+    }
+}
+
+fn locality_from_addr(addr: u32) -> u8 {
+    (addr >> 12) as u8
+}
+
+pub struct Tpm {
+    emulator: Emulator,
+    cmd: Option<BackendCmd>,
+    regs: [u32; TPM_CRB_R_MAX as usize],
+    backend_buff_size: usize,
+    data_buff: [u8; TPM_CRB_BUFFER_MAX],
+    data_buff_len: usize,
+}
+
+impl Tpm {
+    pub fn new(path: String) -> Result<Self> {
+        let emulator = Emulator::new(path)
+            .map_err(|e| Error::Init(anyhow!("Failed while initializing tpm Emulator: {:?}", e)))?;
+        let mut tpm = Tpm {
+            emulator,
+            cmd: None,
+            regs: [0; TPM_CRB_R_MAX as usize],
+            backend_buff_size: TPM_CRB_BUFFER_MAX,
+            data_buff: [0; TPM_CRB_BUFFER_MAX],
+            data_buff_len: 0,
+        };
+        tpm.reset()?;
+        Ok(tpm)
+    }
+
+    fn get_active_locality(&mut self) -> u32 {
+        if get_reg_field(&self.regs, CRB_LOC_STATE, "locAssigned") == 0 {
+            return TPM_CRB_NO_LOCALITY;
+        }
+        get_reg_field(&self.regs, CRB_LOC_STATE, "activeLocality")
+    }
+
+    fn request_completed(&mut self, result: isize) {
+        self.regs[CRB_CTRL_START as usize] = !CRB_START_INVOKE;
+        if result != 0 {
+            set_reg_field(&mut self.regs, CRB_CTRL_STS, "tpmSts", 1);
+        }
+    }
+
+    fn reset(&mut self) -> Result<()> {
+        let cur_buff_size = self.emulator.get_buffer_size().unwrap();
+        self.regs = [0; TPM_CRB_R_MAX as usize];
+        set_reg_field(&mut self.regs, CRB_LOC_STATE, "tpmRegValidSts", 1);
+        set_reg_field(&mut self.regs, CRB_CTRL_STS, "tpmIdle", 1);
+        set_reg_field(
+            &mut self.regs,
+            CRB_INTF_ID,
+            "InterfaceType",
+            CRB_INTF_TYPE_CRB_ACTIVE,
+        );
+        set_reg_field(
+            &mut self.regs,
+            CRB_INTF_ID,
+            "InterfaceVersion",
+            CRB_INTF_VERSION_CRB,
+        );
+        set_reg_field(
+            &mut self.regs,
+            CRB_INTF_ID,
+            "CapLocality",
+            CRB_INTF_CAP_LOCALITY_0_ONLY,
+        );
+        set_reg_field(
+            &mut self.regs,
+            CRB_INTF_ID,
+            "CapCRBIdleBypass",
+            CRB_INTF_CAP_IDLE_FAST,
+        );
+        set_reg_field(
+            &mut self.regs,
+            CRB_INTF_ID,
+            "CapDataXferSizeSupport",
+            CRB_INTF_CAP_XFER_SIZE_64,
+        );
+        set_reg_field(
+            &mut self.regs,
+            CRB_INTF_ID,
+            "CapFIFO",
+            CRB_INTF_CAP_FIFO_NOT_SUPPORTED,
+        );
+        set_reg_field(
+            &mut self.regs,
+            CRB_INTF_ID,
+            "CapCRB",
+            CRB_INTF_CAP_CRB_SUPPORTED,
+        );
+        set_reg_field(
+            &mut self.regs,
+            CRB_INTF_ID,
+            "InterfaceSelector",
+            CRB_INTF_IF_SELECTOR_CRB,
+        );
+        set_reg_field(&mut self.regs, CRB_INTF_ID, "RID", 0b0000);
+        set_reg_field(&mut self.regs, CRB_INTF_ID2, "VID", PCI_VENDOR_ID_IBM);
+
+        self.regs[CRB_CTRL_CMD_SIZE_REG as usize] = CRB_CTRL_CMD_SIZE as u32;
+        self.regs[CRB_CTRL_CMD_LADDR as usize] = TPM_CRB_ADDR_BASE + CRB_DATA_BUFFER;
+        self.regs[CRB_CTRL_RSP_SIZE as usize] = CRB_CTRL_CMD_SIZE as u32;
+        self.regs[CRB_CTRL_RSP_ADDR as usize] = TPM_CRB_ADDR_BASE + CRB_DATA_BUFFER;
+
+        self.backend_buff_size = cmp::min(cur_buff_size, TPM_CRB_BUFFER_MAX);
+
+        if let Err(e) = self.emulator.startup_tpm(self.backend_buff_size) {
+            return Err(Error::Init(anyhow!(
+                "Failed while running Startup TPM. Error: {:?}",
+                e
+            )));
+        }
+        Ok(())
+    }
+}
+
+//impl BusDevice for TPM
+impl BusDevice for Tpm {
+    fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
+        let mut offset: u32 = offset as u32;
+        let read_len: usize = data.len();
+
+        if offset >= CRB_DATA_BUFFER
+            && (offset + read_len as u32) < (CRB_DATA_BUFFER + self.data_buff.len() as u32)
+        {
+            // Read from Data Buffer
+            let start: usize = (offset as usize) - (CRB_DATA_BUFFER as usize);
+            let end: usize = start + read_len;
+            data[..].clone_from_slice(&self.data_buff[start..end]);
+        } else {
+            offset &= 0xff;
+            let mut val = self.regs[offset as usize];
+
+            if offset == CRB_LOC_STATE && !self.emulator.get_established_flag() {
+                val |= 0x1;
+            }
+
+            if data.len() <= 4 {
+                data.clone_from_slice(val.to_ne_bytes()[0..read_len].as_ref());
+            } else {
+                error!(
+                    "Invalid tpm read: offset {:#X}, data length {:?}",
+                    offset,
+                    data.len()
+                );
+            }
+        }
+        debug!(
+            "MMIO Read: offset {:#X} len {:?} val = {:02X?}  ",
+            offset,
+            data.len(),
+            data
+        );
+    }
+
+    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
+        debug!(
+            "MMIO Write: offset {:#X} len {:?} input data {:02X?}",
+            offset,
+            data.len(),
+            data
+        );
+        let mut offset: u32 = offset as u32;
+        if offset < CRB_DATA_BUFFER {
+            offset &= 0xff;
+        }
+        let locality = locality_from_addr(offset) as u32;
+        let write_len = data.len();
+
+        if offset >= CRB_DATA_BUFFER
+            && (offset + write_len as u32) < (CRB_DATA_BUFFER + self.data_buff.len() as u32)
+        {
+            let start: usize = (offset as usize) - (CRB_DATA_BUFFER as usize);
+            if start == 0 {
+                // If filling data_buff at index 0, reset length to 0
+                self.data_buff_len = 0;
+                self.data_buff.fill(0);
+            }
+            let end: usize = start + data.len();
+            self.data_buff[start..end].clone_from_slice(data);
+            self.data_buff_len += data.len();
+        } else {
+            // Ctrl Commands that take more than 4 bytes as input are not yet supported
+            // CTRL_RSP_ADDR usually gets 8 byte write request. Last 4 bytes are zeros.
+            if write_len > 4 && offset != CRB_CTRL_RSP_ADDR {
+                error!(
+                    "Invalid tpm write: offset {:#X}, data length {}",
+                    offset,
+                    data.len()
+                );
+                return None;
+            }
+
+            let mut input: [u8; 4] = [0; 4];
+            input.copy_from_slice(&data[0..4]);
+            let v = u32::from_le_bytes(input);
+
+            match offset {
+                CRB_CTRL_CMD_SIZE_REG => {
+                    self.regs[CRB_CTRL_CMD_SIZE_REG as usize] = v;
+                }
+                CRB_CTRL_CMD_LADDR => {
+                    self.regs[CRB_CTRL_CMD_LADDR as usize] = v;
+                }
+                CRB_CTRL_CMD_HADDR => {
+                    self.regs[CRB_CTRL_CMD_HADDR as usize] = v;
+                }
+                CRB_CTRL_RSP_SIZE => {
+                    self.regs[CRB_CTRL_RSP_SIZE as usize] = v;
+                }
+                CRB_CTRL_RSP_ADDR => {
+                    self.regs[CRB_CTRL_RSP_ADDR as usize] = v;
+                }
+                CRB_CTRL_REQ => match v {
+                    CRB_CTRL_REQ_CMD_READY => {
+                        set_reg_field(&mut self.regs, CRB_CTRL_STS, "tpmIdle", 0);
+                    }
+                    CRB_CTRL_REQ_GO_IDLE => {
+                        set_reg_field(&mut self.regs, CRB_CTRL_STS, "tpmIdle", 1);
+                    }
+                    _ => {
+                        error!("Invalid value passed to CRTL_REQ register");
+                        return None;
+                    }
+                },
+                CRB_CTRL_CANCEL => {
+                    if v == CRB_CANCEL_INVOKE
+                        && (self.regs[CRB_CTRL_START as usize] & CRB_START_INVOKE != 0)
+                    {
+                        if let Err(e) = self.emulator.cancel_cmd() {
+                            error!("Failed to run cancel command. Error: {:?}", e);
+                        }
+                    }
+                }
+                CRB_CTRL_START => {
+                    if v == CRB_START_INVOKE
+                        && ((self.regs[CRB_CTRL_START as usize] & CRB_START_INVOKE) == 0)
+                        && self.get_active_locality() == locality
+                    {
+                        self.regs[CRB_CTRL_START as usize] |= CRB_START_INVOKE;
+
+                        self.cmd = Some(BackendCmd {
+                            locality: locality as u8,
+                            input: self.data_buff[0..self.data_buff_len].to_vec(),
+                            input_len: cmp::min(self.data_buff_len, TPM_CRB_BUFFER_MAX),
+                            output: self.data_buff.to_vec(),
+                            output_len: TPM_CRB_BUFFER_MAX,
+                            selftest_done: false,
+                        });
+
+                        let mut cmd = self.cmd.as_ref().unwrap().clone();
+                        let output = self.emulator.deliver_request(&mut cmd).map_err(|e| {
+                            Error::DeliverRequest(anyhow!(
+                                "Failed to deliver tpm request. Error :{:?}",
+                                e
+                            ))
+                        });
+                        //TODO: drop the copy here
+                        self.data_buff.fill(0);
+                        self.data_buff.clone_from_slice(output.unwrap().as_slice());
+
+                        self.request_completed(TPM_SUCCESS as isize);
+                    }
+                }
+                CRB_LOC_CTRL => {
+                    warn!(
+                        "CRB_LOC_CTRL locality to write = {:?} val = {:?}",
+                        locality, v
+                    );
+                    match v {
+                        CRB_LOC_CTRL_RESET_ESTABLISHMENT_BIT => {}
+                        CRB_LOC_CTRL_RELINQUISH => {
+                            set_reg_field(&mut self.regs, CRB_LOC_STATE, "locAssigned", 0);
+                            set_reg_field(&mut self.regs, CRB_LOC_STS, "Granted", 0);
+                        }
+                        CRB_LOC_CTRL_REQUEST_ACCESS => {
+                            set_reg_field(&mut self.regs, CRB_LOC_STS, "Granted", 1);
+                            set_reg_field(&mut self.regs, CRB_LOC_STS, "beenSeized", 0);
+                            set_reg_field(&mut self.regs, CRB_LOC_STATE, "locAssigned", 1);
+                        }
+                        _ => {
+                            error!("Invalid value to write in CRB_LOC_CTRL {:#X} ", v);
+                        }
+                    }
+                }
+                _ => {
+                    error!(
+                        "Invalid tpm write: offset {:#X}, data length {:?}",
+                        offset,
+                        data.len()
+                    );
+                }
+            }
+        }
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_set_get_reg_field() {
+        let mut regs: [u32; TPM_CRB_R_MAX as usize] = [0; TPM_CRB_R_MAX as usize];
+        set_reg_field(&mut regs, CRB_INTF_ID, "RID", 0xAC);
+        assert_eq!(
+            get_reg_field(&regs, CRB_INTF_ID, "RID"),
+            0xAC,
+            concat!("Test: ", stringify!(set_get_reg_field))
+        );
+    }
+}
--- a/docs/arm64.md
+++ b/docs/arm64.md
@@ -1,152 +0,0 @@
-# How to build and test Cloud Hypervisor on AArch64
-
-This document introduces how to build and test Cloud Hypervisor on AArch64.
-Currently, Cloud Hypervisor supports 2 methods of booting on AArch64: UEFI
-booting and direct-kernel booting. The document covers both methods.
-
-All the steps are based on Ubuntu. We use the Ubuntu cloud image for guest VM
-disk.
-
-## Hardware requirements
-
- AArch64 servers (recommended) or development boards equipped with the GICv3
-interrupt controller.
-
- On development boards that have constrained RAM resources, if the creation of
-a VM consumes a large portion of the free memory on the host, it may be required
-to enable swap. For example, this was required on a board with 3 GB of RAM
-booting a 2 GB VM at a point in time when 2.8 GB were free. Without enabling
-swap the `cloud-hypervisor` process was terminated by the OOM killer. In this
-situation memory was allocated for the virtual machine using memfd while the
-page cache was filled, leading to a situation where the kernel could not even
-drop caches. Making a small section of swap available (observably, 1 to 15 MB),
-this situation can be resolved and the resulting memory footprint of
-`cloud-hypervisor` is as expected.
-
-## Getting started
-
-We create a folder to build and run Cloud Hypervisor at `$HOME/cloud-hypervisor`
-
-```shell
-$ export CLOUDH=$HOME/cloud-hypervisor
-$ mkdir $CLOUDH
-```
-
-## Prerequisites
-
-You need to install some prerequisite packages to build and test Cloud Hypervisor.
-
-### Tools
-
-```bash
-# Install rust tool chain
-$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-# Install the tools used for building guest kernel, EDK2 and converting guest disk
-$ sudo apt-get update
-$ sudo apt-get install git build-essential m4 bison flex uuid-dev qemu-utils
-```
-
-### Building Cloud Hypervisor
-
-```bash
-$ pushd $CLOUDH
-$ git clone https://github.com/cloud-hypervisor/cloud-hypervisor.git
-$ cd cloud-hypervisor
-$ cargo build
-$ popd
-```
-
-### Disk image
-
-Download the Ubuntu cloud image and convert the image type.
-
-```bash
-$ pushd $CLOUDH
-$ wget https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-arm64.img
-$ qemu-img convert -p -f qcow2 -O raw focal-server-cloudimg-arm64.img focal-server-cloudimg-arm64.raw
-$ popd
-```
-
-## UEFI booting
-
-This part introduces how to build EDK2 firmware and boot Cloud Hypervisor with it.
-
-### Building EDK2
-
-```bash
-$ pushd $CLOUDH
-
-# Clone source code repos
-$ git clone --depth 1 https://github.com/tianocore/edk2.git -b master
-$ cd edk2
-$ git submodule update --init
-$ cd ..
-$ git clone --depth 1 https://github.com/tianocore/edk2-platforms.git -b master
-$ git clone --depth 1 https://github.com/acpica/acpica.git -b master
-
-# Build tools
-$ export PACKAGES_PATH="$PWD/edk2:$PWD/edk2-platforms"
-$ export IASL_PREFIX="$PWD/acpica/generate/unix/bin/"
-$ make -C acpica
-$ cd edk2/
-$ . edksetup.sh
-$ cd ..
-$ make -C edk2/BaseTools
-
-# Build EDK2
-$ build -a AARCH64 -t GCC5 -p ArmVirtPkg/ArmVirtCloudHv.dsc -b RELEASE
-
-$ popd
-```
-
-If the build goes well, the EDK2 binary is available at
-`edk2/Build/ArmVirtCloudHv-AARCH64/RELEASE_GCC5/FV/CLOUDHV_EFI.fd`.
-
-### Booting the guest VM
-
-```bash
-$ pushd $CLOUDH
-$ sudo RUST_BACKTRACE=1 $CLOUDH/cloud-hypervisor/target/debug/cloud-hypervisor \
-           --api-socket /tmp/cloud-hypervisor.sock \
-           --kernel $CLOUDH/edk2/Build/ArmVirtCloudHv-AARCH64/RELEASE_GCC5/FV/CLOUDHV_EFI.fd \
-           --disk path=$CLOUDH/focal-server-cloudimg-arm64.raw \
-           --cpus boot=4 \
-           --memory size=4096M \
-           --net tap=,mac=12:34:56:78:90:01,ip=192.168.1.1,mask=255.255.255.0 \
-           --serial tty \
-           --console off
-$ popd
-```
-
-## Direct-kernel booting
-
-Alternativelly, you can build your own kernel for guest VM. This way, UEFI is
-not involved and ACPI cannot be enabled.
-
-### Building kernel
-
-```bash
-$ pushd $CLOUDH
-$ git clone --depth 1 "https://github.com/cloud-hypervisor/linux.git" -b ch-5.12
-$ cd linux
-$ cp $CLOUDH/cloud-hypervisor/resources/linux-config-aarch64 .config
-$ make -j `nproc`
-$ popd
-```
-
-### Booting the guest VM
-
-```bash
-$ pushd $CLOUDH
-$ sudo $CLOUDH/cloud-hypervisor/target/debug/cloud-hypervisor \
-           --api-socket /tmp/cloud-hypervisor.sock \
-           --kernel $CLOUDH/linux/arch/arm64/boot/Image \
-           --disk path=focal-server-cloudimg-arm64.raw \
-           --cmdline "keep_bootcon console=ttyAMA0 reboot=k panic=1 root=/dev/vda1 rw" \
-           --cpus boot=4 \
-           --memory size=4096M \
-           --net tap=,mac=12:34:56:78:90:01,ip=192.168.1.1,mask=255.255.255.0 \
-           --serial tty \
-           --console off
-$ popd
-```
--- a/docs/building.md
+++ b/docs/building.md
@@ -0,0 +1,86 @@
+- [Building Cloud Hypervisor](#building-cloud-hypervisor)
+  - [Preparation](#preparation)
+  - [Install prerequisites](#install-prerequisites)
+  - [Clone and build](#clone-and-build)
+    - [Containerized builds and tests](#containerized-builds-and-tests)
+
+# Building Cloud Hypervisor
+
+We recommend users use the pre-built binaries that are mentioned in the README.md file in the root of the repository. Building from source is only necessary if you wish to make modifications.
+
+## Preparation
+
+We create a folder to build and run `cloud-hypervisor` at `$HOME/cloud-hypervisor`
+
+```shell
+$ export CLOUDH=$HOME/cloud-hypervisor
+$ mkdir $CLOUDH
+```
+
+## Install prerequisites
+
+You need to install some prerequisite packages in order to build and test Cloud
+Hypervisor. Here, all the steps are based on Ubuntu, for other Linux
+distributions please replace the package manager and package name.
+
+```shell
+# Install basic packages needed. For a package list targeting for more
+# functionalities for example the test, please see resources/Dockerfile.
+$ sudo apt-get update
+$ sudo apt install git build-essential m4 bison flex uuid-dev qemu-utils
+# Install rust tool chain
+$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+# If you want to build statically linked binary please add musl target
+$ rustup target add x86_64-unknown-linux-musl  # x86-64
+$ rustup target add aarch64-unknown-linux-musl # AArch64
+```
+
+## Clone and build
+
+First you need to clone and build the Cloud Hypervisor repository:
+
+```shell
+$ pushd $CLOUDH
+$ git clone https://github.com/cloud-hypervisor/cloud-hypervisor.git
+$ cd cloud-hypervisor
+$ cargo build --release
+
+# We need to give the cloud-hypervisor binary the NET_ADMIN capabilities for it to set TAP interfaces up on the host.
+$ sudo setcap cap_net_admin+ep ./target/release/cloud-hypervisor
+
+# If you want to build statically linked binary
+$ cargo build --release --target=x86_64-unknown-linux-musl --all  # x86-64
+$ cargo build --release --target=aarch64-unknown-linux-musl --all # AArch64
+$ popd
+```
+
+This will build a `cloud-hypervisor` binary under
+`$CLOUDH/cloud-hypervisor/target/release/cloud-hypervisor`.
+
+### Containerized builds and tests
+
+If you want to build and test Cloud Hypervisor without having to install all the
+required dependencies (The rust toolchain, cargo tools, etc), you can also use
+Cloud Hypervisor's development script: `dev_cli.sh`. Please note that upon its
+first invocation, this script will pull a fairly large container image.
+
+For example, to build the Cloud Hypervisor release binary:
+
+```shell
+$ pushd $CLOUDH
+$ cd cloud-hypervisor
+$ ./scripts/dev_cli.sh build --release
+```
+
+With `dev_cli.sh`, one can also run the Cloud Hypervisor CI locally. This can be
+very convenient for debugging CI errors without having to fully rely on the
+Cloud Hypervisor CI infrastructure.
+
+For example, to run the Cloud Hypervisor unit tests:
+
+```shell
+$ ./scripts/dev_cli.sh tests --unit
+```
+
+Run the `./scripts/dev_cli.sh --help` command to view all the supported
+development script commands and their related options.
--- a/docs/custom-image.md
+++ b/docs/custom-image.md
@@ -88,7 +88,7 @@ Ubuntu distributions.

 ```bash
 apt update
-apt install fio iperf iperf3 socat stress
+apt install fio iperf iperf3 socat stress cpuid
 ```

 ### Remove counterproductive packages
@@ -158,3 +158,172 @@ as we might need to update the direct kernel boot command line, replacing
 `/dev/vda1` with the appropriate partition number.

 Update all references to the previous image name to the new one.
+
+## NVIDIA image for VFIO baremetal CI
+
+Here we are going to describe how to create a cloud image that contains the
+necessary NVIDIA drivers for our VFIO baremetal CI.
+
+### Download base image
+
+We usually start from one of the custom cloud image we have previously created
+but we can use a stock cloud image as well.
+
+```bash
+wget https://cloud-hypervisor.azureedge.net/jammy-server-cloudimg-amd64-custom-20221118-1.raw
+mv jammy-server-cloudimg-amd64-custom-20221118-1.raw jammy-server-cloudimg-amd64-nvidia.raw
+```
+
+### Extend the image size
+
+The NVIDIA drivers consume lots of space, which is why we must resize the image
+before we proceed any further.
+
+```bash
+qemu-img resize jammy-server-cloudimg-amd64-nvidia.raw 5G
+```
+
+### Resize the partition
+
+We use `parted` for fixing the GPT after the image was resized, as well as for
+resizing the `Linux` partition.
+
+```bash
+sudo parted jammy-server-cloudimg-amd64-nvidia.raw
+
+(parted) print
+Warning: Not all of the space available to jammy-server-cloudimg-amd64-nvidia.raw
+appears to be used, you can fix the GPT to use all of the space (an extra 5873664
+blocks) or continue with the current setting?
+Fix/Ignore? Fix
+Model:  (file)
+Disk jammy-server-cloudimg-amd64-nvidia.raw: 5369MB
+Sector size (logical/physical): 512B/512B
+Partition Table: gpt
+Disk Flags:
+
+Number  Start   End     Size    File system  Name  Flags
+14      1049kB  5243kB  4194kB                     bios_grub
+15      5243kB  116MB   111MB   fat32              boot, esp
+ 1      116MB   2361MB  2245MB  ext4
+
+(parted) resizepart 1 5369MB
+(parted) print
+Model:  (file)
+Disk jammy-server-cloudimg-amd64-nvidia.raw: 5369MB
+Sector size (logical/physical): 512B/512B
+Partition Table: gpt
+Disk Flags:
+
+Number  Start   End     Size    File system  Name  Flags
+14      1049kB  5243kB  4194kB                     bios_grub
+15      5243kB  116MB   111MB   fat32              boot, esp
+ 1      116MB   5369MB  5252MB  ext4
+
+(parted) quit
+```
+
+### Create a macvtap interface
+
+Rely on the following [documentation](docs/macvtap-bridge.md) to set up a
+macvtap interface to provide your VM with proper connectivity.
+
+### Boot the image
+
+It is particularly important to boot with a `cloud-init` disk attached to the
+VM as it will automatically resize the Linux `ext4` filesystem based on the
+partition that we have previously resized.
+
+```bash
+./cloud-hypervisor \
+	--kernel hypervisor-fw  \
+	--disk path=focal-server-cloudimg-amd64-nvidia.raw path=/tmp/ubuntu-cloudinit.img \
+	--cpus boot=4 \
+	--memory size=4G \
+	--net fd=3,mac=$mac 3<>$"$tapdevice"
+```
+	
+### Bring up connectivity
+
+If your network has a DHCP server, run the following from your VM
+
+```bash
+sudo dhclient
+```
+
+But if that's not the case, let's give it an IP manually (the IP addresses
+depend on your actual network) and set the DNS server IP address as well.
+
+```bash
+sudo ip addr add 192.168.2.10/24 dev ens4
+sudo ip link set up dev ens4
+sudo ip route add default via 192.168.2.1
+sudo resolvectl dns ens4 8.8.8.8
+```
+
+#### Check connectivity and update the image
+
+```bash
+sudo apt update
+sudo apt upgrade
+```
+
+### Install NVIDIA drivers
+
+The following steps and commands are referenced from the
+[NVIDIA official documentation](https://docs.nvidia.com/datacenter/tesla/tesla-installation-notes/index.html#ubuntu-lts)
+about Tesla compute cards.
+
+```bash
+distribution=$(. /etc/os-release;echo $ID$VERSION_ID | sed -e 's/\.//g')
+wget https://developer.download.nvidia.com/compute/cuda/repos/$distribution/x86_64/cuda-keyring_1.0-1_all.deb
+sudo dpkg -i cuda-keyring_1.0-1_all.deb
+sudo apt-key del 7fa2af80
+sudo apt update
+sudo apt -y install cuda-drivers
+```
+
+### Check the `nvidia-smi` tool
+
+Quickly validate that you can find and run the `nvidia-smi` command from your
+VM. At this point it should fail given no NVIDIA card has been passed through
+the VM, therefore no NVIDIA driver is loaded.
+
+### Workaround LA57 reboot issue
+
+Add `reboot=a` to `GRUB_CMDLINE_LINUX` in `etc/default/grub` so that the VM
+will be booted with the ACPI reboot type. This resolves a reboot issue when
+running on 5-level paging systems.
+
+```bash
+sudo vim /etc/default/grub
+sudo update-grub
+sudo reboot
+```
+
+### Remove previous logins
+
+Since our integration tests rely on past logins to count the number of reboots,
+we must ensure to clear the list.
+
+```bash
+>/var/log/lastlog
+>/var/log/wtmp
+>/var/log/btmp
+```
+
+### Clear history
+
+```
+history -c
+rm /home/cloud/.bash_history
+```
+
+### Reset cloud-init
+
+This is mandatory as we want `cloud-init` provisioning to work again when a new
+VM will be booted with this image.
+
+```
+sudo cloud-init clean
+```
--- a/docs/memory.md
+++ b/docs/memory.md
@@ -20,12 +20,13 @@ struct MemoryConfig {
    hugepages: bool,
    hugepage_size: Option<u64>,
    prefault: bool,
+    thp: bool
    zones: Option<Vec<MemoryZoneConfig>>,
 }
 ```

 ```
--memory <memory>	Memory parameters "size=<guest_memory_size>,mergeable=on|off,shared=on|off,hugepages=on|off,hugepage_size=<hugepage_size>,hotplug_method=acpi|virtio-mem,hotplug_size=<hotpluggable_memory_size>,hotplugged_size=<hotplugged_memory_size>,prefault=on|off" [default: size=512M]
+--memory <memory>	Memory parameters "size=<guest_memory_size>,mergeable=on|off,shared=on|off,hugepages=on|off,hugepage_size=<hugepage_size>,hotplug_method=acpi|virtio-mem,hotplug_size=<hotpluggable_memory_size>,hotplugged_size=<hotplugged_memory_size>,prefault=on|off,thp=on|off" [default: size=512M,thp=on]
 ```

 ### `size`
@@ -117,6 +118,9 @@ needing access to the guest RAM content.
 By default this option is turned off, which results in performing `mmap(2)`
 with `MAP_PRIVATE` flag.

+If `hugepages=on` then the value of this field is ignored as huge pages always
+requires `MAP_SHARED`.
+
 _Example_

 ```
@@ -140,6 +144,9 @@ behaviour, e.g. error with `ReadKernelImage` is common. If there is a strange
 error with `hugepages` enabled, just disable it or check whether there are enough
 huge pages.

+If `hugepages=on` then the value of `shared` is ignored as huge pages always
+requires `MAP_SHARED`.
+
 By default this option is turned off.

 _Example_
@@ -171,6 +178,25 @@ _Example_
 --memory size=1G,prefault=on
 ```

+### `thp`
+
+Specifies if private anonymous memory for the guest (i.e. `shared=off` and no
+backing file) should be labelled `MADV_HUGEPAGE` with `madvise(2)` indicating
+to the kernel that this memory may be backed with huge pages transparently.
+
+The use of transparent huge pages can improve the performance of the guest as
+there will fewer virtualisation related page faults. Unlike using
+`hugepages=on` a specific number of huge pages do not need to be allocated by
+the kernel.
+
+By default this option is turned on.
+
+_Example_
+
+```
+--memory size=1G,thp=on
+```
+
 ## Advanced Parameters

 `MemoryZoneConfig` or what is known as `--memory-zone` from the CLI perspective
@@ -271,6 +297,9 @@ other processes running on the host. One can use this option when running
 vhost-user devices as part of the VM device model, as they will be driven
 by standalone daemons needing access to the guest RAM content.

+If `hugepages=on` then the value of this field is ignored as huge pages always
+requires `MAP_SHARED`.
+
 By default this option is turned off, which result in performing `mmap(2)`
 with `MAP_PRIVATE` flag.

@@ -298,6 +327,9 @@ behaviour, e.g. error with `ReadKernelImage` is common. If there is a strange
 error with `hugepages` enabled, just disable it or check whether there are enough
 huge pages.

+If `hugepages=on` then the value of `shared` is ignored as huge pages always
+requires `MAP_SHARED`.
+
 By default this option is turned off.

 _Example_
--- a/docs/seccomp.md
+++ b/docs/seccomp.md
@@ -64,5 +64,5 @@ it will log every system call issued by the process. It is important to use
 `-f` option in order to trace each and every thread belonging to the process.

 ```
-strace -f ./cloud-hypervisor ...
+strace --decode-pids=comm -f ./cloud-hypervisor ...
 ```
--- a/docs/tpm.md
+++ b/docs/tpm.md
@@ -0,0 +1,122 @@
+# TPM
+Tpm in Cloud-Hypervisor is emulated using `swtpm` as the backend. [swtpm](https://github.com/stefanberger/swtpm) is the link to swtpm project.
+
+Current implementation only supports TPM `2.0` version. At the moment only
+`CRB Interface` is implemented. This interface is described in
+[TCG PC Client Platform TPM Profile Specification for TPM 2.0, Revision 01.05 v4](https://trustedcomputinggroup.org/wp-content/uploads/PC-Client-Specific-Platform-TPM-Profile-for-TPM-2p0-v1p05p_r14_pub.pdf).
+
+
+## Usage
+`--tpm`, an optional argument, can be passed to enable tpm device.
+This argument takes an UNIX domain Socket as a `socket` value.
+
+_Example_
+
+An Example invocation with `--tpm` argument:
+
+```
+ ./cloud-hypervisor/target/release/cloud-hypervisor \
+	--kernel ./hypervisor-fw \
+	--disk path=focal-server-cloudimg-amd64.raw \
+	--cpus boot=4 \
+	--memory size=1024M \
+	--net "tap=,mac=,ip=,mask=" \
+	--tpm socket="/var/run/swtpm.socket"
+```
+
+## swtpm
+Before invoking cloud-hypervisor with `--tpm` argument, a `swtpm`
+process should be started to listen at the input socket. Below is an
+example invocation of swtpm process.
+
+```
+swtpm socket --tpmstate dir=/var/run/swtpm \
+	--ctrl type=unixio,path="/var/run/swtpm.socket" \
+	--flags startup-clear \
+	--tpm2
+```
+
+## Guest
+After starting a guest with the above commands, ensure below listed modules are
+loaded in the guest:
+
+```
+# lsmod | grep tpm
+tpm_crb                20480  0
+tpm                    81920  1 tpm_crb
+```
+
+Below is the IO Memory map configured in the guest:
+
+```
+# cat /proc/iomem  | grep MSFT
+fed40000-fed40fff : MSFT0101:00
+  fed40000-fed40fff : MSFT0101:00
+```
+Below are the devices created in the guest:
+
+```
+# ls /dev/tpm*
+/dev/tpm0  /dev/tpmrm0
+```
+
+
+## Testing
+
+Inside the guest install `tpm2-tools` package. This package provides some
+commands to run against TPM that supports 2.0 version.
+
+_Examples_
+```
+// Run Self Test
+# tpm2_selftest -f
+# echo $?
+0
+
+
+# echo "hello" > input.txt
+// this command generates hash of the input file using all the algos supported by TPM
+
+# tpm2_pcrevent input.txt
+sha1: f572d396fae9206628714fb2ce00f72e94f2258f
+sha256: 5891b5b522d5df086d0ff0b110fbd9d21bb4fc7163af34d08286a2e846f6be03
+sha384: 1d0f284efe3edea4b9ca3bd514fa134b17eae361ccc7a1eefeff801b9bd6604e01f21f6bf249ef030599f0c
+218f2ba8c
+sha512: e7c22b994c59d9cf2b48e549b1e24666636045930d3da7c1acb299d1c3b7f931f94aae41edda2c2b207a36e
+10f8bcb8d45223e54878f5b316e7ce3b6bc019629
+
+// verify one of the hashes
+# sha256sum input.txt
+5891b5b522d5df086d0ff0b110fbd9d21bb4fc7163af34d08286a2e846f6be03  input.txt
+```
+
+### Bundled Functional Test
+
+Build time dependencies for `tpm2-tss` are captured in [INSTALL](https://github.com/tpm2-software/tpm2-tss/blob/master/INSTALL.md).
+
+```
+# git clone https://github.com/tpm2-software/tpm2-tss.git
+# cd tpm2-tss
+# ./configure --enable-integration --with-devicetests="mandatory,optional" --with-device=/dev/tpm0
+# sudo make check-device
+.
+.
+.
+.
+============================================================================
+Testsuite summary for tpm2-tss 3.2.0-74-ge03617d9
+============================================================================
+# TOTAL: 154
+# PASS:  88
+# SKIP:  7
+# XFAIL: 0
+# FAIL:  59
+# XPASS: 0
+# ERROR: 0
+============================================================================
+See ./test-suite.log
+Please report to https://github.com/tpm2-software/tpm2-tss/issues
+============================================================================
+```
+The same set of failures are noticed while running these tests on `Qemu` with
+its TPM implementation.
--- a/docs/uefi.md
+++ b/docs/uefi.md
@@ -2,17 +2,19 @@

 Cloud Hypervisor supports UEFI boot through the utilization of the EDK II based UEFI firmware. 

-## Building UEFI Firmware
+## Building UEFI Firmware for x86-64

 To avoid any unnecessary issues, it is recommended to use Ubuntu 18.04 and its default toolset. Any other compatible Linux distribution is otherwise suitable, however it is suggested to use a temporary Docker container with Ubuntu 18.04 for a quick build on an existing Linux machine.

+Please note that nasm-2.15 is required for the build to succeed.
+
 The commands below will compile an OVMF firmware suitable for Cloud Hypervisor.

 ```shell
 sudo apt-get update
 sudo apt-get install uuid-dev nasm iasl build-essential python3-distutils git

-git clone https://github.com/cloud-hypervisor/edk2 -b ch
+git clone https://github.com/tianocore/edk2
 cd edk2
 . edksetup.sh
 git submodule update --init
@@ -27,11 +29,40 @@ build

 After the successful build, the resulting firmware binaries are available under `Build/CloudHvX64/DEBUG_GCC5/FV` underneath the edk2 checkout.

+## Building UEFI Firmware for AArch64
+
+```shell
+# On an AArch64 machine:
+$ sudo apt-get update
+$ sudo apt-get install uuid-dev nasm iasl build-essential python3-distutils git
+$ git clone --depth 1 https://github.com/tianocore/edk2.git -b master
+$ cd edk2
+$ git submodule update --init
+$ cd ..
+$ git clone --depth 1 https://github.com/tianocore/edk2-platforms.git -b master
+$ git clone --depth 1 https://github.com/acpica/acpica.git -b master
+
+# Build tools
+$ export PACKAGES_PATH="$PWD/edk2:$PWD/edk2-platforms"
+$ export IASL_PREFIX="$PWD/acpica/generate/unix/bin/"
+$ make -C acpica
+$ cd edk2/
+$ . edksetup.sh
+$ cd ..
+$ make -C edk2/BaseTools
+
+# Build EDK2
+$ build -a AARCH64 -t GCC5 -p ArmVirtPkg/ArmVirtCloudHv.dsc -b RELEASE
+```
+
+If the build goes well, the EDK2 binary is available at
+`edk2/Build/ArmVirtCloudHv-AARCH64/RELEASE_GCC5/FV/CLOUDHV_EFI.fd`.
+
 ## Using OVMF Binaries

 Any UEFI capable image can be booted using the Cloud Hypervisor specific firmware. Windows guests under Cloud Hypervisor only support UEFI boot, therefore OVMF is mandatory there.

-To make Cloud Hypervisor use UEFI boot, pass the `CLOUDHV.fd` file path as an argument to the `--kernel` option. The firmware file will be opened in read only mode.
+To make Cloud Hypervisor use UEFI boot, pass the `CLOUDHV.fd` (for x86-64) / `CLOUDHV_EFI.fd` (for AArch64) file path as an argument to the `--kernel` option. The firmware file will be opened in read only mode.

 # Links

--- a/docs/windows.md
+++ b/docs/windows.md
@@ -131,7 +131,7 @@ See also the [links](#Links) section for a more extended SAC documentation.

 ## Network

-This section illustrates the Windows specific corner points for the VM network configuration. For the extended networking guide, including bridging for multiple VMs, follow [networking.md](networking.md).
+This section illustrates the Windows specific aspects of the VM network configuration.

 ### Basic Networking

--- a/event_monitor/Cargo.toml
+++ b/event_monitor/Cargo.toml
@@ -5,6 +5,6 @@ authors = ["The Cloud Hypervisor Authors"]
 edition = "2021"

 [dependencies]
-libc = "0.2.133"
-serde = { version = "1.0.145", features = ["rc", "derive"] }
-serde_json = "1.0.85"
+libc = "0.2.139"
+serde = { version = "1.0.151", features = ["rc", "derive"] }
+serde_json = "1.0.89"
--- a/event_monitor/src/lib.rs
+++ b/event_monitor/src/lib.rs
@@ -16,8 +16,10 @@ 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;
@@ -26,6 +28,7 @@ pub fn set_monitor(file: File) -> Result<(), std::io::Error> {
    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()));
    };
@@ -41,6 +44,7 @@ struct Event<'a> {
 }

 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(),
--- a/fuzz/Cargo.lock
+++ b/fuzz/Cargo.lock
@@ -11,9 +11,9 @@ dependencies = [

 [[package]]
 name = "anyhow"
-version = "1.0.65"
+version = "1.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98161a4e3e2184da77bb14f02184cdd111e83bbbcc9979dfee3c44b9a85f5602"
+checksum = "2cb2f989d18dd141ab8ae82f64d1a8cdd37e0840f73a406896cf5e99502fab61"

 [[package]]
 name = "api_client"
@@ -24,9 +24,9 @@ dependencies = [

 [[package]]
 name = "arbitrary"
-version = "1.1.6"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f44124848854b941eafdb34f05b3bcf59472f643c7e151eba7c2b69daa469ed5"
+checksum = "29d47fbf90d5149a107494b15a7dc8d69b351be2db3bb9691740e88ec17fd880"

 [[package]]
 name = "arc-swap"
@@ -56,23 +56,6 @@ dependencies = [
 "vmm-sys-util",
 ]

-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "autocfg"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
 [[package]]
 name = "bincode"
 version = "1.3.3"
@@ -96,6 +79,7 @@ dependencies = [
 "libc",
 "log",
 "qcow",
+ "smallvec",
 "thiserror",
 "versionize",
 "versionize_derive",
@@ -115,9 +99,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"

 [[package]]
 name = "cc"
-version = "1.0.73"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+checksum = "a20104e2335ce8a659d6dd92a51a767a0c062599c73b343fd152cb401e828c3d"
 dependencies = [
 "jobserver",
 ]
@@ -130,33 +114,31 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "clap"
-version = "3.2.22"
+version = "4.0.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86447ad904c7fb335a790c9d7fe3d0d971dc523b8ccd1561a520de9a85302750"
+checksum = "a7db700bc935f9e43e88d00b0850dae18a63773cfbec6d8e070fccf7fef89a39"
 dependencies = [
- "atty",
 "bitflags",
 "clap_lex",
- "indexmap",
+ "is-terminal",
 "once_cell",
 "strsim",
 "termcolor",
 "terminal_size",
- "textwrap",
 ]

 [[package]]
 name = "clap_lex"
-version = "0.2.4"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"
 dependencies = [
 "os_str_bytes",
 ]

 [[package]]
 name = "cloud-hypervisor"
-version = "26.0.0"
+version = "28.0.0"
 dependencies = [
 "anyhow",
 "api_client",
@@ -171,6 +153,7 @@ dependencies = [
 "serde_json",
 "signal-hook",
 "thiserror",
+ "tpm",
 "tracer",
 "vm-memory",
 "vmm",
@@ -187,7 +170,9 @@ dependencies = [
 "epoll",
 "libc",
 "libfuzzer-sys",
+ "linux-loader",
 "micro_http",
+ "net_util",
 "once_cell",
 "qcow",
 "seccompiler",
@@ -218,9 +203,9 @@ checksum = "55626594feae15d266d52440b26ff77de0e22230cf0c113abe619084c1ddc910"

 [[package]]
 name = "darling"
-version = "0.14.1"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4529658bdda7fd6769b8614be250cdcfc3aeb0ee72fe66f9e41e5e5eb73eac02"
+checksum = "b0dd3cd20dc6b5a876612a6e5accfe7f3dd883db6d07acfbf14c128f61550dfa"
 dependencies = [
 "darling_core",
 "darling_macro",
@@ -228,9 +213,9 @@ dependencies = [

 [[package]]
 name = "darling_core"
-version = "0.14.1"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "649c91bc01e8b1eac09fb91e8dbc7d517684ca6be8ebc75bb9cafc894f9fdb6f"
+checksum = "a784d2ccaf7c98501746bf0be29b2022ba41fd62a2e622af997a03e9f972859f"
 dependencies = [
 "fnv",
 "ident_case",
@@ -242,9 +227,9 @@ dependencies = [

 [[package]]
 name = "darling_macro"
-version = "0.14.1"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddfc69c5bfcbd2fc09a0f38451d2daf0e372e367986a83906d1b0dbc88134fb5"
+checksum = "7618812407e9402654622dd402b0a89dff9ba93badd6540781526117b92aab7e"
 dependencies = [
 "darling_core",
 "quote",
@@ -263,6 +248,9 @@ dependencies = [
 "hypervisor",
 "libc",
 "log",
+ "phf",
+ "thiserror",
+ "tpm",
 "versionize",
 "versionize_derive",
 "vm-device",
@@ -325,26 +313,20 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

 [[package]]
 name = "getrandom"
-version = "0.2.7"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6"
+checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
 "cfg-if",
 "libc",
 "wasi",
 ]

-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
 [[package]]
 name = "hermit-abi"
-version = "0.1.20"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7a30908dbce072eca83216eab939d2290080e00ca71611b96a09e5cdce5f3fa"
+checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
 dependencies = [
 "libc",
 ]
@@ -370,12 +352,11 @@ dependencies = [

 [[package]]
 name = "iced-x86"
-version = "1.17.0"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "158f5204401d08f91d19176112146d75e99b3cf745092e268fa7be33e09adcec"
+checksum = "1dd04b950d75b3498320253b17fb92745b2cc79ead8814aede2f7c1bab858bec"
 dependencies = [
 "lazy_static",
- "static_assertions",
 ]

 [[package]]
@@ -385,36 +366,42 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

 [[package]]
-name = "indexmap"
-version = "1.9.1"
+name = "io-lifetimes"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
+checksum = "46112a93252b123d31a119a8d1a1ac19deac4fac6e0e8b0df58f0d4e5870e63c"
 dependencies = [
- "autocfg",
- "hashbrown",
+ "libc",
+ "windows-sys",
 ]

-[[package]]
-name = "io-lifetimes"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ea37f355c05dde75b84bba2d767906ad522e97cd9e2eef2be7a4ab7fb442c06"
-
 [[package]]
 name = "io-uring"
-version = "0.5.6"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a645fd8e7048c2f54050f7d0d4de8f624ada437e043bc7d72609bd08d70120b"
+checksum = "c9ddf18110cedc09617f5a965bdb51adb0c0fb02c791e4ab22f7a21bb25269b0"
 dependencies = [
 "bitflags",
 "libc",
 ]

 [[package]]
-name = "itoa"
-version = "1.0.3"
+name = "is-terminal"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8af84674fe1f223a982c933a0ee1086ac4d4052aa0fb8060c12c6ad838e754"
+checksum = "28dfb6c8100ccc63462345b67d1bbc3679177c75ee4bf59bf29c8b1d110b8189"
+dependencies = [
+ "hermit-abi",
+ "io-lifetimes",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"

 [[package]]
 name = "jobserver"
@@ -427,8 +414,8 @@ dependencies = [

 [[package]]
 name = "kvm-bindings"
-version = "0.5.0"
-source = "git+https://github.com/cloud-hypervisor/kvm-bindings?branch=ch-v0.5.0-tdx#52e56d0e8ef0f6ea32fc0492e6a175b73617a49f"
+version = "0.6.0"
+source = "git+https://github.com/cloud-hypervisor/kvm-bindings?branch=ch-v0.6.0-tdx#7d9ffb47e5b9b1989577258800a0f57c93f1445f"
 dependencies = [
 "serde",
 "serde_derive",
@@ -437,8 +424,9 @@ dependencies = [

 [[package]]
 name = "kvm-ioctls"
-version = "0.11.0"
-source = "git+https://github.com/rust-vmm/kvm-ioctls?branch=main#1e03e29cdfbb0cb108a98de7a78045a5a517f18e"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3a321cabd827642499c77e27314f388dd83a717a5ca716b86476fb947f73ae4"
 dependencies = [
 "kvm-bindings",
 "libc",
@@ -453,15 +441,15 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.133"
+version = "0.2.139"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0f80d65747a3e43d1596c7c5492d95d5edddaabd45a7fcdb02b95f644164966"
+checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"

 [[package]]
 name = "libfuzzer-sys"
-version = "0.4.4"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae185684fe19814afd066da15a7cc41e126886c21282934225d9fc847582da58"
+checksum = "c8fff891139ee62800da71b7fd5b508d570b9ad95e614a53c6f453ca08366038"
 dependencies = [
 "arbitrary",
 "cc",
@@ -470,18 +458,18 @@ dependencies = [

 [[package]]
 name = "linux-loader"
-version = "0.6.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62a2f912deca034ec34b0a43a390059ea98daac40e440ebe8bea88f3315fe168"
+checksum = "b9259ddbfbb52cc918f6bbc60390004ddd0228cf1d85f402009ff2b3d95de83f"
 dependencies = [
 "vm-memory",
 ]

 [[package]]
 name = "linux-raw-sys"
-version = "0.0.46"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"
+checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"

 [[package]]
 name = "log"
@@ -495,7 +483,7 @@ dependencies = [
 [[package]]
 name = "micro_http"
 version = "0.1.0"
-source = "git+https://github.com/firecracker-microvm/micro-http?branch=main#863b0370ba7e57f7df5b908ada9e5b44809ccae9"
+source = "git+https://github.com/firecracker-microvm/micro-http?branch=main#fbef706e28c7ca7cce8dfec7ca073f3b359879d3"
 dependencies = [
 "libc",
 "vmm-sys-util",
@@ -531,9 +519,9 @@ dependencies = [

 [[package]]
 name = "once_cell"
-version = "1.15.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1"
+checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"

 [[package]]
 name = "option_parser"
@@ -541,9 +529,9 @@ version = "0.1.0"

 [[package]]
 name = "os_str_bytes"
-version = "6.3.0"
+version = "6.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ff7415e9ae3fff1225851df9e0d9e4e5479f947619774677a63572e55e80eff"
+checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"

 [[package]]
 name = "pci"
@@ -569,10 +557,52 @@ dependencies = [
 ]

 [[package]]
-name = "proc-macro2"
-version = "1.0.45"
+name = "phf"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3edcd08cf4fea98d1ae6c9ddd3b8ccb1acac7c3693d62625969a7daa04a2ae36"
+checksum = "928c6535de93548188ef63bb7c4036bd415cd8f36ad25af44b9789b2ee72a48c"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1181c94580fa345f50f19d738aaa39c0ed30a600d95cb2d3e23f94266f14fbf"
+dependencies = [
+ "phf_shared",
+ "rand",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92aacdc5f16768709a569e913f7451034034178b05bdc8acda226659a3dccc66"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1fb5f6f826b772a8d4c0394209441e7d37cbbb967ae9c7e0e8134365c9ee676"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57a8eca9f9c4ffde41714334dee777596264c7825420f521abc92b5b5deb63a5"
 dependencies = [
 "unicode-ident",
 ]
@@ -597,6 +627,21 @@ dependencies = [
 "proc-macro2",
 ]

+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
 [[package]]
 name = "rate_limiter"
 version = "0.1.0"
@@ -608,9 +653,9 @@ dependencies = [

 [[package]]
 name = "remain"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06df529c0d271b27ac4a2c260f5ce2914b60bd44702cecec7b9f271adbdde23b"
+checksum = "5704e2cda92fd54202f05430725317ba0ea7d0c96b246ca0a92e45177127ba3b"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -628,9 +673,9 @@ dependencies = [

 [[package]]
 name = "rustix"
-version = "0.35.11"
+version = "0.36.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbb2fda4666def1433b1b05431ab402e42a1084285477222b72d6c564c417cef"
+checksum = "a3807b5d10909833d3e9acd1eb5fb988f79376ff10fce42937de71a449c4c588"
 dependencies = [
 "bitflags",
 "errno",
@@ -642,9 +687,9 @@ dependencies = [

 [[package]]
 name = "ryu"
-version = "1.0.11"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09"
+checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde"

 [[package]]
 name = "seccompiler"
@@ -657,24 +702,24 @@ dependencies = [

 [[package]]
 name = "semver"
-version = "1.0.14"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e25dfac463d778e353db5be2449d1cce89bd6fd23c9f1ea21310ce6e5a1b29c4"
+checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"

 [[package]]
 name = "serde"
-version = "1.0.145"
+version = "1.0.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "728eb6351430bccb993660dfffc5a72f91ccc1295abaa8ce19b27ebe4f75568b"
+checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.145"
+version = "1.0.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81fa1584d3d1bcacd84c277a0dfe21f5b0f6accf4a23d04d4c6d61f1af522b4c"
+checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -683,9 +728,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.85"
+version = "1.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e55a28e3aaef9d5ce0506d0a14dbba8054ddc7e499ef522dd8b26859ec9d4a44"
+checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883"
 dependencies = [
 "itoa",
 "ryu",
@@ -694,9 +739,9 @@ dependencies = [

 [[package]]
 name = "serde_with"
-version = "2.0.1"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368f2d60d049ea019a84dcd6687b0d1e0030fe663ae105039bdf967ed5e6a9a7"
+checksum = "25bf4a5a814902cd1014dbccfa4d4560fb8432c779471e96e035602519f82eef"
 dependencies = [
 "serde",
 "serde_with_macros",
@@ -704,9 +749,9 @@ dependencies = [

 [[package]]
 name = "serde_with_macros"
-version = "2.0.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ccadfacf6cf10faad22bbadf55986bdd0856edfb5d9210aa1dcf1f516e84e93"
+checksum = "a1966009f3c05f095697c537312f5415d1e3ed31ce0a56942bac4c771c5c335e"
 dependencies = [
 "darling",
 "proc-macro2",
@@ -738,10 +783,16 @@ dependencies = [
 ]

 [[package]]
-name = "static_assertions"
-version = "1.1.0"
+name = "siphasher"
+version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
+
+[[package]]
+name = "smallvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"

 [[package]]
 name = "strsim"
@@ -751,9 +802,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

 [[package]]
 name = "syn"
-version = "1.0.101"
+version = "1.0.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e90cde112c4b9690b8cbe810cba9ddd8bc1d7472e2cae317b69e9438c1cba7d2"
+checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -771,23 +822,14 @@ dependencies = [

 [[package]]
 name = "terminal_size"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8440c860cf79def6164e4a0a983bcc2305d82419177a0e0c71930d049e3ac5a1"
+checksum = "cb20089a8ba2b69debd491f8d2d023761cbf196e999218c591fa1e7e15a21907"
 dependencies = [
 "rustix",
 "windows-sys",
 ]

-[[package]]
-name = "textwrap"
-version = "0.15.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "949517c0cf1bf4ee812e2e07e08ab448e3ae0d23472aee8a06c985f0c8815b16"
-dependencies = [
- "terminal_size",
-]
-
 [[package]]
 name = "thiserror"
 version = "1.0.37"
@@ -808,6 +850,18 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "tpm"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "libc",
+ "log",
+ "thiserror",
+ "vmm-sys-util",
+]
+
 [[package]]
 name = "tracer"
 version = "0.1.0"
@@ -821,24 +875,24 @@ dependencies = [

 [[package]]
 name = "unicode-ident"
-version = "1.0.4"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
+checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"

 [[package]]
 name = "uuid"
-version = "1.1.2"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd6469f4314d5f1ffec476e05f17cc9a78bc7a27a6a857842170bdf8d6f98d2f"
+checksum = "422ee0de9031b5b948b97a8fc04e3aa35230001a722ddd27943e0be31564ce4c"
 dependencies = [
 "getrandom",
 ]

 [[package]]
 name = "versionize"
-version = "0.1.6"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7429cf68de8f091b667d27323ed323afd39584a56d533995b12ddd748e5e6ca9"
+checksum = "d6e2495726cf917e7ba7ec8bf0f0fceab543dd38d0a4195ed6bef331e38a290f"
 dependencies = [
 "bincode",
 "crc64",
@@ -863,17 +917,16 @@ dependencies = [

 [[package]]
 name = "vfio-bindings"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43449b404c488f70507dca193debd4bea361fe8089869b947adc19720e464bce"
+version = "0.4.0"
+source = "git+https://github.com/rust-vmm/vfio?branch=main#7ef33f6759ae6d37a54cd66f749aa47c1c81509c"
 dependencies = [
 "vmm-sys-util",
 ]

 [[package]]
 name = "vfio-ioctls"
-version = "0.1.0"
-source = "git+https://github.com/rust-vmm/vfio?branch=main#bf7c9b997b4ad0ca1ab4bfe96dc1b10d4bc5be24"
+version = "0.2.0"
+source = "git+https://github.com/rust-vmm/vfio?branch=main#7ef33f6759ae6d37a54cd66f749aa47c1c81509c"
 dependencies = [
 "byteorder",
 "kvm-bindings",
@@ -916,9 +969,9 @@ dependencies = [

 [[package]]
 name = "vhost"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79243657c76e5c90dcbf60187c842614f6dfc7123972c55bb3bcc446792aca93"
+checksum = "c9b791c5b0717a0558888a4cf7240cea836f39a99cb342e12ce633dcaa078072"
 dependencies = [
 "bitflags",
 "libc",
@@ -969,9 +1022,9 @@ dependencies = [

 [[package]]
 name = "virtio-queue"
-version = "0.6.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e2b7bea73248006630c9611a61ac3b8e44eece09342801fe1faec583b7a9f02"
+checksum = "19e927d93d54c365034fd7f31a5f458a1f540de4a37c52e892670dad9692173c"
 dependencies = [
 "log",
 "virtio-bindings",
@@ -1003,14 +1056,14 @@ dependencies = [

 [[package]]
 name = "vm-fdt"
-version = "0.1.0"
-source = "git+https://github.com/rust-vmm/vm-fdt?branch=main#720e48e435b791ec6cbe8d2b229448b71dcb1ab9"
+version = "0.2.0"
+source = "git+https://github.com/rust-vmm/vm-fdt?branch=main#c5a99ab71b130435927d19b50c85fcd5ce904a8c"

 [[package]]
 name = "vm-memory"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "583f213899e8a5eea23d9c507252d4bed5bc88f0ecbe0783262f80034630744b"
+checksum = "688a70366615b45575a424d9c665561c1b5ab2224d494f706b6a6812911a827c"
 dependencies = [
 "arc-swap",
 "libc",
@@ -1088,9 +1141,9 @@ dependencies = [

 [[package]]
 name = "vmm-sys-util"
-version = "0.10.0"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08604d7be03eb26e33b3cee3ed4aef2bf550b305d1cca60e84da5d28d3790b62"
+checksum = "cc06a16ee8ebf0d9269aed304030b0d20a866b8b3dd3d4ce532596ac567a0d24"
 dependencies = [
 "bitflags",
 "libc",
@@ -1137,43 +1190,57 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

 [[package]]
 name = "windows-sys"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
+checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
 dependencies = [
+ "windows_aarch64_gnullvm",
 "windows_aarch64_msvc",
 "windows_i686_gnu",
 "windows_i686_msvc",
 "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
 "windows_x86_64_msvc",
 ]

 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.36.1"
+name = "windows_aarch64_gnullvm"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
+checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4"

 [[package]]
 name = "windows_i686_gnu"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
+checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7"

 [[package]]
 name = "windows_i686_msvc"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
+checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246"

 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
+checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028"

 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.36.1"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
+checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5"
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -12,18 +12,20 @@ cargo-fuzz = true
 block_util = { path = "../block_util" }
 devices = { path = "../devices" }
 epoll = "4.3.1"
-libc = "0.2.133"
-libfuzzer-sys = "0.4.4"
+libc = "0.2.138"
+libfuzzer-sys = "0.4.5"
+linux-loader = { version = "0.8.1", features = ["elf", "bzimage", "pe"] }
 micro_http = { git = "https://github.com/firecracker-microvm/micro-http", branch = "main" }
-once_cell = "1.15.0"
+net_util = { path = "../net_util" }
+once_cell = "1.17.0"
 qcow = { path = "../qcow" }
 seccompiler = "0.3.0"
 vhdx = { path = "../vhdx" }
 virtio-devices = { path = "../virtio-devices" }
-virtio-queue = "0.6.1"
+virtio-queue = "0.7.0"
 vmm = { path = "../vmm" }
-vmm-sys-util = "0.10.0"
-vm-memory = "0.9.0"
+vmm-sys-util = "0.11.0"
+vm-memory = "0.10.0"
 vm-device = { path = "../vm-device" }
 vm-virtio = { path = "../vm-virtio" }

@@ -31,8 +33,7 @@ vm-virtio = { path = "../vm-virtio" }
 path = ".."

 [patch.crates-io]
-kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.5.0-tdx" }
-kvm-ioctls = { git = "https://github.com/rust-vmm/kvm-ioctls", branch = "main" }
+kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.6.0-tdx" }
 versionize_derive = { git = "https://github.com/cloud-hypervisor/versionize_derive", branch = "ch" }

 # Prevent this from interfering with workspaces
@@ -57,12 +58,48 @@ path = "fuzz_targets/cmos.rs"
 test = false
 doc = false

+[[bin]]
+name = "console"
+path = "fuzz_targets/console.rs"
+test = false
+doc = false
+
 [[bin]]
 name = "http_api"
 path = "fuzz_targets/http_api.rs"
 test = false
 doc = false

+[[bin]]
+name = "iommu"
+path = "fuzz_targets/iommu.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "linux_loader"
+path = "fuzz_targets/linux_loader.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "linux_loader_cmdline"
+path = "fuzz_targets/linux_loader_cmdline.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "mem"
+path = "fuzz_targets/mem.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "net"
+path = "fuzz_targets/net.rs"
+test = false
+doc = false
+
 [[bin]]
 name = "pmem"
 path = "fuzz_targets/pmem.rs"
--- a/fuzz/fuzz_targets/balloon.rs
+++ b/fuzz/fuzz_targets/balloon.rs
@@ -16,12 +16,12 @@ use vmm_sys_util::eventfd::{EventFd, EFD_NONBLOCK};
 type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;

 const QUEUE_DATA_SIZE: usize = 4;
-const MEM_SIZE: usize = 1 * 1024 * 1024;
+const MEM_SIZE: usize = 512 * 1024;
 const BALLOON_SIZE: u64 = 512 * 1024;
 // Number of queues
 const QUEUE_NUM: usize = 3;
 // Max entries in the queue.
-const QUEUE_SIZE: u16 = 256;
+const QUEUE_SIZE: u16 = 64;
 // Descriptor table alignment
 const DESC_TABLE_ALIGN_SIZE: u64 = 16;
 // Avalable ring alignment
@@ -49,6 +49,7 @@ fuzz_target!(|bytes| {
        true,
        SeccompAction::Allow,
        EventFd::new(EFD_NONBLOCK).unwrap(),
+        None,
    )
    .unwrap();

--- a/fuzz/fuzz_targets/block.rs
+++ b/fuzz/fuzz_targets/block.rs
@@ -60,6 +60,7 @@ fuzz_target!(|bytes| {
        SeccompAction::Allow,
        None,
        EventFd::new(EFD_NONBLOCK).unwrap(),
+        None,
    )
    .unwrap();

--- a/fuzz/fuzz_targets/console.rs
+++ b/fuzz/fuzz_targets/console.rs
@@ -0,0 +1,194 @@
+// Copyright © 2022 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use seccompiler::SeccompAction;
+use std::fs::File;
+use std::io::Write;
+use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
+use std::sync::Arc;
+use virtio_devices::{VirtioDevice, VirtioInterrupt, VirtioInterruptType};
+use virtio_queue::{Queue, QueueT};
+use vm_memory::{bitmap::AtomicBitmap, Bytes, GuestAddress, GuestMemoryAtomic};
+use vmm_sys_util::eventfd::{EventFd, EFD_NONBLOCK};
+
+type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
+
+macro_rules! align {
+    ($n:expr, $align:expr) => {{
+        (($n + $align - 1) / $align) * $align
+    }};
+}
+
+const CONSOLE_INPUT_SIZE: usize = 128;
+const QUEUE_DATA_SIZE: usize = 4;
+const MEM_SIZE: usize = 32 * 1024 * 1024;
+// Guest memory gap
+const GUEST_MEM_GAP: u64 = 1 * 1024 * 1024;
+// Guest physical address for the first virt queue
+const BASE_VIRT_QUEUE_ADDR: u64 = MEM_SIZE as u64 + GUEST_MEM_GAP;
+// Number of queues
+const QUEUE_NUM: usize = 2;
+// Max entries in the queue.
+const QUEUE_SIZE: u16 = 256;
+// Descriptor table alignment
+const DESC_TABLE_ALIGN_SIZE: u64 = 16;
+// Used ring alignment
+const USED_RING_ALIGN_SIZE: u64 = 4;
+// Descriptor table size
+const DESC_TABLE_SIZE: u64 = 16_u64 * QUEUE_SIZE as u64;
+// Available ring size
+const AVAIL_RING_SIZE: u64 = 6_u64 + 2 * QUEUE_SIZE as u64;
+// Padding size before used ring
+const PADDING_SIZE: u64 = align!(AVAIL_RING_SIZE, USED_RING_ALIGN_SIZE) - AVAIL_RING_SIZE;
+// Used ring size
+const USED_RING_SIZE: u64 = 6_u64 + 8 * QUEUE_SIZE as u64;
+// Virtio-queue size in bytes
+const QUEUE_BYTES_SIZE: usize = align!(
+    DESC_TABLE_SIZE + AVAIL_RING_SIZE + PADDING_SIZE + USED_RING_SIZE,
+    DESC_TABLE_ALIGN_SIZE
+) as usize;
+
+fuzz_target!(|bytes| {
+    if bytes.len() < (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE) * QUEUE_NUM + CONSOLE_INPUT_SIZE
+        || bytes.len()
+            > (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE) * QUEUE_NUM + CONSOLE_INPUT_SIZE + MEM_SIZE
+    {
+        return;
+    }
+
+    let (pipe_rx, mut pipe_tx) = create_pipe().unwrap();
+    let output = unsafe {
+        File::from_raw_fd(
+            memfd_create(&std::ffi::CString::new("fuzz_console_output").unwrap()).unwrap(),
+        )
+    };
+    let endpoint = virtio_devices::Endpoint::FilePair(output, pipe_rx);
+
+    let (mut console, _) = virtio_devices::Console::new(
+        "fuzzer_console".to_owned(),
+        endpoint,
+        None,  // resize_pipe
+        false, // iommu
+        SeccompAction::Allow,
+        EventFd::new(EFD_NONBLOCK).unwrap(),
+        None,
+    )
+    .unwrap();
+
+    let console_input_bytes = &bytes[..CONSOLE_INPUT_SIZE];
+    let queue_data = &bytes[CONSOLE_INPUT_SIZE..CONSOLE_INPUT_SIZE + QUEUE_DATA_SIZE * QUEUE_NUM];
+    let queue_bytes = &bytes[CONSOLE_INPUT_SIZE + QUEUE_DATA_SIZE * QUEUE_NUM
+        ..CONSOLE_INPUT_SIZE + (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE) * QUEUE_NUM];
+    let mem_bytes = &bytes[CONSOLE_INPUT_SIZE + (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE) * QUEUE_NUM..];
+
+    // Setup the virt queues with the input bytes
+    let mut queues = setup_virt_queues(
+        &[
+            &queue_data[..QUEUE_DATA_SIZE].try_into().unwrap(),
+            &queue_data[QUEUE_DATA_SIZE..QUEUE_DATA_SIZE * 2]
+                .try_into()
+                .unwrap(),
+        ],
+        BASE_VIRT_QUEUE_ADDR,
+    );
+
+    // Setup the guest memory with the input bytes
+    let mem = GuestMemoryMmap::from_ranges(&[
+        (GuestAddress(0), MEM_SIZE),
+        (GuestAddress(BASE_VIRT_QUEUE_ADDR), queue_bytes.len()),
+    ])
+    .unwrap();
+    if mem
+        .write_slice(queue_bytes, GuestAddress(BASE_VIRT_QUEUE_ADDR))
+        .is_err()
+    {
+        return;
+    }
+    if mem.write_slice(mem_bytes, GuestAddress(0 as u64)).is_err() {
+        return;
+    }
+    let guest_memory = GuestMemoryAtomic::new(mem);
+
+    let input_queue = queues.remove(0);
+    let input_evt = EventFd::new(0).unwrap();
+    let input_queue_evt = unsafe { EventFd::from_raw_fd(libc::dup(input_evt.as_raw_fd())) };
+    let output_queue = queues.remove(0);
+    let output_evt = EventFd::new(0).unwrap();
+    let output_queue_evt = unsafe { EventFd::from_raw_fd(libc::dup(output_evt.as_raw_fd())) };
+
+    // Kick the 'queue' events and endpoint event before activate the console device
+    input_queue_evt.write(1).unwrap();
+    output_queue_evt.write(1).unwrap();
+    pipe_tx.write_all(console_input_bytes).unwrap(); // To use fuzzed data;
+
+    console
+        .activate(
+            guest_memory,
+            Arc::new(NoopVirtioInterrupt {}),
+            vec![(0, input_queue, input_evt), (1, output_queue, output_evt)],
+        )
+        .unwrap();
+
+    // Wait for the events to finish and console device worker thread to return
+    console.wait_for_epoll_threads();
+});
+
+pub struct NoopVirtioInterrupt {}
+
+impl VirtioInterrupt for NoopVirtioInterrupt {
+    fn trigger(&self, _int_type: VirtioInterruptType) -> std::result::Result<(), std::io::Error> {
+        Ok(())
+    }
+}
+
+fn setup_virt_queues(bytes: &[&[u8; QUEUE_DATA_SIZE]], base_addr: u64) -> Vec<Queue> {
+    let mut queues = Vec::new();
+    for (i, b) in bytes.iter().enumerate() {
+        let mut q = Queue::new(QUEUE_SIZE).unwrap();
+
+        let desc_table_addr = base_addr + (QUEUE_BYTES_SIZE * i) as u64;
+        let avail_ring_addr = desc_table_addr + DESC_TABLE_SIZE;
+        let used_ring_addr = avail_ring_addr + PADDING_SIZE + AVAIL_RING_SIZE;
+        q.try_set_desc_table_address(GuestAddress(desc_table_addr))
+            .unwrap();
+        q.try_set_avail_ring_address(GuestAddress(avail_ring_addr))
+            .unwrap();
+        q.try_set_used_ring_address(GuestAddress(used_ring_addr))
+            .unwrap();
+
+        q.set_next_avail(b[0] as u16); // 'u8' is enough given the 'QUEUE_SIZE' is small
+        q.set_next_used(b[1] as u16);
+        q.set_event_idx(b[2] % 2 != 0);
+        q.set_size(b[3] as u16 % QUEUE_SIZE);
+
+        q.set_ready(true);
+        queues.push(q);
+    }
+
+    queues
+}
+
+fn memfd_create(name: &std::ffi::CStr) -> Result<RawFd, std::io::Error> {
+    let res = unsafe { libc::syscall(libc::SYS_memfd_create, name.as_ptr(), 0) };
+
+    if res < 0 {
+        Err(std::io::Error::last_os_error())
+    } else {
+        Ok(res as RawFd)
+    }
+}
+
+fn create_pipe() -> Result<(File, File), std::io::Error> {
+    let mut pipe = [-1; 2];
+    if unsafe { libc::pipe2(pipe.as_mut_ptr(), libc::O_CLOEXEC) } == -1 {
+        return Err(std::io::Error::last_os_error());
+    }
+    let rx = unsafe { File::from_raw_fd(pipe[0]) };
+    let tx = unsafe { File::from_raw_fd(pipe[1]) };
+
+    Ok((rx, tx))
+}
--- a/fuzz/fuzz_targets/iommu.rs
+++ b/fuzz/fuzz_targets/iommu.rs
@@ -0,0 +1,145 @@
+// Copyright © 2022 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use seccompiler::SeccompAction;
+use std::os::unix::io::{AsRawFd, FromRawFd};
+use std::sync::Arc;
+use virtio_devices::{VirtioDevice, VirtioInterrupt, VirtioInterruptType};
+use virtio_queue::{Queue, QueueT};
+use vm_memory::{bitmap::AtomicBitmap, Bytes, GuestAddress, GuestMemoryAtomic};
+use vmm_sys_util::eventfd::{EventFd, EFD_NONBLOCK};
+
+type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
+
+macro_rules! align {
+    ($n:expr, $align:expr) => {{
+        (($n + $align - 1) / $align) * $align
+    }};
+}
+
+const QUEUE_DATA_SIZE: usize = 4;
+const MEM_SIZE: usize = 32 * 1024 * 1024;
+// Reuse what's being done from DeviceManager::get_msi_iova_space()
+const IOVA_SPACE_SIZE: usize = (0xfeef_ffff - 0xfee0_0000) + 1;
+
+// Max entries in the queue.
+const QUEUE_SIZE: u16 = 256;
+// Descriptor table alignment
+const DESC_TABLE_ALIGN_SIZE: u64 = 16;
+// Avalable ring alignment
+const AVAIL_RING_ALIGN_SIZE: u64 = 2;
+// Used ring alignment
+const USED_RING_ALIGN_SIZE: u64 = 4;
+// Descriptor table size
+const DESC_TABLE_SIZE: u64 = 16_u64 * QUEUE_SIZE as u64;
+// Available ring size
+const AVAIL_RING_SIZE: u64 = 6_u64 + 2 * QUEUE_SIZE as u64;
+// Used ring size
+const USED_RING_SIZE: u64 = 6_u64 + 8 * QUEUE_SIZE as u64;
+
+// Guest memory gap
+const GUEST_MEM_GAP: u64 = 1 * 1024 * 1024;
+// Guest physical address for descriptor table.
+const DESC_TABLE_ADDR: u64 = align!(MEM_SIZE as u64 + GUEST_MEM_GAP, DESC_TABLE_ALIGN_SIZE);
+// Guest physical address for available ring
+const AVAIL_RING_ADDR: u64 = align!(DESC_TABLE_ADDR + DESC_TABLE_SIZE, AVAIL_RING_ALIGN_SIZE);
+// Guest physical address for used ring
+const USED_RING_ADDR: u64 = align!(AVAIL_RING_ADDR + AVAIL_RING_SIZE, USED_RING_ALIGN_SIZE);
+// Virtio-queue size in bytes
+const QUEUE_BYTES_SIZE: usize = (USED_RING_ADDR + USED_RING_SIZE - DESC_TABLE_ADDR) as usize;
+
+fuzz_target!(|bytes| {
+    if bytes.len() < (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE)
+        || bytes.len() > (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE + MEM_SIZE)
+    {
+        return;
+    }
+
+    let (mut iommu, _) = virtio_devices::Iommu::new(
+        "fuzzer_iommu".to_owned(),
+        SeccompAction::Allow,
+        EventFd::new(EFD_NONBLOCK).unwrap(),
+        ((MEM_SIZE - IOVA_SPACE_SIZE) as u64, (MEM_SIZE - 1) as u64),
+        None,
+    )
+    .unwrap();
+
+    let queue_data = &bytes[..QUEUE_DATA_SIZE];
+    let queue_bytes = &bytes[QUEUE_DATA_SIZE..QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE];
+    let mem_bytes = &bytes[QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE..];
+
+    // Setup the request queue with the input bytes
+    let request_queue = setup_virt_queue(queue_data.try_into().unwrap());
+    // Given the "event queue" events are not handled from the current
+    // implementation of virtio-iommu, we simply setup the 'event_queue'
+    // with exactly the same content as the 'request_queue'.
+    let _event_queue = setup_virt_queue(queue_data.try_into().unwrap());
+
+    // Setup the guest memory with the input bytes
+    let mem = GuestMemoryMmap::from_ranges(&[
+        (GuestAddress(0), MEM_SIZE),
+        (GuestAddress(DESC_TABLE_ADDR), QUEUE_BYTES_SIZE),
+    ])
+    .unwrap();
+    if mem
+        .write_slice(queue_bytes, GuestAddress(DESC_TABLE_ADDR))
+        .is_err()
+    {
+        return;
+    }
+    if mem.write_slice(mem_bytes, GuestAddress(0 as u64)).is_err() {
+        return;
+    }
+    let guest_memory = GuestMemoryAtomic::new(mem);
+
+    let request_evt = EventFd::new(0).unwrap();
+    let request_queue_evt = unsafe { EventFd::from_raw_fd(libc::dup(request_evt.as_raw_fd())) };
+    let _event_evt = EventFd::new(0).unwrap();
+
+    // Kick the 'queue' event before activate the vIOMMU device
+    request_queue_evt.write(1).unwrap();
+
+    iommu
+        .activate(
+            guest_memory,
+            Arc::new(NoopVirtioInterrupt {}),
+            vec![
+                (0, request_queue, request_evt),
+                (0, _event_queue, _event_evt),
+            ],
+        )
+        .ok();
+
+    // Wait for the events to finish and vIOMMU device worker thread to return
+    iommu.wait_for_epoll_threads();
+});
+
+pub struct NoopVirtioInterrupt {}
+
+impl VirtioInterrupt for NoopVirtioInterrupt {
+    fn trigger(&self, _int_type: VirtioInterruptType) -> std::result::Result<(), std::io::Error> {
+        Ok(())
+    }
+}
+
+fn setup_virt_queue(bytes: &[u8; QUEUE_DATA_SIZE]) -> Queue {
+    let mut q = Queue::new(QUEUE_SIZE).unwrap();
+    q.set_next_avail(bytes[0] as u16); // 'u8' is enough given the 'QUEUE_SIZE' is small
+    q.set_next_used(bytes[1] as u16);
+    q.set_event_idx(bytes[2] % 2 != 0);
+    q.set_size(bytes[3] as u16 % QUEUE_SIZE);
+
+    q.try_set_desc_table_address(GuestAddress(DESC_TABLE_ADDR))
+        .unwrap();
+    q.try_set_avail_ring_address(GuestAddress(AVAIL_RING_ADDR))
+        .unwrap();
+    q.try_set_used_ring_address(GuestAddress(USED_RING_ADDR))
+        .unwrap();
+    q.set_ready(true);
+
+    q
+}
--- a/fuzz/fuzz_targets/linux_loader.rs
+++ b/fuzz/fuzz_targets/linux_loader.rs
@@ -0,0 +1,50 @@
+// Copyright 2018 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Copyright © 2022 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use linux_loader::loader::KernelLoader;
+use std::ffi;
+use std::fs::File;
+use std::io;
+use std::io::{Seek, SeekFrom, Write};
+use std::os::unix::io::{FromRawFd, RawFd};
+use vm_memory::{bitmap::AtomicBitmap, GuestAddress};
+
+type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
+
+const MEM_SIZE: usize = 256 * 1024 * 1024;
+// From 'arch::x86_64::layout::HIGH_RAM_START'
+const HIGH_RAM_START: GuestAddress = GuestAddress(0x100000);
+
+fuzz_target!(|bytes| {
+    let shm = memfd_create(&ffi::CString::new("fuzz_load_kernel").unwrap(), 0).unwrap();
+    let mut kernel_file: File = unsafe { File::from_raw_fd(shm) };
+    kernel_file.write_all(&bytes).unwrap();
+    kernel_file.seek(SeekFrom::Start(0)).unwrap();
+
+    let guest_memory = GuestMemoryMmap::from_ranges(&[(GuestAddress(0), MEM_SIZE)]).unwrap();
+    linux_loader::loader::elf::Elf::load(
+        &guest_memory,
+        None,
+        &mut kernel_file,
+        Some(HIGH_RAM_START),
+    )
+    .ok();
+});
+
+fn memfd_create(name: &ffi::CStr, flags: u32) -> Result<RawFd, io::Error> {
+    let res = unsafe { libc::syscall(libc::SYS_memfd_create, name.as_ptr(), flags) };
+
+    if res < 0 {
+        Err(io::Error::last_os_error())
+    } else {
+        Ok(res as RawFd)
+    }
+}
--- a/fuzz/fuzz_targets/linux_loader_cmdline.rs
+++ b/fuzz/fuzz_targets/linux_loader_cmdline.rs
@@ -0,0 +1,34 @@
+// Copyright 2018 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Copyright © 2022 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use vm_memory::{bitmap::AtomicBitmap, GuestAddress};
+
+type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
+
+const MEM_SIZE: usize = 256 * 1024 * 1024;
+// From 'arch::x86_64::layout::CMDLINE_START'
+const CMDLINE_START: GuestAddress = GuestAddress(0x20000);
+
+fuzz_target!(|bytes| {
+    let payload_config = vmm::config::PayloadConfig {
+        firmware: None,
+        kernel: None,
+        cmdline: Some(String::from_utf8_lossy(&bytes).to_string()),
+        initramfs: None,
+    };
+    let kernel_cmdline = match vmm::vm::Vm::generate_cmdline(&payload_config) {
+        Ok(cmdline) => cmdline,
+        _ => return,
+    };
+    let guest_memory = GuestMemoryMmap::from_ranges(&[(GuestAddress(0), MEM_SIZE)]).unwrap();
+
+    linux_loader::loader::load_cmdline(&guest_memory, CMDLINE_START, &kernel_cmdline).ok();
+});
--- a/fuzz/fuzz_targets/mem.rs
+++ b/fuzz/fuzz_targets/mem.rs
@@ -0,0 +1,179 @@
+// Copyright © 2022 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use seccompiler::SeccompAction;
+use std::os::unix::io::{AsRawFd, FromRawFd};
+use std::sync::{Arc, Mutex};
+use virtio_devices::{BlocksState, Mem, VirtioDevice, VirtioInterrupt, VirtioInterruptType};
+use virtio_queue::{Queue, QueueT};
+use vm_memory::{bitmap::AtomicBitmap, Bytes, GuestAddress, GuestMemoryAtomic};
+use vmm_sys_util::eventfd::{EventFd, EFD_NONBLOCK};
+
+type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
+type GuestRegionMmap = vm_memory::GuestRegionMmap<AtomicBitmap>;
+
+macro_rules! align {
+    ($n:expr, $align:expr) => {{
+        (($n + $align - 1) / $align) * $align
+    }};
+}
+
+const VIRTIO_MEM_DATA_SIZE: usize = 1;
+const QUEUE_DATA_SIZE: usize = 4;
+// The size of the guest memory for the virtio-mem region
+const MEM_SIZE: usize = 128 * 1024 * 1024;
+// The start address of the virtio-mem region in the guest memory
+const VIRTIO_MEM_REGION_ADDRESS: u64 = 0;
+
+// Max entries in the queue.
+const QUEUE_SIZE: u16 = 64;
+// Descriptor table alignment
+const DESC_TABLE_ALIGN_SIZE: u64 = 16;
+// Avalable ring alignment
+const AVAIL_RING_ALIGN_SIZE: u64 = 2;
+// Used ring alignment
+const USED_RING_ALIGN_SIZE: u64 = 4;
+// Descriptor table size
+const DESC_TABLE_SIZE: u64 = 16_u64 * QUEUE_SIZE as u64;
+// Available ring size
+const AVAIL_RING_SIZE: u64 = 6_u64 + 2 * QUEUE_SIZE as u64;
+// Used ring size
+const USED_RING_SIZE: u64 = 6_u64 + 8 * QUEUE_SIZE as u64;
+
+// Guest memory gap
+const GUEST_MEM_GAP: u64 = 1 * 1024 * 1024;
+// Guest physical address for descriptor table.
+const DESC_TABLE_ADDR: u64 = align!(MEM_SIZE as u64 + GUEST_MEM_GAP, DESC_TABLE_ALIGN_SIZE);
+// Guest physical address for available ring
+const AVAIL_RING_ADDR: u64 = align!(DESC_TABLE_ADDR + DESC_TABLE_SIZE, AVAIL_RING_ALIGN_SIZE);
+// Guest physical address for used ring
+const USED_RING_ADDR: u64 = align!(AVAIL_RING_ADDR + AVAIL_RING_SIZE, USED_RING_ALIGN_SIZE);
+// Virtio-queue size in bytes
+const QUEUE_BYTES_SIZE: usize = (USED_RING_ADDR + USED_RING_SIZE - DESC_TABLE_ADDR) as usize;
+
+fuzz_target!(|bytes| {
+    if bytes.len() < VIRTIO_MEM_DATA_SIZE + QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE
+        || bytes.len() > (VIRTIO_MEM_DATA_SIZE + QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE + MEM_SIZE)
+    {
+        return;
+    }
+
+    let virtio_mem_data = &bytes[..VIRTIO_MEM_DATA_SIZE];
+    let queue_data = &bytes[VIRTIO_MEM_DATA_SIZE..VIRTIO_MEM_DATA_SIZE + QUEUE_DATA_SIZE];
+    let queue_bytes = &bytes[VIRTIO_MEM_DATA_SIZE + QUEUE_DATA_SIZE
+        ..VIRTIO_MEM_DATA_SIZE + QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE];
+    let mem_bytes = &bytes[VIRTIO_MEM_DATA_SIZE + QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE..];
+
+    // Create a virtio-mem device based on the input bytes;
+    let (mut virtio_mem, virtio_mem_region) =
+        create_dummy_virtio_mem(virtio_mem_data.try_into().unwrap());
+
+    // Setup the virt queue with the input bytes
+    let q = setup_virt_queue(queue_data.try_into().unwrap());
+
+    // Setup the guest memory with the input bytes
+    let mem = GuestMemoryMmap::from_ranges(&[
+        (GuestAddress(DESC_TABLE_ADDR), QUEUE_BYTES_SIZE), // guest region for the virt queue
+    ])
+    .unwrap();
+    if mem
+        .write_slice(queue_bytes, GuestAddress(DESC_TABLE_ADDR))
+        .is_err()
+    {
+        return;
+    }
+    // Add the memory region for the virtio-mem device
+    let mem = mem.insert_region(virtio_mem_region).unwrap();
+    if mem
+        .write_slice(mem_bytes, GuestAddress(VIRTIO_MEM_REGION_ADDRESS))
+        .is_err()
+    {
+        return;
+    }
+    let guest_memory = GuestMemoryAtomic::new(mem);
+
+    let evt = EventFd::new(0).unwrap();
+    let queue_evt = unsafe { EventFd::from_raw_fd(libc::dup(evt.as_raw_fd())) };
+
+    // Kick the 'queue' event before activate the virtio-mem device
+    queue_evt.write(1).unwrap();
+
+    virtio_mem
+        .activate(
+            guest_memory,
+            Arc::new(NoopVirtioInterrupt {}),
+            vec![(0, q, evt)],
+        )
+        .ok();
+
+    // Wait for the events to finish and virtio-mem device worker thread to return
+    virtio_mem.wait_for_epoll_threads();
+});
+
+pub struct NoopVirtioInterrupt {}
+
+impl VirtioInterrupt for NoopVirtioInterrupt {
+    fn trigger(&self, _int_type: VirtioInterruptType) -> std::result::Result<(), std::io::Error> {
+        Ok(())
+    }
+}
+
+// Create a dummy virtio-mem device for fuzzing purpose only
+fn create_dummy_virtio_mem(bytes: &[u8; VIRTIO_MEM_DATA_SIZE]) -> (Mem, Arc<GuestRegionMmap>) {
+    let numa_id = if bytes[0] % 2 != 0 { Some(0) } else { None };
+
+    let region = vmm::memory_manager::MemoryManager::create_ram_region(
+        &None,
+        0,
+        GuestAddress(VIRTIO_MEM_REGION_ADDRESS),
+        MEM_SIZE,
+        false,
+        false,
+        false,
+        None,
+        numa_id,
+        None,
+        false,
+    )
+    .unwrap();
+
+    let blocks_state = Arc::new(Mutex::new(BlocksState::new(region.size() as u64)));
+
+    (
+        Mem::new(
+            "fuzzer_mem".to_owned(),
+            &region,
+            SeccompAction::Allow,
+            numa_id.map(|i| i as u16),
+            0,
+            false,
+            EventFd::new(EFD_NONBLOCK).unwrap(),
+            blocks_state.clone(),
+            None,
+        )
+        .unwrap(),
+        region,
+    )
+}
+
+fn setup_virt_queue(bytes: &[u8; QUEUE_DATA_SIZE]) -> Queue {
+    let mut q = Queue::new(QUEUE_SIZE).unwrap();
+    q.set_next_avail(bytes[0] as u16); // 'u8' is enough given the 'QUEUE_SIZE' is small
+    q.set_next_used(bytes[1] as u16);
+    q.set_event_idx(bytes[2] % 2 != 0);
+    q.set_size(bytes[3] as u16 % QUEUE_SIZE);
+
+    q.try_set_desc_table_address(GuestAddress(DESC_TABLE_ADDR))
+        .unwrap();
+    q.try_set_avail_ring_address(GuestAddress(AVAIL_RING_ADDR))
+        .unwrap();
+    q.try_set_used_ring_address(GuestAddress(USED_RING_ADDR))
+        .unwrap();
+    q.set_ready(true);
+
+    q
+}
--- a/fuzz/fuzz_targets/net.rs
+++ b/fuzz/fuzz_targets/net.rs
@@ -0,0 +1,285 @@
+// Copyright © 2022 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use seccompiler::SeccompAction;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::os::unix::io::{AsRawFd, FromRawFd};
+use std::sync::Arc;
+use virtio_devices::{VirtioDevice, VirtioInterrupt, VirtioInterruptType};
+use virtio_queue::{Queue, QueueT};
+use vm_memory::{bitmap::AtomicBitmap, Bytes, GuestAddress, GuestMemoryAtomic};
+use vmm::EpollContext;
+use vmm_sys_util::eventfd::{EventFd, EFD_NONBLOCK};
+
+type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
+
+macro_rules! align {
+    ($n:expr, $align:expr) => {{
+        (($n + $align - 1) / $align) * $align
+    }};
+}
+
+const TAP_INPUT_SIZE: usize = 128;
+const QUEUE_DATA_SIZE: usize = 4;
+const MEM_SIZE: usize = 32 * 1024 * 1024;
+// Guest memory gap
+const GUEST_MEM_GAP: u64 = 1 * 1024 * 1024;
+// Guest physical address for the first virt queue
+const BASE_VIRT_QUEUE_ADDR: u64 = MEM_SIZE as u64 + GUEST_MEM_GAP;
+// Number of queues
+const QUEUE_NUM: usize = 2;
+// Max entries in the queue.
+const QUEUE_SIZE: u16 = 256;
+// Descriptor table alignment
+const DESC_TABLE_ALIGN_SIZE: u64 = 16;
+// Used ring alignment
+const USED_RING_ALIGN_SIZE: u64 = 4;
+// Descriptor table size
+const DESC_TABLE_SIZE: u64 = 16_u64 * QUEUE_SIZE as u64;
+// Available ring size
+const AVAIL_RING_SIZE: u64 = 6_u64 + 2 * QUEUE_SIZE as u64;
+// Padding size before used ring
+const PADDING_SIZE: u64 = align!(AVAIL_RING_SIZE, USED_RING_ALIGN_SIZE) - AVAIL_RING_SIZE;
+// Used ring size
+const USED_RING_SIZE: u64 = 6_u64 + 8 * QUEUE_SIZE as u64;
+// Virtio-queue size in bytes
+const QUEUE_BYTES_SIZE: usize = align!(
+    DESC_TABLE_SIZE + AVAIL_RING_SIZE + PADDING_SIZE + USED_RING_SIZE,
+    DESC_TABLE_ALIGN_SIZE
+) as usize;
+
+fuzz_target!(|bytes| {
+    if bytes.len() < TAP_INPUT_SIZE + (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE) * QUEUE_NUM
+        || bytes.len()
+            > TAP_INPUT_SIZE + (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE) * QUEUE_NUM + MEM_SIZE
+    {
+        return;
+    }
+
+    let (dummy_tap_frontend, dummy_tap_backend) = create_socketpair().unwrap();
+    let if_name = "fuzzer_tap_name".as_bytes().to_vec();
+    let tap = net_util::Tap::new_for_fuzzing(dummy_tap_frontend, if_name);
+
+    let mut net = virtio_devices::Net::new_with_tap(
+        "fuzzer_net".to_owned(),
+        vec![tap],
+        None,  // guest_mac
+        false, // iommu
+        QUEUE_NUM,
+        QUEUE_SIZE,
+        SeccompAction::Allow,
+        None,
+        EventFd::new(EFD_NONBLOCK).unwrap(),
+        None,
+        true,
+        true,
+        true,
+    )
+    .unwrap();
+
+    let tap_input_bytes = &bytes[..TAP_INPUT_SIZE];
+    let queue_data = &bytes[TAP_INPUT_SIZE..TAP_INPUT_SIZE + QUEUE_DATA_SIZE * QUEUE_NUM];
+    let queue_bytes = &bytes[TAP_INPUT_SIZE + QUEUE_DATA_SIZE * QUEUE_NUM
+        ..TAP_INPUT_SIZE + (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE) * QUEUE_NUM];
+    let mem_bytes = &bytes[TAP_INPUT_SIZE + (QUEUE_DATA_SIZE + QUEUE_BYTES_SIZE) * QUEUE_NUM..];
+
+    // Setup the virt queues with the input bytes
+    let mut queues = setup_virt_queues(
+        &[
+            &queue_data[..QUEUE_DATA_SIZE].try_into().unwrap(),
+            &queue_data[QUEUE_DATA_SIZE..QUEUE_DATA_SIZE * 2]
+                .try_into()
+                .unwrap(),
+        ],
+        BASE_VIRT_QUEUE_ADDR,
+    );
+
+    // Setup the guest memory with the input bytes
+    let mem = GuestMemoryMmap::from_ranges(&[
+        (GuestAddress(0), MEM_SIZE),
+        (GuestAddress(BASE_VIRT_QUEUE_ADDR), queue_bytes.len()),
+    ])
+    .unwrap();
+    if mem
+        .write_slice(queue_bytes, GuestAddress(BASE_VIRT_QUEUE_ADDR))
+        .is_err()
+    {
+        return;
+    }
+    if mem.write_slice(mem_bytes, GuestAddress(0 as u64)).is_err() {
+        return;
+    }
+    let guest_memory = GuestMemoryAtomic::new(mem);
+
+    let input_queue = queues.remove(0);
+    let input_evt = EventFd::new(0).unwrap();
+    let input_queue_evt = unsafe { EventFd::from_raw_fd(libc::dup(input_evt.as_raw_fd())) };
+    let output_queue = queues.remove(0);
+    let output_evt = EventFd::new(0).unwrap();
+    let output_queue_evt = unsafe { EventFd::from_raw_fd(libc::dup(output_evt.as_raw_fd())) };
+
+    // Start the thread of dummy tap backend to handle the rx and tx from the virtio-net
+    let exit_evt = EventFd::new(libc::EFD_NONBLOCK).unwrap();
+    let tap_backend_thread = {
+        let dummy_tap_backend = dummy_tap_backend.try_clone().unwrap();
+        let tap_input_bytes: [u8; TAP_INPUT_SIZE] = tap_input_bytes[..].try_into().unwrap();
+        let exit_evt = exit_evt.try_clone().unwrap();
+        std::thread::Builder::new()
+            .name("dummy_tap_backend".to_string())
+            .spawn(move || {
+                tap_backend_stub(dummy_tap_backend, &tap_input_bytes, exit_evt);
+            })
+            .unwrap()
+    };
+
+    // Kick the 'queue' events and endpoint event before activate the net device
+    input_queue_evt.write(1).unwrap();
+    output_queue_evt.write(1).unwrap();
+
+    net.activate(
+        guest_memory,
+        Arc::new(NoopVirtioInterrupt {}),
+        vec![(0, input_queue, input_evt), (1, output_queue, output_evt)],
+    )
+    .unwrap();
+
+    // Wait for the events to finish and net device worker thread to return
+    net.wait_for_epoll_threads();
+    // Terminate the thread for the dummy tap backend
+    exit_evt.write(1).ok();
+    tap_backend_thread.join().unwrap();
+});
+
+pub struct NoopVirtioInterrupt {}
+
+impl VirtioInterrupt for NoopVirtioInterrupt {
+    fn trigger(&self, _int_type: VirtioInterruptType) -> std::result::Result<(), std::io::Error> {
+        Ok(())
+    }
+}
+
+fn setup_virt_queues(bytes: &[&[u8; QUEUE_DATA_SIZE]], base_addr: u64) -> Vec<Queue> {
+    let mut queues = Vec::new();
+    for (i, b) in bytes.iter().enumerate() {
+        let mut q = Queue::new(QUEUE_SIZE).unwrap();
+
+        let desc_table_addr = base_addr + (QUEUE_BYTES_SIZE * i) as u64;
+        let avail_ring_addr = desc_table_addr + DESC_TABLE_SIZE;
+        let used_ring_addr = avail_ring_addr + PADDING_SIZE + AVAIL_RING_SIZE;
+        q.try_set_desc_table_address(GuestAddress(desc_table_addr))
+            .unwrap();
+        q.try_set_avail_ring_address(GuestAddress(avail_ring_addr))
+            .unwrap();
+        q.try_set_used_ring_address(GuestAddress(used_ring_addr))
+            .unwrap();
+
+        q.set_next_avail(b[0] as u16); // 'u8' is enough given the 'QUEUE_SIZE' is small
+        q.set_next_used(b[1] as u16);
+        q.set_event_idx(b[2] % 2 != 0);
+        q.set_size(b[3] as u16 % QUEUE_SIZE);
+
+        q.set_ready(true);
+        queues.push(q);
+    }
+
+    queues
+}
+
+fn create_socketpair() -> Result<(File, File), std::io::Error> {
+    let mut fds = [-1, -1];
+    unsafe {
+        let ret = libc::socketpair(
+            libc::AF_UNIX,
+            libc::SOCK_STREAM | libc::SOCK_NONBLOCK,
+            0,
+            fds.as_mut_ptr(),
+        );
+        if ret == -1 {
+            return Err(std::io::Error::last_os_error());
+        }
+    }
+
+    let socket1 = unsafe { File::from_raw_fd(fds[0]) };
+    let socket2 = unsafe { File::from_raw_fd(fds[1]) };
+    Ok((socket1, socket2))
+}
+
+enum EpollEvent {
+    Exit = 0,
+    Rx = 1,
+    Tx = 2,
+    Unknown,
+}
+
+impl From<u64> for EpollEvent {
+    fn from(v: u64) -> Self {
+        use EpollEvent::*;
+        match v {
+            0 => Exit,
+            1 => Rx,
+            2 => Tx,
+            _ => Unknown,
+        }
+    }
+}
+
+// Handle the rx and tx requests from the virtio-net device
+fn tap_backend_stub(
+    mut dummy_tap: File,
+    tap_input_bytes: &[u8; TAP_INPUT_SIZE],
+    exit_evt: EventFd,
+) {
+    let mut epoll = EpollContext::new().unwrap();
+    epoll
+        .add_event_custom(&exit_evt, EpollEvent::Exit as u64, epoll::Events::EPOLLIN)
+        .unwrap();
+    let dummy_tap_write = dummy_tap.try_clone().unwrap();
+    epoll
+        .add_event_custom(
+            &dummy_tap_write,
+            EpollEvent::Rx as u64,
+            epoll::Events::EPOLLOUT,
+        )
+        .unwrap();
+    epoll
+        .add_event_custom(&dummy_tap, EpollEvent::Tx as u64, epoll::Events::EPOLLIN)
+        .unwrap();
+
+    let epoll_fd = epoll.as_raw_fd();
+    let mut events = vec![epoll::Event::new(epoll::Events::empty(), 0); 3];
+    loop {
+        let num_events = match epoll::wait(epoll_fd, -1, &mut events[..]) {
+            Ok(num_events) => num_events,
+            Err(e) => match e.raw_os_error() {
+                Some(libc::EAGAIN) | Some(libc::EINTR) => continue,
+                _ => panic!("Unexpected epoll::wait error!"),
+            },
+        };
+
+        for event in events.iter().take(num_events) {
+            let dispatch_event: EpollEvent = event.data.into();
+            match dispatch_event {
+                EpollEvent::Exit => {
+                    return;
+                }
+                EpollEvent::Rx => {
+                    dummy_tap.write_all(tap_input_bytes).unwrap();
+                    break;
+                }
+                EpollEvent::Tx => {
+                    let mut buffer = Vec::new();
+                    dummy_tap.read_to_end(&mut buffer).ok();
+                    break;
+                }
+                _ => {
+                    panic!("Unexpected Epoll event");
+                }
+            }
+        }
+    }
+}
--- a/fuzz/fuzz_targets/pmem.rs
+++ b/fuzz/fuzz_targets/pmem.rs
@@ -127,6 +127,7 @@ fn create_dummy_pmem() -> Pmem {
        false,
        SeccompAction::Allow,
        EventFd::new(EFD_NONBLOCK).unwrap(),
+        None,
    )
    .unwrap()
 }
--- a/fuzz/fuzz_targets/rng.rs
+++ b/fuzz/fuzz_targets/rng.rs
@@ -63,6 +63,7 @@ fuzz_target!(|bytes| {
        false,
        SeccompAction::Allow,
        EventFd::new(EFD_NONBLOCK).unwrap(),
+        None,
    )
    .unwrap();

--- a/fuzz/fuzz_targets/serial.rs
+++ b/fuzz/fuzz_targets/serial.rs
@@ -15,6 +15,7 @@ fuzz_target!(|bytes| {
    let mut serial = Serial::new_sink(
        "serial".into(),
        Arc::new(TestInterrupt::new(EventFd::new(EFD_NONBLOCK).unwrap())),
+        None,
    );

    let mut i = 0;
--- a/fuzz/fuzz_targets/watchdog.rs
+++ b/fuzz/fuzz_targets/watchdog.rs
@@ -38,6 +38,7 @@ fuzz_target!(|bytes| {
        EventFd::new(EFD_NONBLOCK).unwrap(),
        SeccompAction::Allow,
        EventFd::new(EFD_NONBLOCK).unwrap(),
+        None,
    )
    .unwrap();

--- a/hypervisor/Cargo.toml
+++ b/hypervisor/Cargo.toml
@@ -11,25 +11,25 @@ mshv = ["mshv-ioctls", "mshv-bindings"]
 tdx = []

 [dependencies]
-anyhow = "1.0.65"
+anyhow = "1.0.68"
 byteorder = "1.4.3"
-thiserror = "1.0.37"
-libc = "0.2.133"
+thiserror = "1.0.38"
+libc = "0.2.139"
 log = "0.4.17"
-kvm-ioctls = { version = "0.11.0", optional = true }
-kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.5.0-tdx", features = ["with-serde", "fam-wrappers"], optional  = true }
+kvm-ioctls = { version = "0.12.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.145", features = ["rc", "derive"] }
-serde_with = { version = "2.0.1", default-features = false, features = ["macros"] }
+serde = { version = "1.0.151", features = ["rc", "derive"] }
+serde_with = { version = "2.1.0", default-features = false, features = ["macros"] }
 vfio-ioctls = { git = "https://github.com/rust-vmm/vfio", branch = "main", default-features = false }
-vm-memory = { version = "0.9.0", features = ["backend-mmap", "backend-atomic"] }
-vmm-sys-util = { version = "0.10.0", features = ["with-serde"] }
+vm-memory = { version = "0.10.0", features = ["backend-mmap", "backend-atomic"] }
+vmm-sys-util = { version = "0.11.0", features = ["with-serde"] }

 [target.'cfg(target_arch = "x86_64")'.dependencies.iced-x86]
-version = "1.17.0"
+version = "1.18.0"
 default-features = false
 features = ["std", "decoder", "op_code_info", "instr_info", "fast_fmt"]

 [dev-dependencies]
-env_logger = "0.9.1"
+env_logger = "0.10.0"
--- a/hypervisor/src/arch/emulator/mod.rs
+++ b/hypervisor/src/arch/emulator/mod.rs
@@ -24,10 +24,10 @@ impl<T: Debug> Display for Exception<T> {
            self.vector,
            self.ip,
            self.error
-                .map(|e| format!(": error {:x}", e))
+                .map(|e| format!(": error {e:x}"))
                .unwrap_or_else(|| "".to_owned()),
            self.payload
-                .map(|payload| format!(": payload {:x}", payload))
+                .map(|payload| format!(": payload {payload:x}"))
                .unwrap_or_else(|| "".to_owned())
        )
    }
--- a/hypervisor/src/arch/x86/emulator/instructions/mod.rs
+++ b/hypervisor/src/arch/x86/emulator/instructions/mod.rs
@@ -56,7 +56,7 @@ fn get_op<T: CpuStateManager>(
        OpKind::Immediate16 => insn.immediate16() as u64,
        OpKind::Immediate32 => insn.immediate32() as u64,
        OpKind::Immediate32to64 => insn.immediate32to64() as u64,
-        OpKind::Immediate64 => insn.immediate64() as u64,
+        OpKind::Immediate64 => insn.immediate64(),
        k => return Err(PlatformError::InvalidOperand(anyhow!("{:?}", k))),
    };

--- a/hypervisor/src/arch/x86/mod.rs
+++ b/hypervisor/src/arch/x86/mod.rs
@@ -272,6 +272,7 @@ impl LapicState {
        use std::io::Cursor;
        use std::mem;

+        // SAFETY: plain old data type
        let sliceu8 = unsafe {
            // This array is only accessed as parts of a u32 word, so interpret it as a u8 array.
            // Cursors are only readable on arrays of u8, not i8(c_char).
@@ -290,6 +291,7 @@ impl LapicState {
        use std::io::Cursor;
        use std::mem;

+        // SAFETY: plain old data type
        let sliceu8 = unsafe {
            // This array is only accessed as parts of a u32 word, so interpret it as a u8 array.
            // Cursors are only readable on arrays of u8, not i8(c_char).
--- a/hypervisor/src/cpu.rs
+++ b/hypervisor/src/cpu.rs
@@ -48,12 +48,12 @@ pub enum HypervisorCpuError {
    ///
    /// Setting floating point registers error
    ///
-    #[error("Failed to set special register: {0}")]
+    #[error("Failed to set floating point registers: {0}")]
    SetFloatingPointRegs(#[source] anyhow::Error),
    ///
    /// Getting floating point register error
    ///
-    #[error("Failed to get special register: {0}")]
+    #[error("Failed to get floating points registers: {0}")]
    GetFloatingPointRegs(#[source] anyhow::Error),
    ///
    /// Setting Cpuid error
--- a/hypervisor/src/kvm/aarch64/gic/redist_regs.rs
+++ b/hypervisor/src/kvm/aarch64/gic/redist_regs.rs
@@ -39,8 +39,8 @@ const GICR_ICFGR0: u32 = GICR_SGI_OFFSET + 0x0C00;
 const KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT: u32 = 32;
 const KVM_DEV_ARM_VGIC_V3_MPIDR_MASK: u64 = 0xffffffff << KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT as u64;

-const KVM_ARM64_SYSREG_MPIDR_EL1: u64 = KVM_REG_ARM64 as u64
-    | KVM_REG_SIZE_U64 as u64
+const KVM_ARM64_SYSREG_MPIDR_EL1: u64 = KVM_REG_ARM64
+    | KVM_REG_SIZE_U64
    | KVM_REG_ARM64_SYSREG as u64
    | (((3_u64) << KVM_REG_ARM64_SYSREG_OP0_SHIFT) & KVM_REG_ARM64_SYSREG_OP0_MASK as u64)
    | (((5_u64) << KVM_REG_ARM64_SYSREG_OP2_SHIFT) & KVM_REG_ARM64_SYSREG_OP2_MASK as u64);
--- a/hypervisor/src/kvm/aarch64/mod.rs
+++ b/hypervisor/src/kvm/aarch64/mod.rs
@@ -24,8 +24,8 @@ pub use {kvm_ioctls::Cap, kvm_ioctls::Kvm};
 // This macro gets the offset of a structure (i.e `str`) member (i.e `field`) without having
 // an instance of that structure.
 #[macro_export]
-macro_rules! offset__of {
-    ($str:ty, $($field:ident)+) => ({
+macro_rules! offset_of {
+    ($str:ty, $field:ident) => {{
        let tmp: std::mem::MaybeUninit<$str> = std::mem::MaybeUninit::uninit();
        let base = tmp.as_ptr();

@@ -34,14 +34,16 @@ macro_rules! offset__of {
        // SAFETY: The pointer is valid and aligned, just not initialised. Using `addr_of` ensures
        // that we don't actually read from `base` (which would be UB) nor create an intermediate
        // reference.
-        let member = unsafe { core::ptr::addr_of!((*base).$($field)*) } as *const u8;
+        let member = unsafe { core::ptr::addr_of!((*base).$field) } as *const u8;

        // Avoid warnings when nesting `unsafe` blocks.
        #[allow(unused_unsafe)]
        // SAFETY: The two pointers are within the same allocated object `tmp`. All requirements
        // from offset_from are upheld.
-        unsafe { member.offset_from(base as *const u8) as usize }
-    });
+        unsafe {
+            member.offset_from(base as *const u8) as usize
+        }
+    }};
 }

 // Following are macros that help with getting the ID of a aarch64 core register.
@@ -97,8 +99,7 @@ pub fn is_system_register(regid: u64) -> bool {

    assert!(
        !(size != KVM_REG_SIZE_U32 && size != KVM_REG_SIZE_U64),
-        "Unexpected register size for system register {}",
-        size
+        "Unexpected register size for system register {size}"
    );

    true
--- a/hypervisor/src/kvm/mod.rs
+++ b/hypervisor/src/kvm/mod.rs
@@ -23,7 +23,7 @@ use crate::vec_with_array_field;
 use crate::vm::{self, InterruptSourceConfig, VmOps};
 use crate::HypervisorType;
 #[cfg(target_arch = "aarch64")]
-use crate::{arm64_core_reg_id, offset__of};
+use crate::{arm64_core_reg_id, offset_of};
 use kvm_ioctls::{NoDatamatch, VcpuFd, VmFd};
 use std::any::Any;
 use std::collections::HashMap;
@@ -1114,7 +1114,7 @@ impl cpu::Vcpu for KvmVcpu {
    #[cfg(target_arch = "aarch64")]
    fn get_regs(&self) -> cpu::Result<StandardRegisters> {
        let mut state: StandardRegisters = kvm_regs::default();
-        let mut off = offset__of!(user_pt_regs, regs);
+        let mut off = offset_of!(user_pt_regs, regs);
        // There are 31 user_pt_regs:
        // https://elixir.free-electrons.com/linux/v4.14.174/source/arch/arm64/include/uapi/asm/ptrace.h#L72
        // These actually are the general-purpose registers of the Armv8-a
@@ -1131,7 +1131,7 @@ impl cpu::Vcpu for KvmVcpu {

        // We are now entering the "Other register" section of the ARMv8-a architecture.
        // First one, stack pointer.
-        let off = offset__of!(user_pt_regs, sp);
+        let off = offset_of!(user_pt_regs, sp);
        state.regs.sp = self
            .fd
            .get_one_reg(arm64_core_reg_id!(KVM_REG_SIZE_U64, off))
@@ -1140,7 +1140,7 @@ impl cpu::Vcpu for KvmVcpu {
            .unwrap();

        // Second one, the program counter.
-        let off = offset__of!(user_pt_regs, pc);
+        let off = offset_of!(user_pt_regs, pc);
        state.regs.pc = self
            .fd
            .get_one_reg(arm64_core_reg_id!(KVM_REG_SIZE_U64, off))
@@ -1149,7 +1149,7 @@ impl cpu::Vcpu for KvmVcpu {
            .unwrap();

        // Next is the processor state.
-        let off = offset__of!(user_pt_regs, pstate);
+        let off = offset_of!(user_pt_regs, pstate);
        state.regs.pstate = self
            .fd
            .get_one_reg(arm64_core_reg_id!(KVM_REG_SIZE_U64, off))
@@ -1158,7 +1158,7 @@ impl cpu::Vcpu for KvmVcpu {
            .unwrap();

        // The stack pointer associated with EL1
-        let off = offset__of!(kvm_regs, sp_el1);
+        let off = offset_of!(kvm_regs, sp_el1);
        state.sp_el1 = self
            .fd
            .get_one_reg(arm64_core_reg_id!(KVM_REG_SIZE_U64, off))
@@ -1168,7 +1168,7 @@ impl cpu::Vcpu for KvmVcpu {

        // Exception Link Register for EL1, when taking an exception to EL1, this register
        // holds the address to which to return afterwards.
-        let off = offset__of!(kvm_regs, elr_el1);
+        let off = offset_of!(kvm_regs, elr_el1);
        state.elr_el1 = self
            .fd
            .get_one_reg(arm64_core_reg_id!(KVM_REG_SIZE_U64, off))
@@ -1177,7 +1177,7 @@ impl cpu::Vcpu for KvmVcpu {
            .unwrap();

        // Saved Program Status Registers, there are 5 of them used in the kernel.
-        let mut off = offset__of!(kvm_regs, spsr);
+        let mut off = offset_of!(kvm_regs, spsr);
        for i in 0..KVM_NR_SPSR as usize {
            state.spsr[i] = self
                .fd
@@ -1190,7 +1190,7 @@ impl cpu::Vcpu for KvmVcpu {

        // Now moving on to floting 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);
+        let mut off = offset_of!(kvm_regs, fp_regs) + offset_of!(user_fpsimd_state, vregs);
        for i in 0..32 {
            state.fp_regs.vregs[i] = self
                .fd
@@ -1200,7 +1200,7 @@ impl cpu::Vcpu for KvmVcpu {
        }

        // Floating-point Status Register
-        let off = offset__of!(kvm_regs, fp_regs) + offset__of!(user_fpsimd_state, fpsr);
+        let off = offset_of!(kvm_regs, fp_regs) + offset_of!(user_fpsimd_state, fpsr);
        state.fp_regs.fpsr = self
            .fd
            .get_one_reg(arm64_core_reg_id!(KVM_REG_SIZE_U32, off))
@@ -1209,7 +1209,7 @@ impl cpu::Vcpu for KvmVcpu {
            .unwrap();

        // Floating-point Control Register
-        let off = offset__of!(kvm_regs, fp_regs) + offset__of!(user_fpsimd_state, fpcr);
+        let off = offset_of!(kvm_regs, fp_regs) + offset_of!(user_fpsimd_state, fpcr);
        state.fp_regs.fpcr = self
            .fd
            .get_one_reg(arm64_core_reg_id!(KVM_REG_SIZE_U32, off))
@@ -1238,7 +1238,7 @@ impl cpu::Vcpu for KvmVcpu {
    fn set_regs(&self, state: &StandardRegisters) -> cpu::Result<()> {
        // The function follows the exact identical order from `state`. Look there
        // for some additional info on registers.
-        let mut off = offset__of!(user_pt_regs, regs);
+        let mut off = offset_of!(user_pt_regs, regs);
        for i in 0..31 {
            self.fd
                .set_one_reg(
@@ -1249,7 +1249,7 @@ impl cpu::Vcpu for KvmVcpu {
            off += std::mem::size_of::<u64>();
        }

-        let off = offset__of!(user_pt_regs, sp);
+        let off = offset_of!(user_pt_regs, sp);
        self.fd
            .set_one_reg(
                arm64_core_reg_id!(KVM_REG_SIZE_U64, off),
@@ -1257,7 +1257,7 @@ impl cpu::Vcpu for KvmVcpu {
            )
            .map_err(|e| cpu::HypervisorCpuError::SetCoreRegister(e.into()))?;

-        let off = offset__of!(user_pt_regs, pc);
+        let off = offset_of!(user_pt_regs, pc);
        self.fd
            .set_one_reg(
                arm64_core_reg_id!(KVM_REG_SIZE_U64, off),
@@ -1265,7 +1265,7 @@ impl cpu::Vcpu for KvmVcpu {
            )
            .map_err(|e| cpu::HypervisorCpuError::SetCoreRegister(e.into()))?;

-        let off = offset__of!(user_pt_regs, pstate);
+        let off = offset_of!(user_pt_regs, pstate);
        self.fd
            .set_one_reg(
                arm64_core_reg_id!(KVM_REG_SIZE_U64, off),
@@ -1273,7 +1273,7 @@ impl cpu::Vcpu for KvmVcpu {
            )
            .map_err(|e| cpu::HypervisorCpuError::SetCoreRegister(e.into()))?;

-        let off = offset__of!(kvm_regs, sp_el1);
+        let off = offset_of!(kvm_regs, sp_el1);
        self.fd
            .set_one_reg(
                arm64_core_reg_id!(KVM_REG_SIZE_U64, off),
@@ -1281,7 +1281,7 @@ impl cpu::Vcpu for KvmVcpu {
            )
            .map_err(|e| cpu::HypervisorCpuError::SetCoreRegister(e.into()))?;

-        let off = offset__of!(kvm_regs, elr_el1);
+        let off = offset_of!(kvm_regs, elr_el1);
        self.fd
            .set_one_reg(
                arm64_core_reg_id!(KVM_REG_SIZE_U64, off),
@@ -1289,7 +1289,7 @@ impl cpu::Vcpu for KvmVcpu {
            )
            .map_err(|e| cpu::HypervisorCpuError::SetCoreRegister(e.into()))?;

-        let mut off = offset__of!(kvm_regs, spsr);
+        let mut off = offset_of!(kvm_regs, spsr);
        for i in 0..KVM_NR_SPSR as usize {
            self.fd
                .set_one_reg(
@@ -1300,7 +1300,7 @@ impl cpu::Vcpu for KvmVcpu {
            off += std::mem::size_of::<u64>();
        }

-        let mut off = offset__of!(kvm_regs, fp_regs) + offset__of!(user_fpsimd_state, vregs);
+        let mut off = offset_of!(kvm_regs, fp_regs) + offset_of!(user_fpsimd_state, vregs);
        for i in 0..32 {
            self.fd
                .set_one_reg(
@@ -1311,7 +1311,7 @@ impl cpu::Vcpu for KvmVcpu {
            off += mem::size_of::<u128>();
        }

-        let off = offset__of!(kvm_regs, fp_regs) + offset__of!(user_fpsimd_state, fpsr);
+        let off = offset_of!(kvm_regs, fp_regs) + offset_of!(user_fpsimd_state, fpsr);
        self.fd
            .set_one_reg(
                arm64_core_reg_id!(KVM_REG_SIZE_U32, off),
@@ -1319,7 +1319,7 @@ impl cpu::Vcpu for KvmVcpu {
            )
            .map_err(|e| cpu::HypervisorCpuError::SetCoreRegister(e.into()))?;

-        let off = offset__of!(kvm_regs, fp_regs) + offset__of!(user_fpsimd_state, fpcr);
+        let off = offset_of!(kvm_regs, fp_regs) + offset_of!(user_fpsimd_state, fpcr);
        self.fd
            .set_one_reg(
                arm64_core_reg_id!(KVM_REG_SIZE_U32, off),
@@ -1700,8 +1700,8 @@ impl cpu::Vcpu for KvmVcpu {
        // it to the corresponding KVM ID, and call `KVM_GET_ONE_REG` API to
        // get the value of the system parameter.
        //
-        let id: u64 = KVM_REG_ARM64 as u64
-            | KVM_REG_SIZE_U64 as u64
+        let id: u64 = KVM_REG_ARM64
+            | KVM_REG_SIZE_U64
            | KVM_REG_ARM64_SYSREG as u64
            | ((((sys_reg) >> 5)
                & (KVM_REG_ARM64_SYSREG_OP0_MASK
@@ -1733,10 +1733,10 @@ impl cpu::Vcpu for KvmVcpu {
        const PSTATE_FAULT_BITS_64: u64 =
            PSR_MODE_EL1h | PSR_A_BIT | PSR_F_BIT | PSR_I_BIT | PSR_D_BIT;

-        let kreg_off = offset__of!(kvm_regs, regs);
+        let kreg_off = offset_of!(kvm_regs, regs);

        // Get the register index of the PSTATE (Processor State) register.
-        let pstate = offset__of!(user_pt_regs, pstate) + kreg_off;
+        let pstate = offset_of!(user_pt_regs, pstate) + kreg_off;
        self.fd
            .set_one_reg(
                arm64_core_reg_id!(KVM_REG_SIZE_U64, pstate),
@@ -1747,7 +1747,7 @@ impl cpu::Vcpu for KvmVcpu {
        // Other vCPUs are powered off initially awaiting PSCI wakeup.
        if cpu_id == 0 {
            // Setting the PC (Processor Counter) to the current program address (kernel address).
-            let pc = offset__of!(user_pt_regs, pc) + kreg_off;
+            let pc = offset_of!(user_pt_regs, pc) + kreg_off;
            self.fd
                .set_one_reg(arm64_core_reg_id!(KVM_REG_SIZE_U64, pc), boot_ip.into())
                .map_err(|e| cpu::HypervisorCpuError::SetCoreRegister(e.into()))?;
@@ -1756,7 +1756,7 @@ impl cpu::Vcpu for KvmVcpu {
            // "The device tree blob (dtb) must be placed on an 8-byte boundary and must
            // not exceed 2 megabytes in size." -> https://www.kernel.org/doc/Documentation/arm64/booting.txt.
            // We are choosing to place it the end of DRAM. See `get_fdt_addr`.
-            let regs0 = offset__of!(user_pt_regs, regs) + kreg_off;
+            let regs0 = offset_of!(user_pt_regs, regs) + kreg_off;
            self.fd
                .set_one_reg(
                    arm64_core_reg_id!(KVM_REG_SIZE_U64, regs0),
@@ -2066,6 +2066,7 @@ impl cpu::Vcpu for KvmVcpu {
    #[cfg(feature = "tdx")]
    fn get_tdx_exit_details(&mut self) -> cpu::Result<TdxExitDetails> {
        let kvm_run = self.fd.get_kvm_run();
+        // SAFETY: accessing a union field in a valid structure
        let tdx_vmcall = unsafe { &mut kvm_run.__bindgen_anon_1.tdx.u.vmcall };

        tdx_vmcall.status_code = TDG_VP_VMCALL_INVALID_OPERAND;
@@ -2089,6 +2090,7 @@ impl cpu::Vcpu for KvmVcpu {
    #[cfg(feature = "tdx")]
    fn set_tdx_status(&mut self, status: TdxExitStatus) {
        let kvm_run = self.fd.get_kvm_run();
+        // SAFETY: accessing a union field in a valid structure
        let tdx_vmcall = unsafe { &mut kvm_run.__bindgen_anon_1.tdx.u.vmcall };

        tdx_vmcall.status_code = match status {
--- a/hypervisor/src/lib.rs
+++ b/hypervisor/src/lib.rs
@@ -18,8 +18,6 @@
 //! - arm64
 //!

-#![allow(clippy::significant_drop_in_scrutinee)]
-
 #[macro_use]
 extern crate anyhow;
 #[cfg(target_arch = "x86_64")]
@@ -63,7 +61,9 @@ pub use vm::{

 #[derive(Debug, Copy, Clone)]
 pub enum HypervisorType {
+    #[cfg(feature = "kvm")]
    Kvm,
+    #[cfg(feature = "mshv")]
    Mshv,
 }

--- a/hypervisor/src/mshv/mod.rs
+++ b/hypervisor/src/mshv/mod.rs
@@ -446,10 +446,10 @@ impl cpu::Vcpu for MshvVcpu {
                            /* Advance RIP and update RAX */
                            let arr_reg_name_value = [
                                (
-                                    hv_register_name::HV_X64_REGISTER_RIP,
+                                    hv_x64_register_name_HV_X64_REGISTER_RIP,
                                    info.header.rip + insn_len,
                                ),
-                                (hv_register_name::HV_X64_REGISTER_RAX, ret_rax),
+                                (hv_x64_register_name_HV_X64_REGISTER_RAX, ret_rax),
                            ];
                            set_registers_64!(self.fd, arr_reg_name_value)
                                .map_err(|e| cpu::HypervisorCpuError::SetRegister(e.into()))?;
@@ -458,12 +458,13 @@ impl cpu::Vcpu for MshvVcpu {
                        _ => {}
                    }

-                    // SAFETY: access_info is valid, otherwise we won't be here
                    assert!(
+                        // SAFETY: access_info is valid, otherwise we won't be here
                        (unsafe { access_info.__bindgen_anon_1.string_op() } != 1),
                        "String IN/OUT not supported"
                    );
                    assert!(
+                        // SAFETY: access_info is valid, otherwise we won't be here
                        (unsafe { access_info.__bindgen_anon_1.rep_prefix() } != 1),
                        "Rep IN/OUT not supported"
                    );
@@ -494,10 +495,10 @@ impl cpu::Vcpu for MshvVcpu {
                    /* Advance RIP and update RAX */
                    let arr_reg_name_value = [
                        (
-                            hv_register_name::HV_X64_REGISTER_RIP,
+                            hv_x64_register_name_HV_X64_REGISTER_RIP,
                            info.header.rip + insn_len,
                        ),
-                        (hv_register_name::HV_X64_REGISTER_RAX, ret_rax),
+                        (hv_x64_register_name_HV_X64_REGISTER_RAX, ret_rax),
                    ];
                    set_registers_64!(self.fd, arr_reg_name_value)
                        .map_err(|e| cpu::HypervisorCpuError::SetRegister(e.into()))?;
@@ -703,7 +704,6 @@ impl cpu::Vcpu for MshvVcpu {
            msr!(msr_index::MSR_LSTAR),
            msr!(msr_index::MSR_KERNEL_GS_BASE),
            msr!(msr_index::MSR_SYSCALL_MASK),
-            msr!(msr_index::MSR_IA32_TSC),
            msr_data!(msr_index::MSR_MTRRdefType, MTRR_ENABLE | MTRR_MEM_TYPE_WB),
        ]
        .to_vec()
@@ -1093,7 +1093,7 @@ impl vm::Vm for MshvVm {
            flags,
            guest_pfn: guest_phys_addr >> PAGE_SHIFT,
            size: memory_size,
-            userspace_addr: userspace_addr as u64,
+            userspace_addr,
        }
        .into()
    }
--- a/net_gen/Cargo.toml
+++ b/net_gen/Cargo.toml
@@ -5,4 +5,4 @@ authors = ["The Chromium OS Authors"]
 edition = "2021"

 [dependencies]
-vmm-sys-util = "0.10.0"
+vmm-sys-util = "0.11.0"
--- a/net_gen/src/iff.rs
+++ b/net_gen/src/iff.rs
@@ -1187,6 +1187,7 @@ pub struct ifreq {

 impl Default for ifreq {
    fn default() -> Self {
+        // SAFETY: all zeros is a valid pattern for this data type
        unsafe { std::mem::zeroed() }
    }
 }
--- a/net_util/Cargo.toml
+++ b/net_util/Cargo.toml
@@ -6,23 +6,23 @@ edition = "2021"

 [dependencies]
 epoll = "4.3.1"
-getrandom = "0.2.7"
-libc = "0.2.133"
+getrandom = "0.2.8"
+libc = "0.2.139"
 log = "0.4.17"
 net_gen = { path = "../net_gen" }
 rate_limiter = { path = "../rate_limiter" }
-serde = "1.0.145"
-thiserror = "1.0.37"
-versionize = "0.1.6"
+serde = "1.0.151"
+thiserror = "1.0.38"
+versionize = "0.1.9"
 versionize_derive = "0.1.4"
 virtio-bindings = "0.1.0"
-virtio-queue = "0.6.1"
-vm-memory = { version = "0.9.0", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
+virtio-queue = "0.7.0"
+vm-memory = { version = "0.10.0", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
 vm-virtio = { path = "../vm-virtio" }
-vmm-sys-util = "0.10.0"
+vmm-sys-util = "0.11.0"

 [dev-dependencies]
-once_cell = "1.15.0"
+once_cell = "1.16.0"
 pnet = "0.31.0"
 pnet_datalink = "0.31.0"
-serde_json = "1.0.85"
+serde_json = "1.0.89"
--- a/net_util/src/lib.rs
+++ b/net_util/src/lib.rs
@@ -66,32 +66,34 @@ fn create_sockaddr(ip_addr: net::Ipv4Addr) -> net_gen::sockaddr {
    let addr_in = net_gen::sockaddr_in {
        sin_family: net_gen::AF_INET as u16,
        sin_port: 0,
+        // SAFETY: ip_addr can be safely transmute to in_addr
        sin_addr: unsafe { mem::transmute(ip_addr.octets()) },
        __pad: [0; 8usize],
    };

+    // SAFETY: addr_in can be safely transmute to sockaddr
    unsafe { mem::transmute(addr_in) }
 }

 fn create_inet_socket() -> Result<net::UdpSocket> {
-    // This is safe since we check the return value.
+    // SAFETY: we check the return value.
    let sock = unsafe { libc::socket(libc::AF_INET, libc::SOCK_DGRAM, 0) };
    if sock < 0 {
        return Err(Error::CreateSocket(IoError::last_os_error()));
    }

-    // This is safe; nothing else will use or hold onto the raw sock fd.
+    // SAFETY: nothing else will use or hold onto the raw sock fd.
    Ok(unsafe { net::UdpSocket::from_raw_fd(sock) })
 }

 fn create_unix_socket() -> Result<net::UdpSocket> {
-    // This is safe since we check the return value.
+    // SAFETY: we check the return value.
    let sock = unsafe { libc::socket(libc::AF_UNIX, libc::SOCK_DGRAM, 0) };
    if sock < 0 {
        return Err(Error::CreateSocket(IoError::last_os_error()));
    }

-    // This is safe; nothing else will use or hold onto the raw sock fd.
+    // SAFETY: nothing else will use or hold onto the raw sock fd.
    Ok(unsafe { net::UdpSocket::from_raw_fd(sock) })
 }

--- a/net_util/src/mac.rs
+++ b/net_util/src/mac.rs
@@ -125,7 +125,7 @@ impl<'de> Deserialize<'de> for MacAddr {
    {
        let s = String::deserialize(deserializer)?;
        MacAddr::parse_str(&s)
-            .map_err(|e| D::Error::custom(format!("The provided MAC address is invalid: {}", e)))
+            .map_err(|e| D::Error::custom(format!("The provided MAC address is invalid: {e}")))
    }
 }

@@ -161,7 +161,7 @@ mod tests {

        let mac = MacAddr::parse_str("12:34:56:78:9a:BC").unwrap();

-        println!("parsed MAC address: {}", mac);
+        println!("parsed MAC address: {mac}");

        let bytes = mac.get_bytes();
        assert_eq!(bytes, [0x12u8, 0x34, 0x56, 0x78, 0x9a, 0xbc]);
--- a/net_util/src/open_tap.rs
+++ b/net_util/src/open_tap.rs
@@ -12,9 +12,9 @@ use thiserror::Error;
 pub enum Error {
    #[error("Failed to convert an hexadecimal string into an integer: {0}")]
    ConvertHexStringToInt(std::num::ParseIntError),
-    #[error("Error related to the multiqueue support (no support TAP side).")]
+    #[error("Error related to the multiqueue support (no support TAP side)")]
    MultiQueueNoTapSupport,
-    #[error("Error related to the multiqueue support (no support device side).")]
+    #[error("Error related to the multiqueue support (no support device side)")]
    MultiQueueNoDeviceSupport,
    #[error("Failed to read the TAP flags from sysfs: {0}")]
    ReadSysfsTunFlags(io::Error),
@@ -41,7 +41,7 @@ type Result<T> = std::result::Result<T, Error>;
 fn check_mq_support(if_name: &Option<&str>, queue_pairs: usize) -> Result<()> {
    if let Some(tap_name) = if_name {
        let mq = queue_pairs > 1;
-        let path = format!("/sys/class/net/{}/tun_flags", tap_name);
+        let path = format!("/sys/class/net/{tap_name}/tun_flags");
        // interface does not exist, check is not required
        if !Path::new(&path).exists() {
            return Ok(());
--- a/net_util/src/queue_pair.rs
+++ b/net_util/src/queue_pair.rs
@@ -83,6 +83,7 @@ impl TxVirtio {
            }

            let len = if !iovecs.is_empty() {
+                // SAFETY: FFI call with correct arguments
                let result = unsafe {
                    libc::writev(
                        tap.as_raw_fd() as libc::c_int,
@@ -104,6 +105,10 @@ impl TxVirtio {
                    return Err(NetQueuePairError::WriteTap(e));
                }

+                if (result as usize) < vnet_hdr_len() {
+                    return Err(NetQueuePairError::InvalidVirtioNetHeader);
+                }
+
                self.counter_bytes += Wrapping(result as u64 - vnet_hdr_len() as u64);
                self.counter_frames += Wrapping(1);

@@ -185,7 +190,7 @@ impl RxVirtio {
                        .translate_gva(access_platform, desc.len() as usize),
                    10,
                )
-                .unwrap();
+                .ok_or(NetQueuePairError::DescriptorInvalidHeader)?;
            let mut next_desc = Some(desc);

            let mut iovecs = Vec::new();
@@ -217,6 +222,7 @@ impl RxVirtio {
            }

            let len = if !iovecs.is_empty() {
+                // SAFETY: FFI call with correct arguments
                let result = unsafe {
                    libc::readv(
                        tap.as_raw_fd() as libc::c_int,
@@ -238,6 +244,10 @@ impl RxVirtio {
                    return Err(NetQueuePairError::ReadTap(e));
                }

+                if (result as usize) < vnet_hdr_len() {
+                    return Err(NetQueuePairError::InvalidVirtioNetHeader);
+                }
+
                // Write num_buffers to guest memory. We simply write 1 as we
                // never spread the frame over more than one descriptor chain.
                desc_chain
@@ -288,7 +298,7 @@ pub struct NetCounters {

 #[derive(Error, Debug)]
 pub enum NetQueuePairError {
-    #[error("No memory configured.")]
+    #[error("No memory configured")]
    NoMemoryConfigured,
    #[error("Error registering listener: {0}")]
    RegisterListener(io::Error),
@@ -302,9 +312,9 @@ pub enum NetQueuePairError {
    GuestMemory(vm_memory::GuestMemoryError),
    #[error("Returned an error while iterating through the queue: {0}")]
    QueueIteratorFailed(virtio_queue::Error),
-    #[error("Descriptor chain is too short.")]
+    #[error("Descriptor chain is too short")]
    DescriptorChainTooShort,
-    #[error("Descriptor chain does not contain valid descriptors.")]
+    #[error("Descriptor chain does not contain valid descriptors")]
    DescriptorChainInvalid,
    #[error("Failed to determine if queue needed notification: {0}")]
    QueueNeedsNotification(virtio_queue::Error),
@@ -312,6 +322,10 @@ pub enum NetQueuePairError {
    QueueEnableNotification(virtio_queue::Error),
    #[error("Failed to add used index to the queue: {0}")]
    QueueAddUsed(virtio_queue::Error),
+    #[error("Descriptor with invalid virtio-net header")]
+    DescriptorInvalidHeader,
+    #[error("Invalid virtio-net header")]
+    InvalidVirtioNetHeader,
 }

 pub struct NetQueuePair {
--- a/net_util/src/tap.rs
+++ b/net_util/src/tap.rs
@@ -26,13 +26,13 @@ pub enum Error {
    ConfigureTap(IoError),
    #[error("Unable to retrieve features: {0}")]
    GetFeatures(IoError),
-    #[error("Missing multiqueue support in the kernel.")]
+    #[error("Missing multiqueue support in the kernel")]
    MultiQueueKernelSupport,
-    #[error("ioctl failed: {0}")]
-    IoctlError(IoError),
+    #[error("ioctl ({0}) failed: {1}")]
+    IoctlError(c_ulong, IoError),
    #[error("Failed to create a socket: {0}")]
    NetUtil(NetUtilError),
-    #[error("Invalid interface name.")]
+    #[error("Invalid interface name")]
    InvalidIfname,
    #[error("Error parsing MAC data: {0}")]
    MacParsing(IoError),
@@ -87,9 +87,37 @@ fn build_terminated_if_name(if_name: &str) -> Result<Vec<u8>> {
 }

 impl Tap {
+    unsafe fn ioctl_with_mut_ref<F: AsRawFd, T>(fd: &F, req: c_ulong, arg: &mut T) -> Result<()> {
+        let ret = ioctl_with_mut_ref(fd, req, arg);
+        if ret < 0 {
+            return Err(Error::IoctlError(req, IoError::last_os_error()));
+        }
+
+        Ok(())
+    }
+
+    unsafe fn ioctl_with_ref<F: AsRawFd, T>(fd: &F, req: c_ulong, arg: &T) -> Result<()> {
+        let ret = ioctl_with_ref(fd, req, arg);
+        if ret < 0 {
+            return Err(Error::IoctlError(req, IoError::last_os_error()));
+        }
+
+        Ok(())
+    }
+
+    unsafe fn ioctl_with_val<F: AsRawFd>(fd: &F, req: c_ulong, arg: c_ulong) -> Result<()> {
+        let ret = ioctl_with_val(fd, req, arg);
+        if ret < 0 {
+            return Err(Error::IoctlError(req, IoError::last_os_error()));
+        }
+
+        Ok(())
+    }
+
    pub fn open_named(if_name: &str, num_queue_pairs: usize, flags: Option<i32>) -> Result<Tap> {
        let terminated_if_name = build_terminated_if_name(if_name)?;

+        // SAFETY: FFI call
        let fd = unsafe {
            // Open calls are safe because we give a constant null-terminated
            // string and verify the result.
@@ -102,13 +130,14 @@ impl Tap {
            return Err(Error::OpenTun(IoError::last_os_error()));
        }

-        // We just checked that the fd is valid.
+        // SAFETY: We just checked that the fd is valid.
        let tuntap = unsafe { File::from_raw_fd(fd) };

        // Let's validate some features before going any further.
        // ioctl is safe since we call it with a valid tap fd and check the return
        // value.
        let mut features = 0;
+        // SAFETY: IOCTL with correct arguments
        let ret = unsafe { ioctl_with_mut_ref(&tuntap, net_gen::TUNGETFEATURES(), &mut features) };
        if ret < 0 {
            return Err(Error::GetFeatures(IoError::last_os_error()));
@@ -123,6 +152,7 @@ impl Tap {
        // don't call as_mut on the same union field more than once, this block
        // is safe.
        let mut ifreq: net_gen::ifreq = Default::default();
+        // SAFETY: see the comment above.
        unsafe {
            let ifrn_name = ifreq.ifr_ifrn.ifrn_name.as_mut();
            let name_slice = &mut ifrn_name[..terminated_if_name.len()];
@@ -134,16 +164,16 @@ impl Tap {
            }
        }

-        // ioctl is safe since we call it with a valid tap fd and check the return
+        // SAFETY: ioctl is safe since we call it with a valid tap fd and check the return
        // value.
        let ret = unsafe { ioctl_with_mut_ref(&tuntap, net_gen::TUNSETIFF(), &mut ifreq) };
        if ret < 0 {
            return Err(Error::ConfigureTap(IoError::last_os_error()));
        }

+        // SAFETY: only the name is accessed, and it's cloned out.
        let mut if_name = unsafe { ifreq.ifr_ifrn.ifrn_name }.to_vec();
        if_name.truncate(terminated_if_name.len() - 1);
-        // Safe since only the name is accessed, and it's cloned out.
        Ok(Tap {
            tap_file: tuntap,
            if_name,
@@ -158,6 +188,7 @@ impl Tap {
    pub fn from_tap_fd(fd: RawFd, num_queue_pairs: usize) -> Result<Tap> {
        // Ensure that the file is opened non-blocking, this is particularly
        // needed when opened via the shell for macvtap.
+        // SAFETY: FFI call
        let ret = unsafe {
            let mut flags = libc::fcntl(fd, libc::F_GETFL);
            flags |= libc::O_NONBLOCK;
@@ -167,19 +198,20 @@ impl Tap {
            return Err(Error::ConfigureTap(IoError::last_os_error()));
        }

+        // SAFETY: fd is a tap fd
        let tap_file = unsafe { File::from_raw_fd(fd) };
        let mut ifreq: net_gen::ifreq = Default::default();

        // Get current config including name
-        let ret = unsafe { ioctl_with_mut_ref(&tap_file, net_gen::TUNGETIFF(), &mut ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
-        // We only access one field of the ifru union, hence this is safe.
+        // SAFETY: IOCTL with correct arugments
+        unsafe { Self::ioctl_with_mut_ref(&tap_file, net_gen::TUNGETIFF(), &mut ifreq)? };
+
+        // SAFETY: We only access one field of the ifru union
        let if_name = unsafe { ifreq.ifr_ifrn.ifrn_name }.to_vec();

        // Try and update flags. Depending on how the tap was created (macvtap
        // or via open_named()) this might return -EEXIST so we just ignore that.
+        // SAFETY: access union fields
        unsafe {
            ifreq.ifr_ifru.ifru_flags =
                (net_gen::IFF_TAP | net_gen::IFF_NO_PI | net_gen::IFF_VNET_HDR) as c_short;
@@ -187,6 +219,7 @@ impl Tap {
                ifreq.ifr_ifru.ifru_flags |= net_gen::IFF_MULTI_QUEUE as c_short;
            }
        }
+        // SAFETY: IOCTL with correct arguments
        let ret = unsafe { ioctl_with_mut_ref(&tap_file, net_gen::TUNSETIFF(), &mut ifreq) };
        if ret < 0 && IoError::last_os_error().raw_os_error().unwrap() != libc::EEXIST {
            return Err(Error::ConfigureTap(IoError::last_os_error()));
@@ -208,14 +241,8 @@ impl Tap {

        ifreq.ifr_ifru.ifru_addr = addr;

-        // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret =
-            unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFADDR as c_ulong, &ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
-
-        Ok(())
+        // SAFETY: ioctl is safe. Called with a valid sock fd, and we check the return.
+        unsafe { Self::ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFADDR as c_ulong, &ifreq) }
    }

    /// Set mac addr for tap interface.
@@ -233,13 +260,10 @@ impl Tap {

        let mut ifreq = self.get_ifreq();

-        // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret =
-            unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCGIFHWADDR as c_ulong, &ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
-        // We only access one field of the ifru union, hence this is safe.
+        // SAFETY: ioctl is safe. Called with a valid sock fd, and we check the return.
+        unsafe { Self::ioctl_with_ref(&sock, net_gen::sockios::SIOCGIFHWADDR as c_ulong, &ifreq)? };
+
+        // SAFETY: We only access one field of the ifru union
        unsafe {
            let ifru_hwaddr = &mut ifreq.ifr_ifru.ifru_hwaddr;
            for (i, v) in addr.get_bytes().iter().enumerate() {
@@ -247,14 +271,8 @@ impl Tap {
            }
        }

-        // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret =
-            unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFHWADDR as c_ulong, &ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
-
-        Ok(())
+        // SAFETY: ioctl is safe. Called with a valid sock fd, and we check the return.
+        unsafe { Self::ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFHWADDR as c_ulong, &ifreq) }
    }

    /// Get mac addr for tap interface.
@@ -263,14 +281,10 @@ impl Tap {

        let ifreq = self.get_ifreq();

-        // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret =
-            unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCGIFHWADDR as c_ulong, &ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
+        // SAFETY: ioctl is safe. Called with a valid sock fd, and we check the return.
+        unsafe { Self::ioctl_with_ref(&sock, net_gen::sockios::SIOCGIFHWADDR as c_ulong, &ifreq)? };

-        // We only access one field of the ifru union, hence this is safe.
+        // SAFETY: We only access one field of the ifru union
        let addr = unsafe {
            MacAddr::from_bytes(&ifreq.ifr_ifru.ifru_hwaddr.sa_data[0..MAC_ADDR_LEN])
                .map_err(Error::MacParsing)?
@@ -287,57 +301,45 @@ impl Tap {

        ifreq.ifr_ifru.ifru_addr = addr;

-        // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret =
-            unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFNETMASK as c_ulong, &ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
-
-        Ok(())
+        // SAFETY: ioctl is safe. Called with a valid sock fd, and we check the return.
+        unsafe { Self::ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFNETMASK as c_ulong, &ifreq) }
    }

+    #[cfg(not(fuzzing))]
    pub fn mtu(&self) -> Result<i32> {
        let sock = create_unix_socket().map_err(Error::NetUtil)?;

        let ifreq = self.get_ifreq();

-        // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret = unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCGIFMTU as c_ulong, &ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
+        // SAFETY: ioctl is safe. Called with a valid sock fd, and we check the return.
+        unsafe { Self::ioctl_with_ref(&sock, net_gen::sockios::SIOCGIFMTU as c_ulong, &ifreq)? };

+        // SAFETY: access a union field
        let mtu = unsafe { ifreq.ifr_ifru.ifru_mtu };

        Ok(mtu)
    }

+    #[cfg(fuzzing)]
+    pub fn mtu(&self) -> Result<i32> {
+        // Consistent with the `virtio_devices::net::MIN_MTU`
+        Ok(1280)
+    }
+
    pub fn set_mtu(&self, mtu: i32) -> Result<()> {
        let sock = create_unix_socket().map_err(Error::NetUtil)?;

        let mut ifreq = self.get_ifreq();
        ifreq.ifr_ifru.ifru_mtu = mtu;

-        // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret = unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFMTU as c_ulong, &ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
-
-        Ok(())
+        // SAFETY: ioctl is safe. Called with a valid sock fd, and we check the return.
+        unsafe { Self::ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFMTU as c_ulong, &ifreq) }
    }

    /// Set the offload flags for the tap interface.
    pub fn set_offload(&self, flags: c_uint) -> Result<()> {
-        // ioctl is safe. Called with a valid tap fd, and we check the return.
-        let ret =
-            unsafe { ioctl_with_val(&self.tap_file, net_gen::TUNSETOFFLOAD(), flags as c_ulong) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
-
-        Ok(())
+        // SAFETY: ioctl is safe. Called with a valid tap fd, and we check the return.
+        unsafe { Self::ioctl_with_val(&self.tap_file, net_gen::TUNSETOFFLOAD(), flags as c_ulong) }
    }

    /// Enable the tap interface.
@@ -346,13 +348,11 @@ impl Tap {

        let mut ifreq = self.get_ifreq();

-        let ret =
-            unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCGIFFLAGS as c_ulong, &ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
+        // SAFETY: IOCTL with correct arguments
+        unsafe { Self::ioctl_with_ref(&sock, net_gen::sockios::SIOCGIFFLAGS as c_ulong, &ifreq)? };

        // If TAP device is already up don't try and enable it
+        // SAFETY: access a union field
        let ifru_flags = unsafe { ifreq.ifr_ifru.ifru_flags };
        if ifru_flags & net_gen::net_device_flags_IFF_UP as i16
            == net_gen::net_device_flags_IFF_UP as i16
@@ -362,25 +362,14 @@ impl Tap {

        ifreq.ifr_ifru.ifru_flags = net_gen::net_device_flags_IFF_UP as i16;

-        // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret =
-            unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFFLAGS as c_ulong, &ifreq) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
-
-        Ok(())
+        // SAFETY: ioctl is safe. Called with a valid sock fd, and we check the return.
+        unsafe { Self::ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFFLAGS as c_ulong, &ifreq) }
    }

    /// Set the size of the vnet hdr.
    pub fn set_vnet_hdr_size(&self, size: c_int) -> Result<()> {
-        // ioctl is safe. Called with a valid tap fd, and we check the return.
-        let ret = unsafe { ioctl_with_ref(&self.tap_file, net_gen::TUNSETVNETHDRSZ(), &size) };
-        if ret < 0 {
-            return Err(Error::IoctlError(IoError::last_os_error()));
-        }
-
-        Ok(())
+        // SAFETY: ioctl is safe. Called with a valid tap fd, and we check the return.
+        unsafe { Self::ioctl_with_ref(&self.tap_file, net_gen::TUNSETVNETHDRSZ(), &size) }
    }

    fn get_ifreq(&self) -> net_gen::ifreq {
@@ -388,6 +377,7 @@ impl Tap {

        // This sets the name of the interface, which is the only entry
        // in a single-field union.
+        // SAFETY: access union fields and we're sure the copy is okay.
        unsafe {
            let ifrn_name = ifreq.ifr_ifrn.ifrn_name.as_mut();
            let name_slice = &mut ifrn_name[..self.if_name.len()];
@@ -400,6 +390,11 @@ impl Tap {
    pub fn get_if_name(&self) -> Vec<u8> {
        self.if_name.clone()
    }
+
+    #[cfg(fuzzing)]
+    pub fn new_for_fuzzing(tap_file: File, if_name: Vec<u8>) -> Self {
+        Tap { tap_file, if_name }
+    }
 }

 impl Read for Tap {
@@ -586,7 +581,7 @@ mod tests {
        let _tap_ip_guard = TAP_IP_LOCK.lock().unwrap();

        let t = Tap::new(1).unwrap();
-        println!("created tap: {:?}", t);
+        println!("created tap: {t:?}");
    }

    #[test]
--- a/option_parser/src/lib.rs
+++ b/option_parser/src/lib.rs
@@ -28,10 +28,10 @@ pub enum OptionParserError {
 impl fmt::Display for OptionParserError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
-            OptionParserError::UnknownOption(s) => write!(f, "unknown option: {}", s),
-            OptionParserError::InvalidSyntax(s) => write!(f, "invalid syntax:{}", s),
+            OptionParserError::UnknownOption(s) => write!(f, "unknown option: {s}"),
+            OptionParserError::InvalidSyntax(s) => write!(f, "invalid syntax:{s}"),
            OptionParserError::Conversion(field, value) => {
-                write!(f, "unable to convert {} for {}", value, field)
+                write!(f, "unable to convert {value} for {field}")
            }
        }
    }
--- a/pci/Cargo.toml
+++ b/pci/Cargo.toml
@@ -10,23 +10,20 @@ kvm = ["vfio-ioctls/kvm"]
 mshv = ["vfio-ioctls/mshv"]

 [dependencies]
-anyhow = "1.0.65"
+anyhow = "1.0.68"
 byteorder = "1.4.3"
 hypervisor = { path = "../hypervisor" }
+vfio-bindings = { git = "https://github.com/rust-vmm/vfio", branch = "main", features = ["fam-wrappers"] }
 vfio-ioctls = { git = "https://github.com/rust-vmm/vfio", branch = "main", default-features = false }
 vfio_user = { path = "../vfio_user" }
-vmm-sys-util = "0.10.0"
-libc = "0.2.133"
+vmm-sys-util = "0.11.0"
+libc = "0.2.139"
 log = "0.4.17"
-serde = { version = "1.0.145", features = ["derive"] }
-thiserror = "1.0.37"
-versionize = "0.1.6"
+serde = { version = "1.0.151", features = ["derive"] }
+thiserror = "1.0.38"
+versionize = "0.1.9"
 versionize_derive = "0.1.4"
 vm-allocator = { path = "../vm-allocator" }
 vm-device = { path = "../vm-device" }
-vm-memory = "0.9.0"
+vm-memory = "0.10.0"
 vm-migration = { path = "../vm-migration" }
-
-[dependencies.vfio-bindings]
-version = "0.3.1"
-features = ["fam-wrappers"]
--- a/pci/src/bus.rs
+++ b/pci/src/bus.rs
@@ -62,6 +62,7 @@ impl PciRoot {
                    0,
                    0,
                    None,
+                    None,
                ),
            }
        }
--- a/pci/src/configuration.rs
+++ b/pci/src/configuration.rs
@@ -32,6 +32,8 @@ const CAPABILITY_MAX_OFFSET: usize = 192;

 const INTERRUPT_LINE_PIN_REG: usize = 15;

+pub const PCI_CONFIGURATION_ID: &str = "pci_configuration";
+
 /// Represents the types of PCI headers allowed in the configuration registers.
 #[derive(Copy, Clone)]
 pub enum PciHeaderType {
@@ -394,7 +396,7 @@ fn decode_64_bits_bar_size(bar_size_hi: u32, bar_size_lo: u32) -> Option<u64> {
    None
 }

-#[derive(Default, Clone, Copy, Versionize)]
+#[derive(Debug, Default, Clone, Copy, Versionize)]
 struct PciBar {
    addr: u32,
    size: u32,
@@ -403,7 +405,7 @@ struct PciBar {
 }

 #[derive(Versionize)]
-struct PciConfigurationState {
+pub struct PciConfigurationState {
    registers: Vec<u32>,
    writable_bits: Vec<u32>,
    bars: Vec<PciBar>,
@@ -514,9 +516,9 @@ impl Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use self::Error::*;
        match self {
-            BarAddressInvalid(a, s) => write!(f, "address {} size {} too big", a, s),
-            BarInUse(b) => write!(f, "bar {} already used", b),
-            BarInUse64(b) => write!(f, "64bit bar {} already used(requires two regs)", b),
+            BarAddressInvalid(a, s) => write!(f, "address {a} size {s} too big"),
+            BarInUse(b) => write!(f, "bar {b} already used"),
+            BarInUse64(b) => write!(f, "64bit bar {b} already used(requires two regs)"),
            BarInvalid(b) => write!(f, "bar {} invalid, max {}", b, NUM_BAR_REGS - 1),
            BarInvalid64(b) => write!(
                f,
@@ -524,18 +526,18 @@ impl Display for Error {
                b,
                NUM_BAR_REGS - 1
            ),
-            BarSizeInvalid(s) => write!(f, "bar address {} not a power of two", s),
+            BarSizeInvalid(s) => write!(f, "bar address {s} not a power of two"),
            CapabilityEmpty => write!(f, "empty capabilities are invalid"),
-            CapabilityLengthInvalid(l) => write!(f, "Invalid capability length {}", l),
-            CapabilitySpaceFull(s) => write!(f, "capability of size {} doesn't fit", s),
+            CapabilityLengthInvalid(l) => write!(f, "Invalid capability length {l}"),
+            CapabilitySpaceFull(s) => write!(f, "capability of size {s} doesn't fit"),
            Decode32BarSize => write!(f, "failed to decode 32 bits BAR size"),
            Decode64BarSize => write!(f, "failed to decode 64 bits BAR size"),
            Encode32BarSize => write!(f, "failed to encode 32 bits BAR size"),
            Encode64BarSize => write!(f, "failed to encode 64 bits BAR size"),
-            RomBarAddressInvalid(a, s) => write!(f, "address {} size {} too big", a, s),
-            RomBarInUse(b) => write!(f, "rom bar {} already used", b),
+            RomBarAddressInvalid(a, s) => write!(f, "address {a} size {s} too big"),
+            RomBarInUse(b) => write!(f, "rom bar {b} already used"),
            RomBarInvalid(b) => write!(f, "rom bar {} invalid, max {}", b, NUM_BAR_REGS - 1),
-            RomBarSizeInvalid(s) => write!(f, "rom bar address {} not a power of two", s),
+            RomBarSizeInvalid(s) => write!(f, "rom bar address {s} not a power of two"),
        }
    }
 }
@@ -553,46 +555,78 @@ impl PciConfiguration {
        subsystem_vendor_id: u16,
        subsystem_id: u16,
        msix_config: Option<Arc<Mutex<MsixConfig>>>,
+        state: Option<PciConfigurationState>,
    ) -> Self {
-        let mut registers = [0u32; NUM_CONFIGURATION_REGISTERS];
-        let mut writable_bits = [0u32; NUM_CONFIGURATION_REGISTERS];
-        registers[0] = u32::from(device_id) << 16 | u32::from(vendor_id);
-        // TODO(dverkamp): Status should be write-1-to-clear
-        writable_bits[1] = 0x0000_ffff; // Status (r/o), command (r/w)
-        let pi = if let Some(pi) = programming_interface {
-            pi.get_register_value()
+        let (
+            registers,
+            writable_bits,
+            bars,
+            rom_bar_addr,
+            rom_bar_size,
+            rom_bar_used,
+            last_capability,
+            msix_cap_reg_idx,
+        ) = if let Some(state) = state {
+            (
+                state.registers.try_into().unwrap(),
+                state.writable_bits.try_into().unwrap(),
+                state.bars.try_into().unwrap(),
+                state.rom_bar_addr,
+                state.rom_bar_size,
+                state.rom_bar_used,
+                state.last_capability,
+                state.msix_cap_reg_idx,
+            )
        } else {
-            0
-        };
-        registers[2] = u32::from(class_code.get_register_value()) << 24
-            | u32::from(subclass.get_register_value()) << 16
-            | u32::from(pi) << 8
-            | u32::from(revision_id);
-        writable_bits[3] = 0x0000_00ff; // Cacheline size (r/w)
-        match header_type {
-            PciHeaderType::Device => {
-                registers[3] = 0x0000_0000; // Header type 0 (device)
-                writable_bits[15] = 0x0000_00ff; // Interrupt line (r/w)
-            }
-            PciHeaderType::Bridge => {
-                registers[3] = 0x0001_0000; // Header type 1 (bridge)
-                writable_bits[9] = 0xfff0_fff0; // Memory base and limit
-                writable_bits[15] = 0xffff_00ff; // Bridge control (r/w), interrupt line (r/w)
-            }
-        };
-        registers[11] = u32::from(subsystem_id) << 16 | u32::from(subsystem_vendor_id);
+            let mut registers = [0u32; NUM_CONFIGURATION_REGISTERS];
+            let mut writable_bits = [0u32; NUM_CONFIGURATION_REGISTERS];
+            registers[0] = u32::from(device_id) << 16 | u32::from(vendor_id);
+            // TODO(dverkamp): Status should be write-1-to-clear
+            writable_bits[1] = 0x0000_ffff; // Status (r/o), command (r/w)
+            let pi = if let Some(pi) = programming_interface {
+                pi.get_register_value()
+            } else {
+                0
+            };
+            registers[2] = u32::from(class_code.get_register_value()) << 24
+                | u32::from(subclass.get_register_value()) << 16
+                | u32::from(pi) << 8
+                | u32::from(revision_id);
+            writable_bits[3] = 0x0000_00ff; // Cacheline size (r/w)
+            match header_type {
+                PciHeaderType::Device => {
+                    registers[3] = 0x0000_0000; // Header type 0 (device)
+                    writable_bits[15] = 0x0000_00ff; // Interrupt line (r/w)
+                }
+                PciHeaderType::Bridge => {
+                    registers[3] = 0x0001_0000; // Header type 1 (bridge)
+                    writable_bits[9] = 0xfff0_fff0; // Memory base and limit
+                    writable_bits[15] = 0xffff_00ff; // Bridge control (r/w), interrupt line (r/w)
+                }
+            };
+            registers[11] = u32::from(subsystem_id) << 16 | u32::from(subsystem_vendor_id);

-        let bars = [PciBar::default(); NUM_BAR_REGS];
+            (
+                registers,
+                writable_bits,
+                [PciBar::default(); NUM_BAR_REGS],
+                0,
+                0,
+                false,
+                None,
+                None,
+            )
+        };

        PciConfiguration {
            registers,
            writable_bits,
            bars,
-            rom_bar_addr: 0,
-            rom_bar_size: 0,
-            rom_bar_used: false,
-            last_capability: None,
-            msix_cap_reg_idx: None,
+            rom_bar_addr,
+            rom_bar_size,
+            rom_bar_used,
+            last_capability,
+            msix_cap_reg_idx,
            msix_config,
        }
    }
@@ -610,18 +644,6 @@ impl PciConfiguration {
        }
    }

-    fn set_state(&mut self, state: &PciConfigurationState) {
-        self.registers.clone_from_slice(state.registers.as_slice());
-        self.writable_bits
-            .clone_from_slice(state.writable_bits.as_slice());
-        self.bars.clone_from_slice(state.bars.as_slice());
-        self.rom_bar_addr = state.rom_bar_addr;
-        self.rom_bar_size = state.rom_bar_size;
-        self.rom_bar_used = state.rom_bar_used;
-        self.last_capability = state.last_capability;
-        self.msix_cap_reg_idx = state.msix_cap_reg_idx;
-    }
-
    /// Reads a 32bit register from `reg_idx` in the register map.
    pub fn read_reg(&self, reg_idx: usize) -> u32 {
        *(self.registers.get(reg_idx).unwrap_or(&0xffff_ffff))
@@ -1046,16 +1068,11 @@ impl Pausable for PciConfiguration {}

 impl Snapshottable for PciConfiguration {
    fn id(&self) -> String {
-        String::from("pci_configuration")
+        String::from(PCI_CONFIGURATION_ID)
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_versioned_state(&self.id(), &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_versioned_state(&self.id())?);
-        Ok(())
+        Snapshot::new_from_versioned_state(&self.state())
    }
 }

@@ -1178,6 +1195,7 @@ mod tests {
            0xABCD,
            0x2468,
            None,
+            None,
        );

        // Add two capabilities with different contents.
@@ -1234,6 +1252,7 @@ mod tests {
            0xABCD,
            0x2468,
            None,
+            None,
        );

        let class_reg = cfg.read_reg(2);
--- a/pci/src/device.rs
+++ b/pci/src/device.rs
@@ -21,6 +21,8 @@ pub enum Error {
    IoRegistrationFailed(u64, configuration::Error),
    /// Expected resource not found.
    MissingResource,
+    /// Invalid resource.
+    InvalidResource(Resource),
 }
 pub type Result<T> = std::result::Result<T, Error>;

@@ -29,14 +31,15 @@ impl Display for Error {
        use self::Error::*;

        match self {
-            CapabilitiesSetup(e) => write!(f, "failed to add capability {}", e),
+            CapabilitiesSetup(e) => write!(f, "failed to add capability {e}"),
            IoAllocationFailed(size) => {
-                write!(f, "failed to allocate space for an IO BAR, size={}", size)
+                write!(f, "failed to allocate space for an IO BAR, size={size}")
            }
            IoRegistrationFailed(addr, e) => {
-                write!(f, "failed to register an IO BAR, addr={} err={}", addr, e)
+                write!(f, "failed to register an IO BAR, addr={addr} err={e}")
            }
            MissingResource => write!(f, "failed to find expected resource"),
+            InvalidResource(r) => write!(f, "invalid resource {r:?}"),
        }
    }
 }
--- a/pci/src/lib.rs
+++ b/pci/src/lib.rs
@@ -19,12 +19,13 @@ pub use self::configuration::{
    PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, PciCapability, PciCapabilityId,
    PciClassCode, PciConfiguration, PciExpressCapabilityId, PciHeaderType, PciMassStorageSubclass,
    PciNetworkControllerSubclass, PciProgrammingInterface, PciSerialBusSubClass, PciSubclass,
+    PCI_CONFIGURATION_ID,
 };
 pub use self::device::{
    BarReprogrammingParams, DeviceRelocation, Error as PciDeviceError, PciDevice,
 };
 pub use self::msi::{msi_num_enabled_vectors, MsiCap, MsiConfig};
-pub use self::msix::{MsixCap, MsixConfig, MsixTableEntry, MSIX_TABLE_ENTRY_SIZE};
+pub use self::msix::{MsixCap, MsixConfig, MsixTableEntry, MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE};
 pub use self::vfio::{VfioPciDevice, VfioPciError};
 pub use self::vfio_user::{VfioUserDmaMapping, VfioUserPciDevice, VfioUserPciDeviceError};
 use serde::de::Visitor;
--- a/pci/src/msi.rs
+++ b/pci/src/msi.rs
@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
 //

-use anyhow::anyhow;
 use byteorder::{ByteOrder, LittleEndian};
 use std::io;
 use std::sync::Arc;
@@ -39,13 +38,15 @@ pub fn msi_num_enabled_vectors(msg_ctl: u16) -> usize {
 }

 #[derive(Error, Debug)]
-enum Error {
+pub enum Error {
    #[error("Failed enabling the interrupt route: {0}")]
    EnableInterruptRoute(io::Error),
    #[error("Failed updating the interrupt route: {0}")]
    UpdateInterruptRoute(io::Error),
 }

+pub const MSI_CONFIG_ID: &str = "msi_config";
+
 #[derive(Clone, Copy, Default, Versionize)]
 pub struct MsiCap {
    // Message Control Register
@@ -172,7 +173,7 @@ impl MsiCap {
 }

 #[derive(Versionize)]
-struct MsiConfigState {
+pub struct MsiConfigState {
    cap: MsiCap,
 }

@@ -184,51 +185,53 @@ pub struct MsiConfig {
 }

 impl MsiConfig {
-    pub fn new(msg_ctl: u16, interrupt_source_group: Arc<dyn InterruptSourceGroup>) -> Self {
-        let cap = MsiCap {
-            msg_ctl,
-            ..Default::default()
+    pub fn new(
+        msg_ctl: u16,
+        interrupt_source_group: Arc<dyn InterruptSourceGroup>,
+        state: Option<MsiConfigState>,
+    ) -> Result<Self, Error> {
+        let cap = if let Some(state) = state {
+            if state.cap.enabled() {
+                for idx in 0..state.cap.num_enabled_vectors() {
+                    let config = MsiIrqSourceConfig {
+                        high_addr: state.cap.msg_addr_hi,
+                        low_addr: state.cap.msg_addr_lo,
+                        data: state.cap.msg_data as u32,
+                        devid: 0,
+                    };
+
+                    interrupt_source_group
+                        .update(
+                            idx as InterruptIndex,
+                            InterruptSourceConfig::MsiIrq(config),
+                            state.cap.vector_masked(idx),
+                        )
+                        .map_err(Error::UpdateInterruptRoute)?;
+                }
+
+                interrupt_source_group
+                    .enable()
+                    .map_err(Error::EnableInterruptRoute)?;
+            }
+
+            state.cap
+        } else {
+            MsiCap {
+                msg_ctl,
+                ..Default::default()
+            }
        };

-        MsiConfig {
+        Ok(MsiConfig {
            cap,
            interrupt_source_group,
-        }
+        })
    }

    fn state(&self) -> MsiConfigState {
        MsiConfigState { cap: self.cap }
    }

-    fn set_state(&mut self, state: &MsiConfigState) -> Result<(), Error> {
-        self.cap = state.cap;
-
-        if self.enabled() {
-            for idx in 0..self.num_enabled_vectors() {
-                let config = MsiIrqSourceConfig {
-                    high_addr: self.cap.msg_addr_hi,
-                    low_addr: self.cap.msg_addr_lo,
-                    data: self.cap.msg_data as u32,
-                    devid: 0,
-                };
-
-                self.interrupt_source_group
-                    .update(
-                        idx as InterruptIndex,
-                        InterruptSourceConfig::MsiIrq(config),
-                        self.cap.vector_masked(idx),
-                    )
-                    .map_err(Error::UpdateInterruptRoute)?;
-            }
-
-            self.interrupt_source_group
-                .enable()
-                .map_err(Error::EnableInterruptRoute)?;
-        }
-
-        Ok(())
-    }
-
    pub fn enabled(&self) -> bool {
        self.cap.enabled()
    }
@@ -281,21 +284,10 @@ impl Pausable for MsiConfig {}

 impl Snapshottable for MsiConfig {
    fn id(&self) -> String {
-        String::from("msi_config")
+        String::from(MSI_CONFIG_ID)
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_versioned_state(&self.id(), &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_versioned_state(&self.id())?)
-            .map_err(|e| {
-                MigratableError::Restore(anyhow!(
-                    "Could not restore state for {}: {:?}",
-                    self.id(),
-                    e
-                ))
-            })
+        Snapshot::new_from_versioned_state(&self.state())
    }
 }
--- a/pci/src/msix.rs
+++ b/pci/src/msix.rs
@@ -4,7 +4,6 @@
 //

 use crate::{PciCapability, PciCapabilityId};
-use anyhow::anyhow;
 use byteorder::{ByteOrder, LittleEndian};
 use std::io;
 use std::result;
@@ -26,16 +25,17 @@ const MSIX_ENABLE_BIT: u8 = 15;
 const FUNCTION_MASK_MASK: u16 = (1 << FUNCTION_MASK_BIT) as u16;
 const MSIX_ENABLE_MASK: u16 = (1 << MSIX_ENABLE_BIT) as u16;
 pub const MSIX_TABLE_ENTRY_SIZE: usize = 16;
+pub const MSIX_CONFIG_ID: &str = "msix_config";

 #[derive(Debug)]
-enum Error {
+pub enum Error {
    /// Failed enabling the interrupt route.
    EnableInterruptRoute(io::Error),
    /// Failed updating the interrupt route.
    UpdateInterruptRoute(io::Error),
 }

-#[derive(Debug, Clone, Versionize)]
+#[derive(Debug, Clone, Versionize, Eq, PartialEq)]
 pub struct MsixTableEntry {
    pub msg_addr_lo: u32,
    pub msg_addr_hi: u32,
@@ -61,7 +61,7 @@ impl Default for MsixTableEntry {
 }

 #[derive(Versionize)]
-struct MsixConfigState {
+pub struct MsixConfigState {
    table_entries: Vec<MsixTableEntry>,
    pba_entries: Vec<u64>,
    masked: bool,
@@ -84,23 +84,62 @@ impl MsixConfig {
        msix_vectors: u16,
        interrupt_source_group: Arc<dyn InterruptSourceGroup>,
        devid: u32,
-    ) -> Self {
+        state: Option<MsixConfigState>,
+    ) -> result::Result<Self, Error> {
        assert!(msix_vectors <= MAX_MSIX_VECTORS_PER_DEVICE);

-        let mut table_entries: Vec<MsixTableEntry> = Vec::new();
-        table_entries.resize_with(msix_vectors as usize, Default::default);
-        let mut pba_entries: Vec<u64> = Vec::new();
-        let num_pba_entries: usize = ((msix_vectors as usize) / BITS_PER_PBA_ENTRY) + 1;
-        pba_entries.resize_with(num_pba_entries, Default::default);
+        let (table_entries, pba_entries, masked, enabled) = if let Some(state) = state {
+            if state.enabled && !state.masked {
+                for (idx, table_entry) in state.table_entries.iter().enumerate() {
+                    if table_entry.masked() {
+                        continue;
+                    }

-        MsixConfig {
+                    let config = MsiIrqSourceConfig {
+                        high_addr: table_entry.msg_addr_hi,
+                        low_addr: table_entry.msg_addr_lo,
+                        data: table_entry.msg_data,
+                        devid,
+                    };
+
+                    interrupt_source_group
+                        .update(
+                            idx as InterruptIndex,
+                            InterruptSourceConfig::MsiIrq(config),
+                            state.masked,
+                        )
+                        .map_err(Error::UpdateInterruptRoute)?;
+
+                    interrupt_source_group
+                        .enable()
+                        .map_err(Error::EnableInterruptRoute)?;
+                }
+            }
+
+            (
+                state.table_entries,
+                state.pba_entries,
+                state.masked,
+                state.enabled,
+            )
+        } else {
+            let mut table_entries: Vec<MsixTableEntry> = Vec::new();
+            table_entries.resize_with(msix_vectors as usize, Default::default);
+            let mut pba_entries: Vec<u64> = Vec::new();
+            let num_pba_entries: usize = ((msix_vectors as usize) / BITS_PER_PBA_ENTRY) + 1;
+            pba_entries.resize_with(num_pba_entries, Default::default);
+
+            (table_entries, pba_entries, true, false)
+        };
+
+        Ok(MsixConfig {
            table_entries,
            pba_entries,
            devid,
            interrupt_source_group,
-            masked: true,
-            enabled: false,
-        }
+            masked,
+            enabled,
+        })
    }

    fn state(&self) -> MsixConfigState {
@@ -112,42 +151,6 @@ impl MsixConfig {
        }
    }

-    fn set_state(&mut self, state: &MsixConfigState) -> result::Result<(), Error> {
-        self.table_entries = state.table_entries.clone();
-        self.pba_entries = state.pba_entries.clone();
-        self.masked = state.masked;
-        self.enabled = state.enabled;
-
-        if self.enabled && !self.masked {
-            for (idx, table_entry) in self.table_entries.iter().enumerate() {
-                if table_entry.masked() {
-                    continue;
-                }
-
-                let config = MsiIrqSourceConfig {
-                    high_addr: table_entry.msg_addr_hi,
-                    low_addr: table_entry.msg_addr_lo,
-                    data: table_entry.msg_data,
-                    devid: self.devid,
-                };
-
-                self.interrupt_source_group
-                    .update(
-                        idx as InterruptIndex,
-                        InterruptSourceConfig::MsiIrq(config),
-                        self.masked,
-                    )
-                    .map_err(Error::UpdateInterruptRoute)?;
-
-                self.interrupt_source_group
-                    .enable()
-                    .map_err(Error::EnableInterruptRoute)?;
-            }
-        }
-
-        Ok(())
-    }
-
    pub fn masked(&self) -> bool {
        self.masked
    }
@@ -258,7 +261,7 @@ impl MsixConfig {
        let modulo_offset = offset % MSIX_TABLE_ENTRIES_MODULO;

        // Store the value of the entry before modification
-        let mut old_entry: Option<MsixTableEntry> = None;
+        let old_entry = self.table_entries[index].clone();

        match data.len() {
            4 => {
@@ -268,7 +271,6 @@ impl MsixConfig {
                    0x4 => self.table_entries[index].msg_addr_hi = value,
                    0x8 => self.table_entries[index].msg_data = value,
                    0xc => {
-                        old_entry = Some(self.table_entries[index].clone());
                        self.table_entries[index].vector_ctl = value;
                    }
                    _ => error!("invalid offset"),
@@ -284,7 +286,6 @@ impl MsixConfig {
                        self.table_entries[index].msg_addr_hi = (value >> 32) as u32;
                    }
                    0x8 => {
-                        old_entry = Some(self.table_entries[index].clone());
                        self.table_entries[index].msg_data = (value & 0xffff_ffffu64) as u32;
                        self.table_entries[index].vector_ctl = (value >> 32) as u32;
                    }
@@ -296,10 +297,18 @@ impl MsixConfig {
            _ => error!("invalid data length"),
        };

-        // Update interrupt routes
-        if self.enabled && !self.masked {
-            let table_entry = &self.table_entries[index];
+        let table_entry = &self.table_entries[index];

+        // Optimisation to avoid excessive updates
+        if &old_entry == table_entry {
+            return;
+        }
+
+        // Update interrupt routes
+        // Optimisation: only update routes if the entry is not masked;
+        // this is safe because if the entry is masked (starts masked as per spec)
+        // in the table then it won't be triggered. (See: #4273)
+        if self.enabled && !self.masked && !table_entry.masked() {
            let config = MsiIrqSourceConfig {
                high_addr: table_entry.msg_addr_hi,
                low_addr: table_entry.msg_addr_lo,
@@ -323,15 +332,15 @@ impl MsixConfig {
        // has been injected, the pending bit in the PBA needs to be cleared.
        // All of this is valid only if MSI-X has not been masked for the whole
        // device.
-        if let Some(old_entry) = old_entry {
-            // Check if bit has been flipped
-            if !self.masked()
-                && old_entry.masked()
-                && !self.table_entries[index].masked()
-                && self.get_pba_bit(index as u16) == 1
-            {
-                self.inject_msix_and_clear_pba(index);
-            }
+
+        // Check if bit has been flipped
+        if !self.masked()
+            && self.enabled()
+            && old_entry.masked()
+            && !table_entry.masked()
+            && self.get_pba_bit(index as u16) == 1
+        {
+            self.inject_msix_and_clear_pba(index);
        }
    }

@@ -420,22 +429,11 @@ impl Pausable for MsixConfig {}

 impl Snapshottable for MsixConfig {
    fn id(&self) -> String {
-        String::from("msix_config")
+        String::from(MSIX_CONFIG_ID)
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_versioned_state(&self.id(), &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_versioned_state(&self.id())?)
-            .map_err(|e| {
-                MigratableError::Restore(anyhow!(
-                    "Could not restore state for {}: {:?}",
-                    self.id(),
-                    e
-                ))
-            })
+        Snapshot::new_from_versioned_state(&self.state())
    }
 }

--- a/pci/src/vfio.rs
+++ b/pci/src/vfio.rs
@@ -3,11 +3,13 @@
 // SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
 //

+use crate::msi::{MsiConfigState, MSI_CONFIG_ID};
+use crate::msix::MsixConfigState;
 use crate::{
    msi_num_enabled_vectors, BarReprogrammingParams, MsiCap, MsiConfig, MsixCap, MsixConfig,
    PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, PciBdf, PciCapabilityId,
    PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciExpressCapabilityId,
-    PciHeaderType, PciSubclass, MSIX_TABLE_ENTRY_SIZE,
+    PciHeaderType, PciSubclass, MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE, PCI_CONFIGURATION_ID,
 };
 use anyhow::anyhow;
 use byteorder::{ByteOrder, LittleEndian};
@@ -36,6 +38,8 @@ use vm_migration::{
 };
 use vmm_sys_util::eventfd::EventFd;

+pub(crate) const VFIO_COMMON_ID: &str = "vfio_common";
+
 #[derive(Debug, Error)]
 pub enum VfioPciError {
    #[error("Failed to create user memory region: {0}")]
@@ -58,6 +62,14 @@ pub enum VfioPciError {
    RegionAlignment,
    #[error("Invalid region size")]
    RegionSize,
+    #[error("Failed to retrieve MsiConfigState: {0}")]
+    RetrieveMsiConfigState(#[source] anyhow::Error),
+    #[error("Failed to retrieve MsixConfigState: {0}")]
+    RetrieveMsixConfigState(#[source] anyhow::Error),
+    #[error("Failed to retrieve PciConfigurationState: {0}")]
+    RetrievePciConfigurationState(#[source] anyhow::Error),
+    #[error("Failed to retrieve VfioCommonState: {0}")]
+    RetrieveVfioCommonState(#[source] anyhow::Error),
 }

 #[derive(Copy, Clone)]
@@ -406,6 +418,86 @@ pub(crate) struct VfioCommon {
 }

 impl VfioCommon {
+    pub(crate) fn new(
+        msi_interrupt_manager: Arc<dyn InterruptManager<GroupConfig = MsiIrqGroupConfig>>,
+        legacy_interrupt_group: Option<Arc<dyn InterruptSourceGroup>>,
+        vfio_wrapper: Arc<dyn Vfio>,
+        subclass: &dyn PciSubclass,
+        bdf: PciBdf,
+        snapshot: Option<Snapshot>,
+    ) -> Result<Self, VfioPciError> {
+        let pci_configuration_state =
+            vm_migration::versioned_state_from_id(snapshot.as_ref(), PCI_CONFIGURATION_ID)
+                .map_err(|e| {
+                    VfioPciError::RetrievePciConfigurationState(anyhow!(
+                        "Failed to get PciConfigurationState from Snapshot: {}",
+                        e
+                    ))
+                })?;
+
+        let configuration = PciConfiguration::new(
+            0,
+            0,
+            0,
+            PciClassCode::Other,
+            subclass,
+            None,
+            PciHeaderType::Device,
+            0,
+            0,
+            None,
+            pci_configuration_state,
+        );
+
+        let mut vfio_common = VfioCommon {
+            mmio_regions: Vec::new(),
+            configuration,
+            interrupt: Interrupt {
+                intx: None,
+                msi: None,
+                msix: None,
+            },
+            msi_interrupt_manager,
+            legacy_interrupt_group,
+            vfio_wrapper,
+            patches: HashMap::new(),
+        };
+
+        let state: Option<VfioCommonState> = snapshot
+            .as_ref()
+            .map(|s| s.to_versioned_state())
+            .transpose()
+            .map_err(|e| {
+                VfioPciError::RetrieveVfioCommonState(anyhow!(
+                    "Failed to get VfioCommonState from Snapshot: {}",
+                    e
+                ))
+            })?;
+        let msi_state = vm_migration::versioned_state_from_id(snapshot.as_ref(), MSI_CONFIG_ID)
+            .map_err(|e| {
+                VfioPciError::RetrieveMsiConfigState(anyhow!(
+                    "Failed to get MsiConfigState from Snapshot: {}",
+                    e
+                ))
+            })?;
+        let msix_state = vm_migration::versioned_state_from_id(snapshot.as_ref(), MSIX_CONFIG_ID)
+            .map_err(|e| {
+            VfioPciError::RetrieveMsixConfigState(anyhow!(
+                "Failed to get MsixConfigState from Snapshot: {}",
+                e
+            ))
+        })?;
+
+        if let Some(state) = state.as_ref() {
+            vfio_common.set_state(state, msi_state, msix_state)?;
+        } else {
+            vfio_common.parse_capabilities(bdf);
+            vfio_common.initialize_legacy_interrupt()?;
+        }
+
+        Ok(vfio_common)
+    }
+
    pub(crate) fn allocate_bars(
        &mut self,
        allocator: &Arc<Mutex<SystemAllocator>>,
@@ -413,7 +505,7 @@ impl VfioCommon {
        resources: Option<Vec<Resource>>,
    ) -> Result<Vec<PciBarConfiguration>, PciDeviceError> {
        let mut bars = Vec::new();
-        let mut bar_id = VFIO_PCI_BAR0_REGION_INDEX as u32;
+        let mut bar_id = VFIO_PCI_BAR0_REGION_INDEX;

        // Going through all regular regions to compute the BAR size.
        // We're not saving the BAR address to restore it, because we
@@ -526,7 +618,7 @@ impl VfioCommon {
                    }

                    // Invert and add 1 to to find size
-                    region_size = (!combined_size + 1) as u64;
+                    region_size = !combined_size + 1;
                } else {
                    region_type = PciBarRegionType::Memory32BitRegion;

@@ -599,7 +691,7 @@ impl VfioCommon {
                start: bar_addr,
                length: region_size,
                type_: region_type,
-                index: bar_id as u32,
+                index: bar_id,
                user_memory_regions: Vec::new(),
            });

@@ -650,7 +742,13 @@ impl VfioCommon {
        }
    }

-    pub(crate) fn initialize_msix(&mut self, msix_cap: MsixCap, cap_offset: u32, bdf: PciBdf) {
+    pub(crate) fn initialize_msix(
+        &mut self,
+        msix_cap: MsixCap,
+        cap_offset: u32,
+        bdf: PciBdf,
+        state: Option<MsixConfigState>,
+    ) {
        let interrupt_source_group = self
            .msi_interrupt_manager
            .create_group(MsiIrqGroupConfig {
@@ -663,7 +761,9 @@ impl VfioCommon {
            msix_cap.table_size(),
            interrupt_source_group.clone(),
            bdf.into(),
-        );
+            state,
+        )
+        .unwrap();

        self.interrupt.msix = Some(VfioMsix {
            bar: msix_config,
@@ -677,7 +777,12 @@ impl VfioCommon {
        self.vfio_wrapper.read_config_word((cap + 2).into())
    }

-    pub(crate) fn initialize_msi(&mut self, msg_ctl: u16, cap_offset: u32) {
+    pub(crate) fn initialize_msi(
+        &mut self,
+        msg_ctl: u16,
+        cap_offset: u32,
+        state: Option<MsiConfigState>,
+    ) {
        let interrupt_source_group = self
            .msi_interrupt_manager
            .create_group(MsiIrqGroupConfig {
@@ -686,7 +791,7 @@ impl VfioCommon {
            })
            .unwrap();

-        let msi_config = MsiConfig::new(msg_ctl, interrupt_source_group.clone());
+        let msi_config = MsiConfig::new(msg_ctl, interrupt_source_group.clone(), state).unwrap();

        self.interrupt.msi = Some(VfioMsi {
            cfg: msi_config,
@@ -713,7 +818,7 @@ impl VfioCommon {
                            // Parse capability only if the VFIO device
                            // supports MSI.
                            let msg_ctl = self.parse_msi_capabilities(cap_next);
-                            self.initialize_msi(msg_ctl, cap_next as u32);
+                            self.initialize_msi(msg_ctl, cap_next as u32, None);
                        }
                    }
                }
@@ -724,7 +829,7 @@ impl VfioCommon {
                            // Parse capability only if the VFIO device
                            // supports MSI-X.
                            let msix_cap = self.parse_msix_capabilities(cap_next);
-                            self.initialize_msix(msix_cap, cap_next as u32, bdf);
+                            self.initialize_msix(msix_cap, cap_next as u32, bdf, None);
                        }
                    }
                }
@@ -1091,7 +1196,12 @@ impl VfioCommon {
        }
    }

-    fn set_state(&mut self, state: &VfioCommonState) -> Result<(), VfioPciError> {
+    fn set_state(
+        &mut self,
+        state: &VfioCommonState,
+        msi_state: Option<MsiConfigState>,
+        msix_state: Option<MsixConfigState>,
+    ) -> Result<(), VfioPciError> {
        if let (Some(intx), Some(interrupt_source_group)) =
            (&state.intx_state, self.legacy_interrupt_group.clone())
        {
@@ -1106,11 +1216,11 @@ impl VfioCommon {
        }

        if let Some(msi) = &state.msi_state {
-            self.initialize_msi(msi.cap.msg_ctl, msi.cap_offset);
+            self.initialize_msi(msi.cap.msg_ctl, msi.cap_offset, msi_state);
        }

        if let Some(msix) = &state.msix_state {
-            self.initialize_msix(msix.cap, msix.cap_offset, msix.bdf.into());
+            self.initialize_msix(msix.cap, msix.cap_offset, msix.bdf.into(), msix_state);
        }

        Ok(())
@@ -1121,73 +1231,27 @@ impl Pausable for VfioCommon {}

 impl Snapshottable for VfioCommon {
    fn id(&self) -> String {
-        String::from("vfio_common")
+        String::from(VFIO_COMMON_ID)
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        let mut vfio_common_snapshot =
-            Snapshot::new_from_versioned_state(&self.id(), &self.state())?;
+        let mut vfio_common_snapshot = Snapshot::new_from_versioned_state(&self.state())?;

        // Snapshot PciConfiguration
-        vfio_common_snapshot.add_snapshot(self.configuration.snapshot()?);
+        vfio_common_snapshot.add_snapshot(self.configuration.id(), self.configuration.snapshot()?);

        // Snapshot MSI
        if let Some(msi) = &mut self.interrupt.msi {
-            vfio_common_snapshot.add_snapshot(msi.cfg.snapshot()?);
+            vfio_common_snapshot.add_snapshot(msi.cfg.id(), msi.cfg.snapshot()?);
        }

        // Snapshot MSI-X
        if let Some(msix) = &mut self.interrupt.msix {
-            vfio_common_snapshot.add_snapshot(msix.bar.snapshot()?);
+            vfio_common_snapshot.add_snapshot(msix.bar.id(), msix.bar.snapshot()?);
        }

        Ok(vfio_common_snapshot)
    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        if let Some(vfio_common_section) = snapshot
-            .snapshot_data
-            .get(&format!("{}-section", self.id()))
-        {
-            // It has to be invoked first as we want Interrupt to be initialized
-            // correctly before we try to restore MSI and MSI-X configurations.
-            self.set_state(&vfio_common_section.to_versioned_state()?)
-                .map_err(|e| {
-                    MigratableError::Restore(anyhow!("Could not restore VFIO_COMMON state {:?}", e))
-                })?;
-
-            // Restore PciConfiguration
-            if let Some(pci_config_snapshot) = snapshot.snapshots.get(&self.configuration.id()) {
-                self.configuration.restore(*pci_config_snapshot.clone())?;
-            }
-
-            // Restore MSI
-            if let Some(msi) = &mut self.interrupt.msi {
-                if let Some(msi_snapshot) = snapshot.snapshots.get(&msi.cfg.id()) {
-                    msi.cfg.restore(*msi_snapshot.clone())?;
-                }
-                if msi.cfg.enabled() {
-                    self.enable_msi().unwrap();
-                }
-            }
-
-            // Restore MSI-X
-            if let Some(msix) = &mut self.interrupt.msix {
-                if let Some(msix_snapshot) = snapshot.snapshots.get(&msix.bar.id()) {
-                    msix.bar.restore(*msix_snapshot.clone())?;
-                }
-                if msix.bar.enabled() {
-                    self.enable_msix().unwrap();
-                }
-            }
-
-            return Ok(());
-        }
-
-        Err(MigratableError::Restore(anyhow!(
-            "Could not find VFIO_COMMON snapshot section"
-        )))
-    }
 }

 /// VfioPciDevice represents a VFIO PCI device.
@@ -1218,48 +1282,22 @@ impl VfioPciDevice {
        legacy_interrupt_group: Option<Arc<dyn InterruptSourceGroup>>,
        iommu_attached: bool,
        bdf: PciBdf,
-        restoring: bool,
        memory_slot: Arc<dyn Fn() -> u32 + Send + Sync>,
+        snapshot: Option<Snapshot>,
    ) -> Result<Self, VfioPciError> {
        let device = Arc::new(device);
        device.reset();

-        let configuration = PciConfiguration::new(
-            0,
-            0,
-            0,
-            PciClassCode::Other,
-            &PciVfioSubclass::VfioSubclass,
-            None,
-            PciHeaderType::Device,
-            0,
-            0,
-            None,
-        );
-
        let vfio_wrapper = VfioDeviceWrapper::new(Arc::clone(&device));

-        let mut common = VfioCommon {
-            mmio_regions: Vec::new(),
-            configuration,
-            interrupt: Interrupt {
-                intx: None,
-                msi: None,
-                msix: None,
-            },
+        let common = VfioCommon::new(
            msi_interrupt_manager,
            legacy_interrupt_group,
-            vfio_wrapper: Arc::new(vfio_wrapper) as Arc<dyn Vfio>,
-            patches: HashMap::new(),
-        };
-
-        // No need to parse capabilities from the device if on the restore path.
-        // The initialization will be performed later when restore() will be
-        // called.
-        if !restoring {
-            common.parse_capabilities(bdf);
-            common.initialize_legacy_interrupt()?;
-        }
+            Arc::new(vfio_wrapper) as Arc<dyn Vfio>,
+            &PciVfioSubclass::VfioSubclass,
+            bdf,
+            vm_migration::snapshot_from_id(snapshot.as_ref(), VFIO_COMMON_ID),
+        )?;

        let vfio_pci_device = VfioPciDevice {
            id,
@@ -1422,6 +1460,7 @@ impl VfioPciDevice {
                )?;

                for area in sparse_areas.iter() {
+                    // SAFETY: FFI call with correct arguments
                    let host_addr = unsafe {
                        libc::mmap(
                            null_mut(),
@@ -1488,6 +1527,7 @@ impl VfioPciDevice {
                    error!("Could not remove the userspace memory region: {}", e);
                }

+                // SAFETY: FFI call with correct arguments
                let ret = unsafe {
                    libc::munmap(
                        user_memory_region.host_addr as *mut libc::c_void,
@@ -1699,28 +1739,13 @@ impl Snapshottable for VfioPciDevice {
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        let mut vfio_pci_dev_snapshot = Snapshot::new(&self.id);
+        let mut vfio_pci_dev_snapshot = Snapshot::default();

        // Snapshot VfioCommon
-        vfio_pci_dev_snapshot.add_snapshot(self.common.snapshot()?);
+        vfio_pci_dev_snapshot.add_snapshot(self.common.id(), self.common.snapshot()?);

        Ok(vfio_pci_dev_snapshot)
    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        // Restore VfioCommon
-        if let Some(vfio_common_snapshot) = snapshot.snapshots.get(&self.common.id()) {
-            self.common.restore(*vfio_common_snapshot.clone())?;
-            self.map_mmio_regions().map_err(|e| {
-                MigratableError::Restore(anyhow!(
-                    "Could not map MMIO regions for VfioPciDevice on restore {:?}",
-                    e
-                ))
-            })?;
-        }
-
-        Ok(())
-    }
 }
 impl Transportable for VfioPciDevice {}
 impl Migratable for VfioPciDevice {}
--- a/pci/src/vfio_user.rs
+++ b/pci/src/vfio_user.rs
@@ -3,15 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //

-use crate::vfio::{Interrupt, UserMemoryRegion, Vfio, VfioCommon, VfioError};
+use crate::vfio::{UserMemoryRegion, Vfio, VfioCommon, VfioError, VFIO_COMMON_ID};
 use crate::{BarReprogrammingParams, PciBarConfiguration, VfioPciError};
-use crate::{
-    PciBdf, PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType, PciSubclass,
-};
-use anyhow::anyhow;
+use crate::{PciBdf, PciDevice, PciDeviceError, PciSubclass};
 use hypervisor::HypervisorVmError;
 use std::any::Any;
-use std::collections::HashMap;
 use std::os::unix::prelude::AsRawFd;
 use std::ptr::null_mut;
 use std::sync::{Arc, Barrier, Mutex};
@@ -51,6 +47,8 @@ pub enum VfioUserPciDeviceError {
    DmaUnmap(#[source] VfioUserError),
    #[error("Failed to initialize legacy interrupts: {0}")]
    InitializeLegacyInterrupts(#[source] VfioPciError),
+    #[error("Failed to create VfioCommon: {0}")]
+    CreateVfioCommon(#[source] VfioPciError),
 }

 #[derive(Copy, Clone)]
@@ -73,22 +71,9 @@ impl VfioUserPciDevice {
        msi_interrupt_manager: Arc<dyn InterruptManager<GroupConfig = MsiIrqGroupConfig>>,
        legacy_interrupt_group: Option<Arc<dyn InterruptSourceGroup>>,
        bdf: PciBdf,
-        restoring: bool,
        memory_slot: Arc<dyn Fn() -> u32 + Send + Sync>,
+        snapshot: Option<Snapshot>,
    ) -> Result<Self, VfioUserPciDeviceError> {
-        // This is used for the BAR and capabilities only
-        let configuration = PciConfiguration::new(
-            0,
-            0,
-            0,
-            PciClassCode::Other,
-            &PciVfioUserSubclass::VfioUserSubclass,
-            None,
-            PciHeaderType::Device,
-            0,
-            0,
-            None,
-        );
        let resettable = client.lock().unwrap().resettable();
        if resettable {
            client
@@ -102,29 +87,15 @@ impl VfioUserPciDevice {
            client: client.clone(),
        };

-        let mut common = VfioCommon {
-            mmio_regions: Vec::new(),
-            configuration,
-            interrupt: Interrupt {
-                intx: None,
-                msi: None,
-                msix: None,
-            },
+        let common = VfioCommon::new(
            msi_interrupt_manager,
            legacy_interrupt_group,
-            vfio_wrapper: Arc::new(vfio_wrapper) as Arc<dyn Vfio>,
-            patches: HashMap::new(),
-        };
-
-        // No need to parse capabilities from the device if on the restore path.
-        // The initialization will be performed later when restore() will be
-        // called.
-        if !restoring {
-            common.parse_capabilities(bdf);
-            common
-                .initialize_legacy_interrupt()
-                .map_err(VfioUserPciDeviceError::InitializeLegacyInterrupts)?;
-        }
+            Arc::new(vfio_wrapper) as Arc<dyn Vfio>,
+            &PciVfioUserSubclass::VfioUserSubclass,
+            bdf,
+            vm_migration::snapshot_from_id(snapshot.as_ref(), VFIO_COMMON_ID),
+        )
+        .map_err(VfioUserPciDeviceError::CreateVfioCommon)?;

        Ok(Self {
            id,
@@ -181,6 +152,7 @@ impl VfioUserPciDevice {
                };

                for s in mmaps.iter() {
+                    // SAFETY: FFI call with correct arguments
                    let host_addr = unsafe {
                        libc::mmap(
                            null_mut(),
@@ -247,6 +219,7 @@ impl VfioUserPciDevice {
                }

                // Remove mmaps
+                // SAFETY: FFI call with correct arguments
                let ret = unsafe {
                    libc::munmap(
                        user_memory_region.host_addr as *mut libc::c_void,
@@ -276,12 +249,7 @@ impl VfioUserPciDevice {
        self.client
            .lock()
            .unwrap()
-            .dma_map(
-                offset,
-                region.start_addr().raw_value(),
-                region.len() as u64,
-                fd,
-            )
+            .dma_map(offset, region.start_addr().raw_value(), region.len(), fd)
            .map_err(VfioUserPciDeviceError::DmaMap)
    }

@@ -292,7 +260,7 @@ impl VfioUserPciDevice {
        self.client
            .lock()
            .unwrap()
-            .dma_unmap(region.start_addr().raw_value(), region.len() as u64)
+            .dma_unmap(region.start_addr().raw_value(), region.len())
            .map_err(VfioUserPciDeviceError::DmaUnmap)
    }
 }
@@ -567,28 +535,13 @@ impl Snapshottable for VfioUserPciDevice {
    }

    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        let mut vfio_pci_dev_snapshot = Snapshot::new(&self.id);
+        let mut vfio_pci_dev_snapshot = Snapshot::default();

        // Snapshot VfioCommon
-        vfio_pci_dev_snapshot.add_snapshot(self.common.snapshot()?);
+        vfio_pci_dev_snapshot.add_snapshot(self.common.id(), self.common.snapshot()?);

        Ok(vfio_pci_dev_snapshot)
    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        // Restore VfioCommon
-        if let Some(vfio_common_snapshot) = snapshot.snapshots.get(&self.common.id()) {
-            self.common.restore(*vfio_common_snapshot.clone())?;
-            self.map_mmio_regions().map_err(|e| {
-                MigratableError::Restore(anyhow!(
-                    "Could not map MMIO regions for VfioUserPciDevice on restore {:?}",
-                    e
-                ))
-            })?;
-        }
-
-        Ok(())
-    }
 }
 impl Transportable for VfioUserPciDevice {}
 impl Migratable for VfioUserPciDevice {}
@@ -622,13 +575,13 @@ impl<M: GuestAddressSpace + Sync + Send> ExternalDmaMapping for VfioUserDmaMappi
                .map_err(|e| {
                    std::io::Error::new(
                        std::io::ErrorKind::Other,
-                        format!("Error mapping region: {}", e),
+                        format!("Error mapping region: {e}"),
                    )
                })
        } else {
            Err(std::io::Error::new(
                std::io::ErrorKind::Other,
-                format!("Region not found for 0x{:x}", gpa),
+                format!("Region not found for 0x{gpa:x}"),
            ))
        }
    }
@@ -641,7 +594,7 @@ impl<M: GuestAddressSpace + Sync + Send> ExternalDmaMapping for VfioUserDmaMappi
            .map_err(|e| {
                std::io::Error::new(
                    std::io::ErrorKind::Other,
-                    format!("Error unmapping region: {}", e),
+                    format!("Error unmapping region: {e}"),
                )
            })
    }
--- a/performance-metrics/Cargo.toml
+++ b/performance-metrics/Cargo.toml
@@ -6,13 +6,10 @@ edition = "2021"
 build = "build.rs"

 [dependencies]
-clap = { version = "3.2.22", features = ["wrap_help","cargo"] }
+clap = { version = "4.0.32", features = ["wrap_help"] }
 dirs = "4.0.0"
-serde = { version = "1.0.145", features = ["rc", "derive"] }
-serde_json = "1.0.85"
+serde = { version = "1.0.151", features = ["rc", "derive"] }
+serde_json = "1.0.89"
 test_infra = { path = "../test_infra" }
-thiserror = "1.0.37"
+thiserror = "1.0.38"
 wait-timeout = "0.2.0"
-
-[build-dependencies]
-clap = { version = "3.2.22", features = ["cargo"] }
--- a/Show More
+++ b/Show More