build: Release v48.0

Signed-off-by: Bo Chen <bchen@crusoe.ai>

.github/dependabot.yml

@@ -4,7 +4,7 @@ updates:
   directory: "/"
   schedule:
     interval: daily
-  open-pull-requests-limit: 3
+  open-pull-requests-limit: 1
   allow:
   - dependency-type: direct
   - dependency-type: indirect
@@ -12,7 +12,12 @@ updates:
   directory: "/fuzz"
   schedule:
     interval: daily
-  open-pull-requests-limit: 3
+  open-pull-requests-limit: 1
   allow:
   - dependency-type: direct
   - dependency-type: indirect
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 1

.github/workflows/audit.yaml

@@ -4,12 +4,13 @@ on:
     paths: 
       - '**/Cargo.toml'
       - '**/Cargo.lock'
+
 jobs:
   security_audit:
     name: Audit
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
-      - uses: actions-rs/audit-check@v1
+      - uses: actions/checkout@v5
+      - uses: actions-rust-lang/audit@v1
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build.yaml

@@ -1,9 +1,11 @@
 name: Cloud Hypervisor Build
-on: [pull_request, create]
+on: [pull_request, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
   build:
-    if: github.event_name == 'pull_request'
     name: Build
     runs-on: ubuntu-latest
     strategy:
@@ -13,44 +15,63 @@ jobs:
           - stable
           - beta
           - nightly
+          - "1.88.0"
         target:
           - x86_64-unknown-linux-gnu
           - x86_64-unknown-linux-musl
     steps:
       - name: Code checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 
+      - name: Install musl-gcc
+        run: sudo apt install -y musl-tools
+
       - name: Install Rust toolchain (${{ matrix.rust }})
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@stable
         with:
-            toolchain: ${{ matrix.rust }}
-            target: ${{ matrix.target }}
-            override: true
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
 
-      - name: Debug Check (default features)
-        run: |
-          git rev-list origin/main..$GITHUB_SHA | xargs -t -I % sh -c 'git checkout %; cargo check --all --target=${{ matrix.target }}'
-          git checkout $GITHUB_SHA
-
-      - name: Build (default + tdx)
-        run: cargo rustc --bin cloud-hypervisor --features "tdx" -- -D warnings
-
-      - name: Build (acpi,kvm)
-        run: cargo rustc --bin cloud-hypervisor --no-default-features --features "acpi,kvm"  -- -D warnings
+      - name: Build (default features)
+        run: cargo rustc --locked --bin cloud-hypervisor -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
 
       - name: Build (kvm)
-        run: cargo rustc --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 -W clippy::assertions_on_result_states
 
-      - name: Build (acpi,mshv)
-        run: cargo rustc --bin cloud-hypervisor --no-default-features --features "acpi,mshv"  -- -D warnings
+      - name: Build (default features + tdx)
+        run: cargo rustc --locked --bin cloud-hypervisor --features "tdx" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Build (default features + dbus_api)
+        run: cargo rustc --locked --bin cloud-hypervisor --features "dbus_api" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Build (default features + guest_debug)
+        run: cargo rustc --locked --bin cloud-hypervisor --features "guest_debug" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Build (default features + pvmemcontrol)
+        run: cargo rustc --locked --bin cloud-hypervisor --features "pvmemcontrol" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Build (default features + fw_cfg)
+        run: cargo rustc --locked --bin cloud-hypervisor --features "fw_cfg" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Build (default features + ivshmem)
+        run: cargo rustc --locked --bin cloud-hypervisor --features "ivshmem" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
 
       - name: Build (mshv)
-        run: cargo rustc --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 -W clippy::assertions_on_result_states
+
+      - name: Build (sev_snp)
+        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "sev_snp"  -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Build (igvm)
+        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "igvm"  -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Build (mshv + kvm)
+        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "mshv,kvm"  -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
       - name: Release Build (default features)
-        run: cargo build --all --release --target=${{ matrix.target }}
+        run: cargo build --locked --all --release --target=${{ matrix.target }}
 
       - name: Check build did not modify any files
         run: test -z "$(git status --porcelain)"

.github/workflows/dco.yaml

@@ -1,16 +1,18 @@
 name: DCO
-on:
-  pull_request:
+on: [pull_request, merge_group]
+
 jobs:
   check:
+    name: DCO Check ("Signed-Off-By")
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v5
     - name: Set up Python 3.x
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v6
       with:
         python-version: '3.x'
     - name: Check DCO
+      if: ${{ github.event_name == 'pull_request' }}
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       run: |

.github/workflows/docker-image.yaml

@@ -1,48 +1,65 @@
 name: Cloud Hypervisor's Docker image update
-
 on:
   push:
     branches: main
     paths: resources/Dockerfile
   pull_request:
     paths: resources/Dockerfile
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
 
 jobs:
   main:
     runs-on: ubuntu-latest
     steps:
       - name: Code checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v5
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v3
 
-      - name: Login to DockerHub
-        if: ${{ github.event_name == 'push' }}
-        uses: docker/login-action@v1 
+      - name: Login to ghcr
+        uses: docker/login-action@v3
         with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          # generate Docker tags based on the following events/attributes
+          tags: |
+            type=raw,value=20250815-0
+            type=sha
 
       - name: Build and push
         if: ${{ github.event_name == 'push' }}
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v6
         with:
           file: ./resources/Dockerfile
           platforms: linux/amd64,linux/arm64
           push: true
-          tags: cloudhypervisor/dev:latest
+          tags: ${{ steps.meta.outputs.tags }}
 
       - name: Build only
         if: ${{ github.event_name == 'pull_request' }}
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v6
         with:
           file: ./resources/Dockerfile
           platforms: linux/amd64,linux/arm64
-          tags: cloudhypervisor/dev:latest
+          tags: ${{ steps.meta.outputs.tags }}
 
       - name: Image digest
         run: echo ${{ steps.docker_build.outputs.digest }}

.github/workflows/formatting.yaml

@@ -0,0 +1,32 @@
+name: Cloud Hypervisor Code Formatting
+on: [pull_request, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Code Formatting
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust:
+          - nightly
+        target:
+          - x86_64-unknown-linux-gnu
+          - aarch64-unknown-linux-musl
+    env:
+      RUSTFLAGS: -D warnings
+    steps:
+      - name: Code checkout
+        uses: actions/checkout@v5
+      - name: Install Rust toolchain (${{ matrix.rust }})
+        uses: dtolnay/rust-toolchain@stable
+        with:
+            toolchain: ${{ matrix.rust }}
+            target: ${{ matrix.target }}
+            components: rustfmt
+      - name: Formatting (rustfmt)
+        run: cargo fmt --all -- --check
+      - name: Formatting (fuzz) (rustfmt)
+        run: cargo fmt --all --manifest-path fuzz/Cargo.toml -- --check

.github/workflows/fuzz-build.yaml

@@ -1,9 +1,11 @@
 name: Cloud Hypervisor Cargo Fuzz Build
-on: [pull_request, create]
+on: [pull_request, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
   build:
-    if: github.event_name == 'pull_request'
     name: Cargo Fuzz Build
     runs-on: ubuntu-latest
     strategy:
@@ -12,18 +14,19 @@ jobs:
           - nightly
         target:
           - x86_64-unknown-linux-gnu
+    env:
+      RUSTFLAGS: -D warnings
     steps:
       - name: Code checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v5
       - name: Install Rust toolchain (${{ matrix.rust }})
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@stable
         with:
             toolchain: ${{ matrix.rust }}
             target: ${{ matrix.target }}
-            override: true
       - name: Install Cargo fuzz
-        # Temporary fix for cargo-fuzz on latest nightly: https://github.com/rust-fuzz/cargo-fuzz/issues/276
-        #run: cargo install cargo-fuzz
-        run: cargo install --git https://github.com/rust-fuzz/cargo-fuzz --rev b4df3e58f767b5cad8d1aa6753961003f56f3609
-      - name: Cargo Fuzz Build
+        run: cargo install cargo-fuzz
+      - name: Fuzz Build
         run: cargo fuzz build
+      - name: Fuzz Check
+        run: cargo fuzz check

.github/workflows/gitlint.yaml

@@ -0,0 +1,25 @@
+name: Commit messages check
+on:
+  pull_request:
+
+jobs:
+  gitlint:
+    name: Check commit messages
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v5
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+        fetch-depth: 0
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v6
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade gitlint
+    - name: Lint git commit messages
+      run: |
+        gitlint --commits origin/$GITHUB_BASE_REF..

.github/workflows/hadolint.yaml

@@ -0,0 +1,25 @@
+name: Lint Dockerfile
+on:
+  push:
+    paths:
+    - resources/Dockerfile
+  pull_request:
+    paths:
+    - resources/Dockerfile
+
+jobs:
+  hadolint:
+    name: Run Hadolint Dockerfile Linter
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Lint Dockerfile
+        uses: hadolint/hadolint-action@master
+        with:
+          dockerfile: ./resources/Dockerfile
+          format: tty
+          no-fail: false
+          verbose: true
+          failure-threshold: info

.github/workflows/integration-arm64.yaml

@@ -0,0 +1,54 @@
+name: Cloud Hypervisor Tests (ARM64)
+on: [pull_request, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    timeout-minutes: 120
+    name: Tests (ARM64)
+    runs-on: bookworm-arm64
+    steps:
+      - name: Fix workspace permissions
+        run: sudo chown -R runner:runner ${GITHUB_WORKSPACE}
+      - name: Code checkout
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Run unit tests (musl)
+        run: scripts/dev_cli.sh tests --unit --libc musl
+      - name: Load openvswitch module
+        run: sudo modprobe openvswitch
+      - name: Run integration tests (musl)
+        timeout-minutes: 60
+        run: scripts/dev_cli.sh tests --integration --libc musl
+      - name: Install Azure CLI
+        if: ${{ github.event_name != 'pull_request' }}
+        run: |
+          sudo apt install -y ca-certificates curl apt-transport-https lsb-release gnupg
+          curl -sL https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/microsoft.gpg > /dev/null
+          echo "deb [arch=arm64] https://packages.microsoft.com/repos/azure-cli/ bookworm main" | sudo tee /etc/apt/sources.list.d/azure-cli.list
+          sudo apt update
+          sudo apt install -y azure-cli
+      - name: Download Windows image
+        if: ${{ github.event_name != 'pull_request' }}
+        shell: bash
+        run: |
+          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 "${{ secrets.CH_PRIVATE_IMAGES }}"
+          gzip -d $IMG_GZ_PATH
+      - name: Run Windows guest integration tests
+        if: ${{ github.event_name != 'pull_request' }}
+        timeout-minutes: 30
+        run: scripts/dev_cli.sh tests --integration-windows --libc musl

.github/workflows/integration-metrics.yaml

@@ -0,0 +1,22 @@
+name: Cloud Hypervisor Tests (Metrics)
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    name: Tests (Metrics)
+    runs-on: bare-metal-9950x
+    env:
+      METRICS_PUBLISH_KEY: ${{ secrets.METRICS_PUBLISH_KEY }}
+    steps:
+      - name: Code checkout
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Run metrics tests
+        timeout-minutes: 60
+        run: scripts/dev_cli.sh tests --metrics -- -- --report-file /root/workloads/metrics.json
+      - name: Upload metrics report
+        run: 'curl -X PUT https://ch-metrics.azurewebsites.net/api/publishmetrics -H "x-functions-key: $METRICS_PUBLISH_KEY" -T ~/workloads/metrics.json'

.github/workflows/integration-rate-limiter.yaml

@@ -0,0 +1,25 @@
+name: Cloud Hypervisor Tests (Rate-Limiter)
+on: [merge_group, pull_request]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Tests (Rate-Limiter)
+    runs-on: ${{ github.event_name == 'pull_request' && 'ubuntu-latest' || 'bare-metal-9950x' }}
+    env:
+      AUTH_DOWNLOAD_TOKEN: ${{ secrets.AUTH_DOWNLOAD_TOKEN }}
+    steps:
+      - name: Code checkout
+        if: ${{ github.event_name != 'pull_request' }}
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Run rate-limiter integration tests
+        if: ${{ github.event_name != 'pull_request' }}
+        timeout-minutes: 20
+        run: scripts/dev_cli.sh tests --integration-rate-limiter
+      - name: Skipping build for PR
+        if: ${{ github.event_name == 'pull_request' }}
+        run: echo "Skipping build for PR"

.github/workflows/integration-vfio.yaml

@@ -0,0 +1,33 @@
+name: Cloud Hypervisor Tests (VFIO)
+on: [merge_group, pull_request]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Tests (VFIO)
+    runs-on: ${{ github.event_name == 'pull_request' && 'ubuntu-latest' || 'vfio-nvidia' }}
+    env:
+      AUTH_DOWNLOAD_TOKEN: ${{ secrets.AUTH_DOWNLOAD_TOKEN }}
+    steps:
+      - name: Fix workspace permissions
+        if: ${{ github.event_name != 'pull_request' }}
+        run: sudo chown -R runner:runner ${GITHUB_WORKSPACE}
+      - name: Code checkout
+        if: ${{ github.event_name != 'pull_request' }}
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Run VFIO integration tests
+        if: ${{ github.event_name != 'pull_request' }}
+        timeout-minutes: 15
+        run: scripts/dev_cli.sh tests --integration-vfio
+      # Most tests are failing with musl see #6790
+      # - name: Run VFIO integration tests for musl
+      #   if: ${{ github.event_name != 'pull_request' }}
+      #   timeout-minutes: 15
+      #   run: scripts/dev_cli.sh tests --integration-vfio --libc musl
+      - name: Skipping build for PR
+        if: ${{ github.event_name == 'pull_request' }}
+        run: echo "Skipping build for PR"

.github/workflows/integration-windows.yaml

@@ -0,0 +1,50 @@
+name: Cloud Hypervisor Tests (Windows Guest)
+on: [merge_group, pull_request]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Tests (Windows Guest)
+    runs-on: ${{ github.event_name == 'pull_request' && 'ubuntu-latest' || 'garm-jammy-16' }}
+    steps:
+      - name: Code checkout
+        if: ${{ github.event_name != 'pull_request' }}
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Install Docker
+        if: ${{ github.event_name != 'pull_request' }}
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ca-certificates curl gnupg
+          curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
+          sudo chmod a+r /usr/share/keyrings/docker-archive-keyring.gpg
+          echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+          sudo apt-get update
+          sudo apt install -y docker-ce docker-ce-cli
+      - name: Install Azure CLI
+        if: ${{ github.event_name != 'pull_request' }}
+        run: |
+          sudo apt install -y ca-certificates curl apt-transport-https lsb-release gnupg
+          curl -sL https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/microsoft.gpg > /dev/null
+          echo "deb [arch=amd64] https://packages.microsoft.com/repos/azure-cli/ jammy main" | sudo tee /etc/apt/sources.list.d/azure-cli.list
+          sudo apt update
+          sudo apt install -y azure-cli
+      - name: Download Windows image
+        if: ${{ github.event_name != 'pull_request' }}
+        run: |
+          mkdir $HOME/workloads
+          az storage blob download --container-name private-images --file "$HOME/workloads/windows-server-2022-amd64-2.raw" --name windows-server-2022-amd64-2.raw --connection-string "${{ secrets.CH_PRIVATE_IMAGES }}"
+      - name: Run Windows guest integration tests
+        if: ${{ github.event_name != 'pull_request' }}
+        timeout-minutes: 15
+        run: scripts/dev_cli.sh tests --integration-windows
+      - name: Run Windows guest integration tests for musl
+        if: ${{ github.event_name != 'pull_request' }}
+        timeout-minutes: 15
+        run: scripts/dev_cli.sh tests --integration-windows --libc musl
+      - name: Skipping build for PR
+        if: ${{ github.event_name == 'pull_request' }}
+        run: echo "Skipping build for PR"

.github/workflows/integration-x86-64.yaml

@@ -0,0 +1,52 @@
+name: Cloud Hypervisor Tests (x86-64)
+on: [pull_request, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        runner: ['garm-jammy', "garm-jammy-amd"]
+        libc: ["musl", 'gnu']
+    name: Tests (x86-64)
+    runs-on: ${{ github.event_name == 'pull_request' && !(matrix.runner == 'garm-jammy' && matrix.libc == 'gnu') && 'ubuntu-latest' || format('{0}-16', matrix.runner) }}
+    steps:
+      - name: Code checkout
+        if: ${{ github.event_name != 'pull_request' || (matrix.runner == 'garm-jammy' && matrix.libc == 'gnu') }}
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Install Docker
+        if: ${{ github.event_name != 'pull_request' || (matrix.runner == 'garm-jammy' && matrix.libc == 'gnu') }}
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ca-certificates curl gnupg
+          curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
+          sudo chmod a+r /usr/share/keyrings/docker-archive-keyring.gpg
+          echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+          sudo apt-get update
+          sudo apt install -y docker-ce docker-ce-cli
+      - name: Prepare for VDPA
+        if: ${{ github.event_name != 'pull_request' || (matrix.runner == 'garm-jammy' && matrix.libc == 'gnu') }}
+        run: scripts/prepare_vdpa.sh
+      - name: Run unit tests
+        if: ${{ github.event_name != 'pull_request' || (matrix.runner == 'garm-jammy' && matrix.libc == 'gnu') }}
+        run: scripts/dev_cli.sh tests --unit --libc ${{ matrix.libc }}
+      - name: Load openvswitch module
+        if: ${{ github.event_name != 'pull_request' || (matrix.runner == 'garm-jammy' && matrix.libc == 'gnu') }}
+        run: sudo modprobe openvswitch
+      - name: Run integration tests
+        if: ${{ github.event_name != 'pull_request' || (matrix.runner == 'garm-jammy' && matrix.libc == 'gnu') }}
+        timeout-minutes: 40
+        run: scripts/dev_cli.sh tests --integration --libc ${{ matrix.libc }}
+      - name: Run live-migration integration tests
+        if: ${{ github.event_name != 'pull_request' || (matrix.runner == 'garm-jammy' && matrix.libc == 'gnu') }}
+        timeout-minutes: 20
+        run: scripts/dev_cli.sh tests --integration-live-migration --libc ${{ matrix.libc }}
+      - name: Skipping build for PR
+        if: ${{ github.event_name == 'pull_request' && matrix.runner != 'garm-jammy' && matrix.libc != 'gnu' }}
+        run: echo "Skipping build for PR"

.github/workflows/lychee.yaml

@@ -0,0 +1,45 @@
+name: Link Check (lychee)
+on: pull_request
+jobs:
+  link_check:
+    name: Link Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Code checkout
+        uses: actions/checkout@v5
+        with:
+          # Fetch the entire history so git diff can compare against the base branch
+          fetch-depth: 0
+      - name: Get changed files in PR
+        id: changed-files
+        uses: tj-actions/changed-files@v46 # Using a dedicated action for robustness
+        with:
+          # Compare the HEAD of the PR with the merge-base (where the PR branches off)
+          base_sha: ${{ github.event.pull_request.base.sha }}
+
+      # NEW STEP: Print all changed-files outputs for verification
+      - name: Verify Changed Files
+        run: |
+          echo "--- tj-actions/changed-files Outputs ---"
+          echo "any_changed: ${{ steps.changed-files.outputs.any_changed }}"
+          echo "all_changed_files: ${{ steps.changed-files.outputs.all_changed_files }}"
+          echo "added_files: ${{ steps.changed-files.outputs.added_files }}"
+          echo "modified_files: ${{ steps.changed-files.outputs.modified_files }}"
+          echo "deleted_files: ${{ steps.changed-files.outputs.deleted_files }}"
+          echo "renamed_files: ${{ steps.changed-files.outputs.renamed_files }}"
+          echo "----------------------------------------"
+          # This will also show if the all_changed_files string is empty or not
+          if [ -n "${{ steps.changed-files.outputs.all_changed_files }}" ]; then
+            echo "Detected changes: all_changed_files output is NOT empty."
+          else
+            echo "No changes detected: all_changed_files output IS empty."
+          fi
+      - name: Link Availability Check (Diff Only)
+        # MODIFIED: Only run lychee if the 'all_changed_files' output is not an empty string
+        if: ${{ steps.changed-files.outputs.all_changed_files != '' }}
+        uses: lycheeverse/lychee-action@master
+        with:
+          # Pass the space-separated list of changed files to lychee
+          args: --verbose --config .lychee.toml ${{ steps.changed-files.outputs.all_changed_files }}
+          failIfEmpty: false
+          fail: true

.github/workflows/openapi.yaml

@@ -0,0 +1,14 @@
+name: Cloud Hypervisor OpenAPI Validation
+on: [pull_request, merge_group]
+
+jobs:
+  Validate:
+    runs-on: ubuntu-latest
+    container: openapitools/openapi-generator-cli
+    steps:
+    - uses: actions/checkout@v5
+    - name: Validate OpenAPI
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: |
+        /usr/local/bin/docker-entrypoint.sh validate -i vmm/src/api/openapi/cloud-hypervisor.yaml

.github/workflows/package-consistency.yaml

@@ -0,0 +1,32 @@
+name: Cloud Hypervisor Consistency
+on: [pull_request, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Rust VMM Consistency Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Code checkout
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Install dependencies
+        run: sudo apt install -y python3
+
+      - name: Install Rust toolchain stable
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+
+      - name: Check Rust VMM Package Consistency of root Workspace
+        run: python3 scripts/package-consistency-check.py github.com/rust-vmm
+
+      - name: Check Rust VMM Package Consistency of fuzz Workspace
+        run: |
+          pushd fuzz
+          python3 ../scripts/package-consistency-check.py github.com/rust-vmm
+          popd

.github/workflows/preview-riscv64-build.yaml

@@ -0,0 +1,30 @@
+name: Cloud Hypervisor RISC-V 64-bit kvm build Preview
+on: [pull_request, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Cargo
+    runs-on: riscv64-qemu-host
+    strategy:
+      fail-fast: false
+
+    steps:
+      - name: Code checkout
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Install Rust toolchain
+        run: /opt/scripts/exec-in-qemu.sh rustup default 1.88.0
+
+      - name: Build test (kvm)
+        run: /opt/scripts/exec-in-qemu.sh cargo rustc --locked --no-default-features --features "kvm"
+
+      - name: Clippy test (kvm)
+        run: /opt/scripts/exec-in-qemu.sh cargo clippy --locked --no-default-features --features "kvm"
+
+      - name: Check no files were modified
+        run: test -z "$(git status --porcelain)"

.github/workflows/preview-riscv64-modules.yaml

@@ -0,0 +1,39 @@
+name: Cloud Hypervisor RISC-V 64-bit Preview
+on: [pull_request, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Cargo
+    runs-on: riscv64-qemu-host
+    strategy:
+      fail-fast: false
+      matrix:
+        module:
+          - hypervisor
+          - arch
+          - vm-allocator
+          - devices
+
+    steps:
+      - name: Code checkout
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Install Rust toolchain
+        run: /opt/scripts/exec-in-qemu.sh rustup default 1.88.0
+
+      - name: Build ${{ matrix.module }} Module (kvm)
+        run: /opt/scripts/exec-in-qemu.sh cargo rustc --locked -p ${{ matrix.module }} --no-default-features --features "kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Clippy ${{ matrix.module }} Module (kvm)
+        run: /opt/scripts/exec-in-qemu.sh cargo clippy --locked -p ${{ matrix.module }} --no-default-features --features "kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Test ${{ matrix.module }} Module (kvm)
+        run: /opt/scripts/exec-in-qemu.sh cargo test --locked -p ${{ matrix.module }} --no-default-features --features "kvm"
+
+      - name: Check no files were modified
+        run: test -z "$(git status --porcelain)"

.github/workflows/quality-aarch64.yaml

@@ -1,61 +0,0 @@
-name: Cloud Hypervisor Quality Checks
-on: [pull_request, create]
-
-jobs:
-  build:
-    if: github.event_name == 'pull_request'
-    name: Quality (clippy, rustfmt)
-    runs-on: ubuntu-latest
-    continue-on-error: ${{ matrix.experimental }}
-    strategy:
-      fail-fast: false
-      matrix:
-        rust:
-          - stable
-        target:
-          - aarch64-unknown-linux-gnu
-        experimental: [false]
-        include:
-          - rust: beta
-            target: aarch64-unknown-linux-gnu
-            experimental: true
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@v2
-      - name: Install Rust toolchain (${{ matrix.rust }})
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ matrix.rust }}
-            target: ${{ matrix.target }}
-            override: true
-            components: rustfmt, clippy
-      - name: Formatting (rustfmt)
-        run: cargo fmt -- --check
-
-      - name: Clippy (kvm)
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: clippy
-          args: --target=${{ matrix.target }} --all --no-default-features --features "kvm" -- -D warnings
-
-      - name: Clippy (kvm,acpi)
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: clippy
-          args: --target=${{ matrix.target }} --all --no-default-features --features "kvm,acpi" -- -D warnings
-
-      - name: Clippy (all features,kvm)
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: clippy
-          args: --target=${{ matrix.target }} --all --no-default-features --features "common,kvm" -- -D warnings
-
-      - name: Clippy (default)
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: clippy
-          args: --target=${{ matrix.target }} --all -- -D warnings

.github/workflows/quality.yaml

@@ -1,61 +1,170 @@
 name: Cloud Hypervisor Quality Checks
-on: [pull_request, create]
+on: [pull_request, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
   build:
-    if: github.event_name == 'pull_request'
-    name: Quality (clippy, rustfmt)
+    name: Quality (clippy)
     runs-on: ubuntu-latest
     continue-on-error: ${{ matrix.experimental }}
     strategy:
       fail-fast: false
       matrix:
         rust:
+          - beta
           - stable
         target:
+          - aarch64-unknown-linux-gnu
+          - aarch64-unknown-linux-musl
           - x86_64-unknown-linux-gnu
-        experimental: [false]
+          - x86_64-unknown-linux-musl
+
         include:
           - rust: beta
-            target: x86_64-unknown-linux-gnu
             experimental: true
+          - rust: stable
+            experimental: false
+
     steps:
       - name: Code checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
       - name: Install Rust toolchain (${{ matrix.rust }})
         uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ matrix.rust }}
           target: ${{ matrix.target }}
           override: true
-          components: rustfmt, clippy
+          components: clippy
 
-      - name: Formatting (rustfmt)
-        run: cargo fmt -- --check
-
-      - name: Clippy (all features,kvm)
-        run: cargo clippy --all --all-targets --no-default-features --tests --features "common,kvm" -- -D warnings
-
-      - name: Clippy (all features,mshv)
-        run: cargo clippy --all --all-targets --no-default-features --tests --features "common,mshv" -- -D warnings
-
-      - name: Clippy (acpi,kvm)
-        run: cargo clippy --all --all-targets --no-default-features --tests --features "acpi,kvm" -- -D warnings
-
-      - name: Clippy (acpi,kvm,tdx)
-        run: cargo clippy --all --all-targets --no-default-features --tests --features "acpi,kvm,tdx" -- -D warnings
+      - name: Bisectability Check (default features)
+        if: ${{ github.event_name == 'pull_request' && matrix.target == 'x86_64-unknown-linux-gnu' }}
+        run: |
+          set -e
+          commits=$(git rev-list origin/${{ github.base_ref }}..${{ github.sha }})
+          for commit in $commits; do git checkout $commit; cargo check --tests --examples --all --target=${{ matrix.target }}; done
+          git checkout ${{ github.sha }}
 
       - name: Clippy (kvm)
-        run: cargo clippy --all --all-targets --no-default-features --tests --features "kvm" -- -D warnings
-
-      - name: Clippy (acpi,mshv)
-        run: cargo clippy --all --all-targets --no-default-features --tests --features "acpi,mshv" -- -D warnings
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --no-default-features --tests --examples --features "kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
 
       - name: Clippy (mshv)
-        run: cargo clippy --all --all-targets --no-default-features --tests --features "mshv" -- -D warnings
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --no-default-features --tests --examples --features "mshv" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
 
-      - name: Clippy (integration tests)
-        run: cargo clippy --all --all-targets --tests -- -D warnings
+      - name: Clippy (mshv + kvm)
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --no-default-features --tests --examples --features "mshv,kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Clippy (default features)
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --tests --examples -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Clippy (default features + guest_debug)
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --tests --examples --features "guest_debug" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Clippy (default features + pvmemcontrol)
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --tests --examples --features "pvmemcontrol" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Clippy (default features + tracing)
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --tests --examples --features "tracing" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+      - name: Clippy (default features + fw_cfg)
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
+          command: clippy
+          args: --target=${{ matrix.target }} --locked --all --all-targets --tests --examples --features "fw_cfg" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Clippy (default features + ivshmem)
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --tests --examples --features "ivshmem" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Clippy (sev_snp)
+        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --no-default-features --tests --examples --features "sev_snp" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Clippy (igvm)
+        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --no-default-features --tests --examples --features "igvm" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
+
+      - name: Clippy (kvm + tdx)
+        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
+        uses: houseabsolute/actions-rust-cross@v1
+        with:
+          command: clippy
+          cross-version: 3e0957637b49b1bbced23ad909170650c5b70635
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          args: --locked --all --all-targets --no-default-features --tests --examples --features "tdx,kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks -W clippy::assertions_on_result_states
 
       - name: Check build did not modify any files
         run: test -z "$(git status --porcelain)"
+
+  typos:
+    if: github.event_name == 'pull_request'
+    name: Typos / Spellcheck
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      # Executes "typos ."
+      - uses: crate-ci/typos@v1.36.2

.github/workflows/release.yaml

@@ -1,131 +1,95 @@
 name: Cloud Hypervisor Release
-on: [create]
+on: [create, merge_group]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name }}
+  cancel-in-progress: true
+env:
+  GITHUB_TOKEN: ${{ github.token }}
 
 jobs:
   release:
-    if: github.event_name == 'create' && github.event.ref_type == 'tag'
-    name: Release
+    if: (github.event_name == 'create' && github.event.ref_type == 'tag') || github.event_name == 'merge_group'
+    name: Release ${{ matrix.platform.target }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+        - target: x86_64-unknown-linux-gnu
+          args: --all --release --features mshv
+          name_ch: cloud-hypervisor
+          name_ch_remote: ch-remote
+        - target: x86_64-unknown-linux-musl
+          args: --all --release --features mshv
+          name_ch: cloud-hypervisor-static
+          name_ch_remote: ch-remote-static
+        - target: aarch64-unknown-linux-musl
+          args:  --all --release
+          name_ch: cloud-hypervisor-static-aarch64
+          name_ch_remote: ch-remote-static-aarch64
     runs-on: ubuntu-latest
     steps:
       - name: Code checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v5
+      - name: Install musl-gcc
+        if: contains(matrix.platform.target, 'musl')
+        run: sudo apt install -y musl-tools
       - name: Create release directory
+        if: |
+          github.event_name == 'create' && github.event.ref_type == 'tag' &&
+          matrix.platform.target == 'x86_64-unknown-linux-gnu'
         run: rsync -rv --exclude=.git . ../cloud-hypervisor-${{ github.event.ref }}
-      - name: Install Rust toolchain (x86_64-unknown-linux-gnu)
-        uses: actions-rs/toolchain@v1
+      - name: Build ${{ matrix.platform.target }}
+        uses: houseabsolute/actions-rust-cross@v1
         with:
-            toolchain: stable
-            target: x86_64-unknown-linux-gnu
-      - name: Install Rust toolchain (x86_64-unknown-linux-musl)
-        uses: actions-rs/toolchain@v1
+          command: build
+          target: ${{ matrix.platform.target }}
+          args: ${{ matrix.platform.args  }}
+          strip: true
+          toolchain: "1.88.0"
+      - name: Copy Release Binaries
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
+        shell: bash
+        run: |
+          cp target/${{ matrix.platform.target }}/release/cloud-hypervisor ./${{ matrix.platform.name_ch }}
+          cp target/${{ matrix.platform.target }}/release/ch-remote ./${{ matrix.platform.name_ch_remote }}
+      - name: Upload Release Artifacts
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
+        uses: actions/upload-artifact@v4
         with:
-            toolchain: stable
-            target: x86_64-unknown-linux-musl
-      - name: Build
-        run: cargo build --all --release --target=x86_64-unknown-linux-gnu
-      - name: Static Build
-        run: cargo build --all --release --target=x86_64-unknown-linux-musl
-      - name: Strip cloud-hypervisor binaries
-        run: strip target/*/release/cloud-hypervisor
-      - name: Install Rust toolchain (aarch64-unknown-linux-musl)
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: stable
-            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: Artifacts for ${{ matrix.platform.target }}
+          path: |
+            ./${{ matrix.platform.name_ch }}
+            ./${{ matrix.platform.name_ch_remote }}
       - name: Vendor
+        if: |
+          github.event_name == 'create' && github.event.ref_type == 'tag' &&
+          matrix.platform.target == 'x86_64-unknown-linux-gnu'
         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 Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          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 }}
+        if: |
+          github.event_name == 'create' && github.event.ref_type == 'tag' &&
+          matrix.platform.target == 'x86_64-unknown-linux-gnu'
+        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' &&
+          matrix.platform.target == 'x86_64-unknown-linux-gnu'
         id: upload-release-cloud-hypervisor-vendored-sources
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        uses: actions/upload-artifact@v4
         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
-        id: upload-release-cloud-hypervisor
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          path: cloud-hypervisor-${{ github.event.ref }}.tar.xz
+          name: cloud-hypervisor-${{ github.event.ref }}.tar.xz
+      - name: Create GitHub Release
+        if: github.event_name == 'create' && github.event.ref_type == 'tag'
+        uses: softprops/action-gh-release@v2
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/x86_64-unknown-linux-gnu/release/cloud-hypervisor
-          asset_name: cloud-hypervisor
-          asset_content_type: application/octet-stream
-      - name: Upload static cloud-hypervisor
-        id: upload-release-static-cloud-hypervisor
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/x86_64-unknown-linux-musl/release/cloud-hypervisor
-          asset_name: cloud-hypervisor-static
-          asset_content_type: application/octet-stream
-      - name: Upload ch-remote
-        id: upload-release-ch-remote
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/x86_64-unknown-linux-gnu/release/ch-remote
-          asset_name: ch-remote
-          asset_content_type: application/octet-stream
-      - name: Upload static-ch-remote
-        id: upload-release-static-ch-remote
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/x86_64-unknown-linux-musl/release/ch-remote
-          asset_name: ch-remote-static
-          asset_content_type: application/octet-stream
-      - name: Upload static AArch64 cloud-hypervisor
-        id: upload-release-static-aarch64-cloud-hypervisor
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/aarch64-unknown-linux-musl/release/cloud-hypervisor
-          asset_name: cloud-hypervisor-static-aarch64
-          asset_content_type: application/octet-stream
-      - name: Upload static AArch64 ch-remote
-        id: upload-release-static-aarch64-ch-remote
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/aarch64-unknown-linux-musl/release/ch-remote
-          asset_name: ch-remote-static-aarch64
-          asset_content_type: application/octet-stream
+          draft: true
+          files: |
+            ./${{ matrix.platform.name_ch }}
+            ./${{ matrix.platform.name_ch_remote }}
+            ./cloud-hypervisor-${{ github.event.ref }}.tar.xz

.github/workflows/reuse.yaml

@@ -0,0 +1,12 @@
+name: REUSE Compliance Check
+
+on: [push, pull_request]
+
+jobs:
+  reuse:
+    name: REUSE Compliance Check
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v5
+    - name: REUSE Compliance Check
+      uses: fsfe/reuse-action@v5

.github/workflows/shlint.yaml

@@ -0,0 +1,20 @@
+name: Shell scripts check
+on:
+  pull_request:
+  merge_group:
+  push:
+    branches:
+      - main
+
+jobs:
+  sh-checker:
+    name: Check shell scripts
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v5
+    - name: Run the shell script checkers
+      uses: luizm/action-sh-checker@master
+      env:
+        SHFMT_OPTS: -i 4 -d
+        SHELLCHECK_OPTS: -x --source-path scripts

.github/workflows/taplo.yaml

@@ -0,0 +1,21 @@
+name: Cargo.toml Formatting (taplo)
+on:
+  pull_request:
+    paths: 
+      - '**/Cargo.toml'
+
+jobs:
+  cargo_toml_format:
+    name: Cargo.toml Formatting
+    runs-on: ubuntu-latest
+    steps:
+      - name: Code checkout
+        uses: actions/checkout@v5
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Install build dependencies
+        run: sudo apt-get update && sudo apt-get -yqq install build-essential libssl-dev
+      - name: Install taplo
+        run: cargo install taplo-cli --locked
+      - name: Check formatting
+        run: taplo fmt --check

.gitignore

@@ -4,3 +4,7 @@
 **/*.rs.bk
 **/Cargo.lock
 **/rusty-tags.vi
+/rpm/SOURCES
+/.vscode
+/vendor
+__pycache__

.gitlint

@@ -0,0 +1,13 @@
+[general]
+extra-path=scripts/gitlint/rules
+regex-style-search=true
+ignore=body-max-line-length
+
+[ignore-by-author-name]
+regex=dependabot
+ignore=all
+
+# default 72
+[title-max-length]
+line-length=72
+

.lychee.toml

@@ -0,0 +1,27 @@
+verbose = "info"
+
+exclude = [
+    # Availability of links below should be manually verified.
+    # Page for intel TDX support, returns 403 while querying.
+    '^https://www.intel.com/content/www/us/en/developer/tools/trust-domain-extensions/overview.html',
+    # Page for TPM, returns 403 while querying.
+    '^https://trustedcomputinggroup.org/wp-content/uploads/PC-Client-Specific-Platform-TPM-Profile-for-TPM-2p0-v1p05p_r14_pub.pdf',
+
+    # GitHub user smibarber referenced in `CREDITS.md` no longer exist
+    '^https://github.com/smibarber',
+
+    # OSDev has added bot protection and accesses my result in 403 Forbidden.
+    '^https://wiki.osdev.org',
+    # Exclude all pages with $ in the URL since $XXX is a variable
+    "\\$.*",
+    # Exclude local files
+    "file://.*",
+]
+
+# Exclude loopback addresses
+exclude_loopback = true
+
+
+max_retries = 3
+
+retry_wait_time = 5

.reuse/dep5

@@ -0,0 +1,12 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: cloud-hypervisor
+Upstream-Contact:  <>
+Source: https://www.cloudhypervisor.org
+
+Files: docs/*.md *.md
+Copyright: 2024
+License: CC-BY-4.0
+
+Files: scripts/* test_data/* *.toml .git* fuzz/Cargo.lock fuzz/.gitignore resources/linux-config-* vmm/src/api/openapi/cloud-hypervisor.yaml CODEOWNERS Cargo.lock
+Copyright: 2024
+License: Apache-2.0

.rustfmt.toml

@@ -1 +1,4 @@
-edition = "2018"
+edition = "2024"
+group_imports="StdExternalCrate"
+imports_granularity="Module"
+

.taplo.toml

@@ -0,0 +1,5 @@
+include = ["**/Cargo.toml"]
+
+[formatting]
+reorder_arrays = true
+reorder_keys = true

.typos.toml

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

CODEOWNERS

@@ -0,0 +1,2 @@
+# Add the list of code owners here (using their GitHub username)
+* @cloud-hypervisor/cloud-hypervisor-reviewers

CONTRIBUTING.md

@@ -2,22 +2,41 @@
 
 Cloud Hypervisor is an open source project licensed under the [Apache v2
 License](https://opensource.org/licenses/Apache-2.0) and the [BSD 3
-Clause](https://opensource.org/licenses/BSD-3-Clause) license. Contributions
-can be made under either license or both. Individual files contain details of
-their licensing and changes to that file are under the same license unless the
-contribution changes the license of the file. When importing code from a third
-party project (e.g. Firecracker or CrosVM) please respect the license of those
-projects.
+Clause](https://opensource.org/licenses/BSD-3-Clause) license. Individual files
+contain details of their licensing and changes to that file are under the same
+license unless the contribution changes the license of the file. When importing
+code from a third party project (e.g. Firecracker or crosvm) please respect the
+license of those projects.
+
+New code should be under the [Apache v2
+License](https://opensource.org/licenses/Apache-2.0).
 
 ## Coding Style
 
-We follow the [Rust Style](https://github.com/rust-dev-tools/fmt-rfcs/blob/master/guide/guide.md)
+We follow the [Rust Style](https://github.com/rust-lang/rust/tree/HEAD/src/doc/style-guide/src)
 convention and enforce it through the Continuous Integration (CI) process calling into `rustfmt`
 for each submitted Pull Request (PR).
 
+## Basic Checks
+
+Please consider creating the following hook as `.git/hooks/pre-commit` in order
+to ensure basic correctness of your code. You can extend this further if you
+have specific features that you regularly develop against.
+
+```sh
+#!/bin/sh
+
+cargo fmt -- --check || exit 1
+cargo check --locked --all --all-targets --tests || exit 1
+cargo clippy --locked --all --all-targets --tests -- -D warnings || exit 1
+```
+
+You will need to `chmod +x .git/hooks/pre-commit` to have it run on every
+commit you make.
+
 ## Certificate of Origin
 
-In order to get a clear contribution chain of trust we use the [signed-off-by language](https://01.org/community/signed-process)
+In order to get a clear contribution chain of trust we use the [signed-off-by language](https://web.archive.org/web/20230406041855/https://01.org/community/signed-process)
 used by the Linux kernel project.
 
 ## Patch format
@@ -60,14 +79,12 @@ you want to merge your changes to `cloud-hypervisor`:
 
 1. Fork the [cloud-hypervisor](https://github.com/cloud-hypervisor/cloud-hypervisor) project
    into your github organization.
-2. Within your fork, create a branch for your contribution.
-3. [Create a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/)
+1. Within your fork, create a branch for your contribution.
+1. [Create a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/)
    against the main branch of the Cloud Hypervisor repository.
-4. Add reviewers to your pull request and then work with your reviewers to address
-   any comments and obtain minimum of 2 [maintainers](MAINTAINERS.md) approvals.
-   To update your pull request amend existing commits whenever applicable and
+1. To update your pull request amend existing commits whenever applicable and
    then push the new changes to your pull request branch.
-5. Once the pull request is approved, one of the maintainers will merge it.
+1. Once the pull request is approved it can be integrated.
 
 ## Issue tracking
 
@@ -95,5 +112,15 @@ Fixes #88
 Signed-off-by: Sebastien Boeuf <sebastien.boeuf@intel.com>
 ```
 
-Then, after the corresponding PR is merged, Github will automatically close that issue when parsing the
+Then, after the corresponding PR is merged, GitHub will automatically close that issue when parsing the
 [commit message](https://help.github.com/articles/closing-issues-via-commit-messages/).
+
+## AI Generated Code
+
+Our policy is to decline any contributions known to contain contents
+generated or derived from using Large Language Models (LLMs). This
+includes ChatGPT, Gemini, Claude, Copilot and similar tools.
+
+The goal is to avoid ambiguity in license compliance and optimize the
+use of limited project resources, especially for code review and
+maintenance. This policy can be revisited as LLMs evolve and mature.

Cargo.toml

@@ -1,89 +1,155 @@
 [package]
-name = "cloud-hypervisor"
-version = "21.0.0"
 authors = ["The Cloud Hypervisor Authors"]
-edition = "2018"
-default-run = "cloud-hypervisor"
 build = "build.rs"
-license = "LICENSE-APACHE & LICENSE-BSD-3-Clause"
-description = "Open source Virtual Machine Monitor (VMM) that runs on top of KVM"
+default-run = "cloud-hypervisor"
+description = "Open source Virtual Machine Monitor (VMM) that runs on top of KVM & MSHV"
+edition = "2024"
 homepage = "https://github.com/cloud-hypervisor/cloud-hypervisor"
+license = "Apache-2.0 AND BSD-3-Clause"
+name = "cloud-hypervisor"
+version = "48.0.0"
+# Minimum buildable version:
+# Keep in sync with version in .github/workflows/build.yaml
+# Policy on MSRV (see #4318):
+# Can only be bumped if satisfying any of the following:
+# 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.88.0"
 
 [profile.release]
+codegen-units = 1
 lto = true
+opt-level = "s"
+strip = true
+
+[profile.profiling]
+debug = true
+inherits = "release"
+strip = false
 
 [dependencies]
-anyhow = "1.0.52"
+anyhow = { workspace = true }
 api_client = { path = "api_client" }
-clap = { version = "3.0.10", features = ["wrap_help","cargo"] }
-epoll = "4.3.1"
+clap = { workspace = true, features = ["string"] }
+dhat = { workspace = true, optional = true }
+env_logger = { workspace = true }
+epoll = { workspace = true }
 event_monitor = { path = "event_monitor" }
 hypervisor = { path = "hypervisor" }
-libc = "0.2.112"
-log = { version = "0.4.14", features = ["std"] }
+libc = { workspace = true }
+log = { workspace = true, features = ["std"] }
 option_parser = { path = "option_parser" }
-seccompiler = "0.2.0"
-serde_json = "1.0.75"
-signal-hook = "0.3.13"
-thiserror = "1.0.30"
+seccompiler = { workspace = true }
+serde_json = { workspace = true }
+signal-hook = { workspace = true }
+thiserror = { workspace = true }
+tpm = { path = "tpm" }
+tracer = { path = "tracer" }
+vm-memory = { workspace = true }
 vmm = { path = "vmm" }
-vmm-sys-util = "0.9.0"
-vm-memory = "0.7.0"
-
-[build-dependencies]
-clap = { version = "3.0.10", features = ["wrap_help"] }
-
-# List of patched crates
-[patch.crates-io]
-kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.5.0", features = ["with-serde", "fam-wrappers"] }
-kvm-ioctls = { git = "https://github.com/rust-vmm/kvm-ioctls", branch = "main" }
-versionize_derive = { git = "https://github.com/cloud-hypervisor/versionize_derive", branch = "ch" }
+vmm-sys-util = { workspace = true }
+zbus = { version = "5.7.1", optional = true }
 
 [dev-dependencies]
-dirs = "4.0.0"
-lazy_static= "1.4.0"
+dirs = { workspace = true }
 net_util = { path = "net_util" }
-serde_json = "1.0.75"
+serde_json = { workspace = true }
 test_infra = { path = "test_infra" }
-wait-timeout = "0.2.0"
+wait-timeout = { workspace = true }
 
+# Please adjust `vmm::feature_list()` accordingly when changing the
+# feature list below
 [features]
-default = ["common", "kvm"]
-# Common features for all hypervisors
-common = ["acpi", "cmos", "fwdebug"]
-acpi = ["vmm/acpi"]
-cmos = ["vmm/cmos"]
-fwdebug = ["vmm/fwdebug"]
+dbus_api = ["vmm/dbus_api", "zbus"]
+default = ["io_uring", "kvm"]
+dhat-heap = ["dhat", "vmm/dhat-heap"]       # For heap profiling
+fw_cfg = ["vmm/fw_cfg"]
+guest_debug = ["vmm/guest_debug"]
+igvm = ["mshv", "vmm/igvm"]
+io_uring = ["vmm/io_uring"]
+ivshmem = ["vmm/ivshmem"]
 kvm = ["vmm/kvm"]
 mshv = ["vmm/mshv"]
+pvmemcontrol = ["vmm/pvmemcontrol"]
+sev_snp = ["igvm", "mshv", "vmm/sev_snp"]
 tdx = ["vmm/tdx"]
+tracing = ["tracer/tracing", "vmm/tracing"]
 
 [workspace]
 members = [
-    "acpi_tables",
-    "api_client",
-    "arch",
-    "block_util",
-    "devices",
-    "event_monitor",
-    "hypervisor",
-    "net_gen",
-    "net_util",
-    "option_parser",
-    "pci",
-    "qcow",
-    "rate_limiter",
-    "vfio_user",
-    "vhdx",
-    "vhost_user_backend",
-    "vhost_user_block",
-    "vhost_user_net",
-    "virtio-devices",
-    "virtio-queue",
-    "vmm",
-    "vm-allocator",
-    "vm-device",
-    "vm-migration",
-    "vm-virtio"
+  "api_client",
+  "arch",
+  "block",
+  "devices",
+  "event_monitor",
+  "hypervisor",
+  "net_gen",
+  "net_util",
+  "option_parser",
+  "pci",
+  "performance-metrics",
+  "rate_limiter",
+  "serial_buffer",
+  "test_infra",
+  "tracer",
+  "vhost_user_block",
+  "vhost_user_net",
+  "virtio-devices",
+  "vm-allocator",
+  "vm-device",
+  "vm-migration",
+  "vm-virtio",
+  "vmm",
 ]
-exclude = ["test_infra"]
+package.edition = "2024"
+
+[workspace.dependencies]
+# rust-vmm crates
+acpi_tables = { git = "https://github.com/rust-vmm/acpi_tables", branch = "main" }
+kvm-bindings = "0.12.0"
+kvm-ioctls = "0.22.0"
+# TODO: update to 0.13.1+
+linux-loader = { git = "https://github.com/rust-vmm/linux-loader", branch = "main" }
+mshv-bindings = "0.6.0"
+mshv-ioctls = "0.6.0"
+seccompiler = "0.5.0"
+vfio-bindings = { version = "0.6.0", default-features = false }
+vfio-ioctls = { version = "0.5.1", default-features = false }
+vfio_user = { version = "0.1.1", default-features = false }
+vhost = { version = "0.14.0", default-features = false }
+vhost-user-backend = { version = "0.20.0", default-features = false }
+virtio-bindings = "0.2.6"
+virtio-queue = "0.16.0"
+vm-fdt = { git = "https://github.com/rust-vmm/vm-fdt", branch = "main" }
+vm-memory = "0.16.1"
+vmm-sys-util = "0.14.0"
+
+# igvm crates
+# TODO: bump to 0.3.5 release
+igvm = { git = "https://github.com/microsoft/igvm", branch = "main" }
+igvm_defs = { git = "https://github.com/microsoft/igvm", branch = "main" }
+
+# serde crates
+serde = "1.0.208"
+serde_json = "1.0.143"
+serde_with = { version = "3.14.0", default-features = false }
+
+# other crates
+anyhow = "1.0.98"
+bitflags = "2.9.4"
+byteorder = "1.5.0"
+cfg-if = "1.0.0"
+clap = "4.5.47"
+dhat = "0.3.3"
+dirs = "6.0.0"
+env_logger = "0.11.8"
+epoll = "4.3.3"
+flume = "0.11.1"
+libc = "0.2.167"
+log = "0.4.22"
+signal-hook = "0.3.18"
+thiserror = "2.0.12"
+uuid = { version = "1.18.1" }
+wait-timeout = "0.2.1"
+zerocopy = { version = "0.8.26", default-features = false }

Jenkinsfile

@@ -1,299 +0,0 @@
-pipeline{
-	agent none
-	stages {
-		stage ('Early checks') {
-			agent { node { label 'built-in' } }
-			stages {
-				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 'hirsute' } }
-					environment {
-        					AZURE_CONNECTION_STRING = credentials('46b4e7d6-315f-4cc1-8333-b58780863b9b')
-					}
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-
-						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' } }
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-						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"
-							}
-						}
-					}
-					post {
-						always {
-							sh "sudo chown -R jenkins.jenkins ${WORKSPACE}"
-							deleteDir()
-						}
-					}
-				}
-				stage ('Worker build (musl)') {
-					agent { node { label 'hirsute' } }
-					environment {
-        					AZURE_CONNECTION_STRING = credentials('46b4e7d6-315f-4cc1-8333-b58780863b9b')
-					}
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-
-						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 SGX') {
-					agent { node { label 'bionic-sgx' } }
-					when {
-						beforeAgent true
-						branch 'main'
-					}
-					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 'bionic-vfio' } }
-					when {
-						beforeAgent true
-						branch 'main'
-					}
-					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()
-						}
-					}
-				}
-				stage ('Worker build - Windows guest') {
-					agent { node { label 'hirsute' } }
-					environment {
-        					AZURE_CONNECTION_STRING = credentials('46b4e7d6-315f-4cc1-8333-b58780863b9b')
-					}
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-						stage ('Install azure-cli') {
-							steps {
-								installAzureCli()
-							}
-						}
-						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 'hirsute-small' } }
-					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')
-				}
-			}
-		}
-		fixed {
-			script {
-				if (env.BRANCH_NAME == 'main') {
-					slackSend (color: '#00ff00', message: '"main" branch build is now fixed')
-				}
-			}
-		}
-	}
-}
-
-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)
-
-		// 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() {
-	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=amd64] https://packages.microsoft.com/repos/azure-cli/ hirsute main\" | sudo tee /etc/apt/sources.list.d/azure-cli.list"
-	sh "sudo apt update"
-	sh "sudo apt install -y azure-cli"
-}

LICENSES/CC-BY-4.0.txt

@@ -0,0 +1,400 @@
+All documentations (e.g. files with extension `.md`) in this repository is
+covered by the following license:
+
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
+
+

MAINTAINERS.md

@@ -2,6 +2,7 @@
 
 - Sebastien Boeuf - @sboeuf
 - Robert Bradford - @rbradford
+- Bo Chen - @likebreath
 - Samuel Ortiz - @sameo
 - Wei Liu - @liuw
 - Michael Zhao - @michael2012z

README.md

@@ -4,35 +4,43 @@
     - [Architectures](#architectures)
     - [Guest OS](#guest-os)
 - [2. Getting Started](#2-getting-started)
-  - [Preparation](#preparation)
-  - [Install prerequisites](#install-prerequisites)
-  - [Clone and build](#clone-and-build)
-    - [Containerized builds and tests](#containerized-builds-and-tests)
-  - [Run](#run)
-    - [Cloud image](#cloud-image)
-    - [Custom kernel and disk image](#custom-kernel-and-disk-image)
-      - [Building your kernel](#building-your-kernel)
+  - [Host OS](#host-os)
+  - [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)
-- [4. `rust-vmm` project dependency](#4-rust-vmm-project-dependency)
-  - [Firecracker and crosvm](#firecracker-and-crosvm)
+  - [Roadmap](#roadmap)
+- [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)
-  - [Join us](#join-us)
+  - [Slack](#slack)
+  - [Mailing list](#mailing-list)
   - [Security issues](#security-issues)
 
 # 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) and the MSHV hypervisors .
+Cloud Hypervisor is an open source Virtual Machine Monitor (VMM) that runs on
+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 64-bit CPUs.
+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.
+Cloud Hypervisor is implemented in [Rust](https://www.rust-lang.org/) and is
+based on the [Rust VMM](https://github.com/rust-vmm) crates.
 
 ## Objectives
 
@@ -51,7 +59,13 @@ Cloud Hypervisor is implemented in [Rust](https://www.rust-lang.org/) and is bas
 
 ### Architectures
 
-Cloud Hypervisor supports the `x86-64` and `AArch64` architectures. There are some small differences in functionality between the two architectures (see [#1125](https://github.com/cloud-hypervisor/cloud-hypervisor/issues/1125)).
+Cloud Hypervisor supports the `x86-64`, `AArch64` and `riscv64`
+architectures, with functionality varying across these platforms. The
+functionality differences between `x86-64` and `AArch64` are documented
+in [#1125](https://github.com/cloud-hypervisor/cloud-hypervisor/issues/1125).
+The `riscv64` architecture support is experimental and offers limited
+functionality. For more details and instructions, please refer to [riscv
+documentation](docs/riscv.md).
 
 ### Guest OS
 
@@ -59,181 +73,196 @@ 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.
 
-## Preparation
+## Prerequisites for AArch64
 
-We create a folder to build and run `cloud-hypervisor` at `$HOME/cloud-hypervisor`
+- AArch64 servers (recommended) or development boards equipped with the GICv3
+  interrupt controller.
+
+## Host OS
+
+For required KVM functionality and adequate performance the recommended host
+kernel version is 5.13. The majority of the CI currently tests with kernel
+version 5.15.
+
+## Use Pre-built Binaries
+
+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.
+
+## Packages
+
+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.
+
+## Building from Source
+
+Please see the [instructions for building from source](docs/building.md) if you
+do not wish to use the pre-built binaries.
+
+## Booting Linux
+
+Cloud Hypervisor supports direct kernel boot (the x86-64 kernel requires the kernel
+built with PVH support or a bzImage) 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`.)
+
+Binary builds of the firmware files are available for the latest release of
+[Rust Hypervisor
+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
-$ 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 git
-$ sudo apt install git
-# Install rust tool chain
-$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-# Install build-essential
-$ sudo apt install build-essential
-# 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.
-
-## Run
-
-You can run a guest VM by either using an existing cloud image or booting into your own kernel and disk image.
-
-### Cloud image
-
-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.
-
-We need to get the latest `rust-hypervisor-firmware` release and also a working cloud image. Here we will use a Ubuntu image:
-
-```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.3.2/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. Script also assigns
+default IP address using `test_data/cloud-init/ubuntu/local/network-config` details
+with `--net "mac=12:34:56:78:90:ab,tap="` option. Then the matching mac address
+interface will be enabled as per `network-config` details.
+
 ```shell
-$ pushd $CLOUDH
-$ sudo setcap cap_net_admin+ep ./cloud-hypervisor/target/release/cloud-hypervisor
-$ ./cloud-hypervisor/target/release/cloud-hypervisor \
-	--kernel ./hypervisor-fw \
-	--disk path=focal-server-cloudimg-amd64.raw \
+$ sudo setcap cap_net_admin+ep ./cloud-hypervisor
+$ ./create-cloud-init.sh
+$ ./cloud-hypervisor \
+	--firmware ./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="
-$ 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
+## Booting: `--firmware` vs `--kernel`
 
-Cloud Hypervisor also supports direct kernel boot into a `vmlinux` ELF kernel. In order to support virtio-iommu 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.
+The following scenarios are supported by Cloud Hypervisor to bootstrap a VM, i.e.,
+to load a payload/bootitem(s):
+
+- Provide firmware
+- Provide kernel \[+ cmdline\]\ [+ initrd\]
+
+Please note that our Cloud Hypervisor firmware (`hypervisor-fw`) has a Xen PVH
+boot entry, therefore it can also be booted via the `--kernel` parameter, as 
+seen in some examples.
+
+### Custom Kernel and Disk Image
+
+#### Building your Kernel
+
+Cloud Hypervisor also supports direct kernel boot. For x86-64, a `vmlinux` ELF kernel (compiled with PVH support) or a regular bzImage are supported. 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
+$ git clone --depth 1 https://github.com/cloud-hypervisor/linux.git -b ch-6.12.8 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
+$ make ch_defconfig
+# 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 `linux-cloud-hypervisor/arch/x86/boot/compressed/vmlinux.bin`.
+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 \
@@ -244,102 +273,130 @@ $ ./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 releases notice. Where possible warnings
-  will be given about the use of deprecated functionality and the deprecations
-  will be documented in the release notes.
+  breaking way without a minimum of 2 major releases notice. Where possible
+  warnings will be given about the use of deprecated functionality and the
+  deprecations will be documented in the release notes.
+
 * Point releases will be made between individual releases where there are
-  substantial bug fixes or security issues that need to be fixed.
+  substantial bug fixes or security issues that need to be fixed. These point
+  releases will only include bug fixes.
 
 Currently the following items are **not** guaranteed across updates:
 
 * Snapshot/restore is not supported across different versions
 * Live migration is not supported across different versions
 * The following features are considered experimental and may change
-  substantially between releases: TDX, SGX.
+  substantially between releases: TDX, vfio-user, vDPA.
 
+Further details can be found in the [release documentation](docs/releases.md).
 
-As of 2021-04-29, the following cloud images are supported:
+As of 2023-01-03, the following cloud images are supported:
 
-- [Ubuntu Bionic](https://cloud-images.ubuntu.com/bionic/current/) (cloudimg)
-- [Ubuntu Focal](https://cloud-images.ubuntu.com/focal/current/) (cloudimg)
-- [Ubuntu Groovy](https://cloud-images.ubuntu.com/groovy/current/) (cloudimg)
-- [Ubuntu Hirsute](https://cloud-images.ubuntu.com/hirsute/current/) (cloudimg)
+- [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)
+- [Ubuntu Noble](https://cloud-images.ubuntu.com/noble/current/) (noble-server-cloudimg-{amd64,arm64}.img)
+- [Fedora 36](https://archives.fedoraproject.org/pub/archive/fedora/linux/releases/36/Cloud/) ([Fedora-Cloud-Base-36-1.5.x86_64.raw.xz](https://archives.fedoraproject.org/pub/archive/fedora/linux/releases/36/Cloud/x86_64/images/) / [Fedora-Cloud-Base-36-1.5.aarch64.raw.xz](https://archives.fedoraproject.org/pub/archive/fedora/linux/releases/36/Cloud/aarch64/images/))
 
-Direct kernel boot to userspace should work with a rootfs from most distributions.
+Direct kernel boot to userspace should work with a rootfs from most
+distributions although you may need to enable exotic filesystem types in the
+reference kernel configuration (e.g. XFS or btrfs.)
 
 ## Hot Plug
 
-Cloud Hypervisor supports hotplug of CPUs, passthrough devices (VFIO), `virtio-{net,block,pmem,fs,vsock}` and memory resizing. This [document](docs/hotplug.md) details how to add devices to
-a running VM.
+Cloud Hypervisor supports hotplug of CPUs, passthrough devices (VFIO),
+`virtio-{net,block,pmem,fs,vsock}` and memory resizing. This
+[document](docs/hotplug.md) details how to add devices to a running VM.
 
 ## Device Model
 
-Details of the device model can be found in this [documentation](docs/device_model.md).
+Details of the device model can be found in this
+[documentation](docs/device_model.md).
 
-## TODO
+## Roadmap
 
-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.
+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 [Rust](https://www.rust-lang.org/) programming language.
-The language's strong focus on memory and thread safety makes it an ideal candidate for implementing VMMs.
+In order to satisfy the design goal of having a high-performance,
+security-focused hypervisor the decision was made to use the
+[Rust](https://www.rust-lang.org/) programming language. The language's strong
+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 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/).
+Instead of implementing the VMM components from scratch, Cloud Hypervisor is
+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.
+## Differences with Firecracker and crosvm
 
-## Firecracker and crosvm
+A large part of the Cloud Hypervisor code is based on either the Firecracker or
+the crosvm project's implementations. Both of these are VMMs written in Rust
+with a focus on safety and security, like Cloud Hypervisor.
 
-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 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.
 
-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.
-
-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
 
-The Cloud Hypervisor project follows the governance, and community guidelines described in
-the [Community](https://github.com/cloud-hypervisor/community) repository.
+The Cloud Hypervisor project follows the governance, and community guidelines
+described in the [Community](https://github.com/cloud-hypervisor/community)
+repository.
 
 ## Contribute
 
-We are working on 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.
+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 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.
+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.
 
-## Join us
+## Slack
 
-Get an [invite to our Slack channel](https://join.slack.com/t/cloud-hypervisor/shared_invite/enQtNjY3MTE3MDkwNDQ4LWQ1MTA1ZDVmODkwMWQ1MTRhYzk4ZGNlN2UwNTI3ZmFlODU0OTcwOWZjMTkwZDExYWE3YjFmNzgzY2FmNDAyMjI)
-and [join us on Slack](https://cloud-hypervisor.slack.com/).
+Get an [invite to our Slack channel](https://join.slack.com/t/cloud-hypervisor/shared_invite/enQtNjY3MTE3MDkwNDQ4LWQ1MTA1ZDVmODkwMWQ1MTRhYzk4ZGNlN2UwNTI3ZmFlODU0OTcwOWZjMTkwZDExYWE3YjFmNzgzY2FmNDAyMjI),
+ [join us on Slack](https://cloud-hypervisor.slack.com/), and [participate in our community activities](https://cloud-hypervisor.slack.com/archives/C04R5DUQVBN).
+
+## Mailing list
+
+Please report bugs using the [GitHub issue
+tracker](https://github.com/cloud-hypervisor/cloud-hypervisor/issues) but for
+broader community discussions you may use our [mailing
+list](https://lists.cloudhypervisor.org/g/dev/).
 
 ## Security issues
 
-Please use the GitHub security advisories feature for reporting issues: https://github.com/cloud-hypervisor/cloud-hypervisor/security/advisories/new
+Please contact the maintainers listed in the MAINTAINERS.md file with security issues.

acpi_tables/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "acpi_tables"
-version = "0.1.0"
-authors = ["The Cloud Hypervisor Authors"]
-edition = "2018"
-
-[dependencies]
-vm-memory = "0.7.0"

acpi_tables/src/lib.rs

@@ -1,12 +0,0 @@
-// Copyright © 2019 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-pub mod aml;
-pub mod rsdp;
-pub mod sdt;
-
-fn generate_checksum(data: &[u8]) -> u8 {
-    (255 - data.iter().fold(0u8, |acc, x| acc.wrapping_add(*x))).wrapping_add(1)
-}

acpi_tables/src/rsdp.rs

@@ -1,68 +0,0 @@
-// Copyright © 2019 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-use vm_memory::ByteValued;
-
-#[repr(packed)]
-#[derive(Clone, Copy, Default)]
-pub struct Rsdp {
-    pub signature: [u8; 8],
-    pub checksum: u8,
-    pub oem_id: [u8; 6],
-    pub revision: u8,
-    _rsdt_addr: u32,
-    pub length: u32,
-    pub xsdt_addr: u64,
-    pub extended_checksum: u8,
-    _reserved: [u8; 3],
-}
-
-// SAFETY: Rsdp only contains a series of integers
-unsafe impl ByteValued for Rsdp {}
-
-impl Rsdp {
-    pub fn new(oem_id: [u8; 6], xsdt_addr: u64) -> Self {
-        let mut rsdp = Rsdp {
-            signature: *b"RSD PTR ",
-            checksum: 0,
-            oem_id,
-            revision: 2,
-            _rsdt_addr: 0,
-            length: std::mem::size_of::<Rsdp>() as u32,
-            xsdt_addr,
-            extended_checksum: 0,
-            _reserved: [0; 3],
-        };
-
-        rsdp.checksum = super::generate_checksum(&rsdp.as_slice()[0..19]);
-        rsdp.extended_checksum = super::generate_checksum(rsdp.as_slice());
-        rsdp
-    }
-
-    pub fn len() -> usize {
-        std::mem::size_of::<Rsdp>()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Rsdp;
-    use vm_memory::bytes::ByteValued;
-
-    #[test]
-    fn test_rsdp() {
-        let rsdp = Rsdp::new(*b"CHYPER", 0xdead_beef);
-        let sum = rsdp
-            .as_slice()
-            .iter()
-            .fold(0u8, |acc, x| acc.wrapping_add(*x));
-        assert_eq!(sum, 0);
-        let sum: u8 = rsdp
-            .as_slice()
-            .iter()
-            .fold(0u8, |acc, x| acc.wrapping_add(*x));
-        assert_eq!(sum, 0);
-    }
-}

acpi_tables/src/sdt.rs

@@ -1,146 +0,0 @@
-// Copyright © 2019 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-#[repr(packed)]
-pub struct GenericAddress {
-    pub address_space_id: u8,
-    pub register_bit_width: u8,
-    pub register_bit_offset: u8,
-    pub access_size: u8,
-    pub address: u64,
-}
-
-impl GenericAddress {
-    pub fn io_port_address<T>(address: u16) -> Self {
-        GenericAddress {
-            address_space_id: 1,
-            register_bit_width: 8 * std::mem::size_of::<T>() as u8,
-            register_bit_offset: 0,
-            access_size: std::mem::size_of::<T>() as u8,
-            address: u64::from(address),
-        }
-    }
-    pub fn mmio_address<T>(address: u64) -> Self {
-        GenericAddress {
-            address_space_id: 0,
-            register_bit_width: 8 * std::mem::size_of::<T>() as u8,
-            register_bit_offset: 0,
-            access_size: std::mem::size_of::<T>() as u8,
-            address,
-        }
-    }
-}
-
-pub struct Sdt {
-    data: Vec<u8>,
-}
-
-#[allow(clippy::len_without_is_empty)]
-impl Sdt {
-    pub fn new(
-        signature: [u8; 4],
-        length: u32,
-        revision: u8,
-        oem_id: [u8; 6],
-        oem_table: [u8; 8],
-        oem_revision: u32,
-    ) -> Self {
-        assert!(length >= 36);
-
-        let mut data = Vec::with_capacity(length as usize);
-        data.extend_from_slice(&signature);
-        data.extend_from_slice(&length.to_le_bytes());
-        data.push(revision);
-        data.push(0); // checksum
-        data.extend_from_slice(&oem_id);
-        data.extend_from_slice(&oem_table);
-        data.extend_from_slice(&oem_revision.to_le_bytes());
-        data.extend_from_slice(b"CLDH");
-        data.extend_from_slice(&0u32.to_le_bytes());
-        assert_eq!(data.len(), 36);
-
-        data.resize(length as usize, 0);
-        let mut sdt = Sdt { data };
-
-        sdt.update_checksum();
-        sdt
-    }
-
-    pub fn update_checksum(&mut self) {
-        self.data[9] = 0;
-        let checksum = super::generate_checksum(self.data.as_slice());
-        self.data[9] = checksum
-    }
-
-    pub fn as_slice(&self) -> &[u8] {
-        self.data.as_slice()
-    }
-
-    pub fn append<T>(&mut self, value: T) {
-        let orig_length = self.data.len();
-        let new_length = orig_length + std::mem::size_of::<T>();
-        self.data.resize(new_length, 0);
-        self.write_u32(4, new_length as u32);
-        self.write(orig_length, value);
-    }
-
-    pub fn append_slice(&mut self, data: &[u8]) {
-        let orig_length = self.data.len();
-        let new_length = orig_length + data.len();
-        self.write_u32(4, new_length as u32);
-        self.data.extend_from_slice(data);
-        self.update_checksum();
-    }
-
-    /// 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());
-        unsafe {
-            *(((self.data.as_mut_ptr() as usize) + offset) as *mut T) = value;
-        }
-        self.update_checksum();
-    }
-
-    pub fn write_u8(&mut self, offset: usize, val: u8) {
-        self.write(offset, val);
-    }
-
-    pub fn write_u16(&mut self, offset: usize, val: u16) {
-        self.write(offset, val);
-    }
-
-    pub fn write_u32(&mut self, offset: usize, val: u32) {
-        self.write(offset, val);
-    }
-
-    pub fn write_u64(&mut self, offset: usize, val: u64) {
-        self.write(offset, val);
-    }
-
-    pub fn len(&self) -> usize {
-        self.data.len()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Sdt;
-
-    #[test]
-    fn test_sdt() {
-        let mut sdt = Sdt::new(*b"TEST", 40, 1, *b"CLOUDH", *b"TESTTEST", 1);
-        let sum: u8 = sdt
-            .as_slice()
-            .iter()
-            .fold(0u8, |acc, x| acc.wrapping_add(*x));
-        assert_eq!(sum, 0);
-        sdt.write_u32(36, 0x12345678);
-        let sum: u8 = sdt
-            .as_slice()
-            .iter()
-            .fold(0u8, |acc, x| acc.wrapping_add(*x));
-        assert_eq!(sum, 0);
-    }
-}

api_client/Cargo.toml

@@ -1,8 +1,9 @@
 [package]
+authors = ["The Cloud Hypervisor Authors"]
+edition.workspace = true
 name = "api_client"
 version = "0.1.0"
-authors = ["The Cloud Hypervisor Authors"]
-edition = "2018"
 
 [dependencies]
-vmm-sys-util = "0.9.0"
+thiserror = { workspace = true }
+vmm-sys-util = { workspace = true }

api_client/src/lib.rs

@@ -3,39 +3,32 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-use std::fmt;
 use std::io::{Read, Write};
 use std::os::unix::io::RawFd;
+
+use thiserror::Error;
 use vmm_sys_util::sock_ctrl_msg::ScmSocket;
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum Error {
-    Socket(std::io::Error),
-    SocketSendFds(vmm_sys_util::errno::Error),
-    StatusCodeParsing(std::num::ParseIntError),
+    #[error("Error writing to or reading from HTTP socket")]
+    Socket(#[source] std::io::Error),
+    #[error("Error sending file descriptors")]
+    SocketSendFds(#[source] vmm_sys_util::errno::Error),
+    #[error("Error parsing HTTP status code")]
+    StatusCodeParsing(#[source] std::num::ParseIntError),
+    #[error("HTTP output is missing protocol statement")]
     MissingProtocol,
-    ContentLengthParsing(std::num::ParseIntError),
-    ServerResponse(StatusCode, Option<String>),
-}
-
-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),
-            MissingProtocol => write!(f, "HTTP output is missing protocol statement"),
-            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)
-                } else {
-                    write!(f, "Server responded with an error: {:?}", s)
-                }
-            }
-        }
-    }
+    #[error("Error parsing HTTP Content-Length field")]
+    ContentLengthParsing(#[source] std::num::ParseIntError),
+    #[error("Server responded with error {0:?}: {1:?}")]
+    ServerResponse(
+        StatusCode,
+        // TODO: Move `api` module from `vmm` to dedicated crate and use a common type definition
+        Option<
+            String, /* Untyped: Currently Vec<String> of error messages from top to root cause */
+        >,
+    ),
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -45,6 +38,7 @@ pub enum StatusCode {
     NoContent,
     BadRequest,
     NotFound,
+    TooManyRequests,
     InternalServerError,
     NotImplemented,
     Unknown,
@@ -58,6 +52,7 @@ impl StatusCode {
             204 => StatusCode::NoContent,
             400 => StatusCode::BadRequest,
             404 => StatusCode::NotFound,
+            429 => StatusCode::TooManyRequests,
             500 => StatusCode::InternalServerError,
             501 => StatusCode::NotImplemented,
             _ => StatusCode::Unknown,
@@ -79,7 +74,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()])
 }
@@ -101,6 +96,10 @@ fn parse_http_response(socket: &mut dyn Read) -> Result<Option<String>, Error> {
     loop {
         let mut bytes = vec![0; 256];
         let count = socket.read(&mut bytes).map_err(Error::Socket)?;
+        // If the return value is 0, the peer has performed an orderly shutdown.
+        if count == 0 {
+            break;
+        }
         res.push_str(std::str::from_utf8(&bytes[0..count]).unwrap());
 
         // End of headers
@@ -119,15 +118,14 @@ fn parse_http_response(socket: &mut dyn Read) -> Result<Option<String>, Error> {
             }
         }
 
-        if let Some(body_offset) = body_offset {
-            if let Some(content_length) = content_length {
-                if res.len() >= content_length + body_offset {
-                    break;
-                }
-            }
+        if let Some(body_offset) = body_offset
+            && let Some(content_length) = content_length
+            && res.len() >= content_length + body_offset
+        {
+            break;
         }
     }
-    let body_string = content_length.and(Some(String::from(&res[body_offset.unwrap()..])));
+    let body_string = content_length.and(body_offset.map(|o| String::from(&res[o..])));
     let status_code = get_status_code(&res)?;
 
     if status_code.is_server_error() {
@@ -137,18 +135,19 @@ fn parse_http_response(socket: &mut dyn Read) -> Result<Option<String>, Error> {
     }
 }
 
-pub fn simple_api_command_with_fds<T: Read + Write + ScmSocket>(
+/// Make an API request using the fully qualified command name.
+/// For example, full_command could be "vm.create" or "vmm.ping".
+pub fn simple_api_full_command_with_fds_and_response<T: Read + Write + ScmSocket>(
     socket: &mut T,
     method: &str,
-    c: &str,
+    full_command: &str,
     request_body: Option<&str>,
     request_fds: Vec<RawFd>,
-) -> Result<(), Error> {
+) -> Result<Option<String>, Error> {
     socket
         .send_with_fds(
             &[format!(
-                "{} /api/v1/vm.{} HTTP/1.1\r\nHost: localhost\r\nAccept: */*\r\n",
-                method, c
+                "{method} /api/v1/{full_command} HTTP/1.1\r\nHost: localhost\r\nAccept: */*\r\n"
             )
             .as_bytes()],
             &request_fds,
@@ -171,12 +170,69 @@ pub fn simple_api_command_with_fds<T: Read + Write + ScmSocket>(
 
     socket.flush().map_err(Error::Socket)?;
 
-    if let Some(body) = parse_http_response(socket)? {
-        println!("{}", body);
+    parse_http_response(socket)
+}
+
+pub fn simple_api_full_command_with_fds<T: Read + Write + ScmSocket>(
+    socket: &mut T,
+    method: &str,
+    full_command: &str,
+    request_body: Option<&str>,
+    request_fds: Vec<RawFd>,
+) -> Result<(), Error> {
+    let response = simple_api_full_command_with_fds_and_response(
+        socket,
+        method,
+        full_command,
+        request_body,
+        request_fds,
+    )?;
+
+    if response.is_some() {
+        println!("{}", response.unwrap());
     }
+
     Ok(())
 }
 
+pub fn simple_api_full_command<T: Read + Write + ScmSocket>(
+    socket: &mut T,
+    method: &str,
+    full_command: &str,
+    request_body: Option<&str>,
+) -> Result<(), Error> {
+    simple_api_full_command_with_fds(socket, method, full_command, request_body, Vec::new())
+}
+
+pub fn simple_api_full_command_and_response<T: Read + Write + ScmSocket>(
+    socket: &mut T,
+    method: &str,
+    full_command: &str,
+    request_body: Option<&str>,
+) -> Result<Option<String>, Error> {
+    simple_api_full_command_with_fds_and_response(
+        socket,
+        method,
+        full_command,
+        request_body,
+        Vec::new(),
+    )
+}
+
+pub fn simple_api_command_with_fds<T: Read + Write + ScmSocket>(
+    socket: &mut T,
+    method: &str,
+    c: &str,
+    request_body: Option<&str>,
+    request_fds: Vec<RawFd>,
+) -> Result<(), Error> {
+    // Create the full VM command. For VMM commands, use
+    // simple_api_full_command().
+    let full_command = format!("vm.{c}");
+
+    simple_api_full_command_with_fds(socket, method, &full_command, request_body, request_fds)
+}
+
 pub fn simple_api_command<T: Read + Write + ScmSocket>(
     socket: &mut T,
     method: &str,

arch/Cargo.toml

@@ -1,31 +1,29 @@
 [package]
+authors = ["The Chromium OS Authors"]
+edition.workspace = true
 name = "arch"
 version = "0.1.0"
-authors = ["The Chromium OS Authors"]
-edition = "2018"
 
 [features]
 default = []
-acpi = ["acpi_tables"]
+fw_cfg = []
+kvm = ["hypervisor/kvm"]
+sev_snp = []
 tdx = []
 
 [dependencies]
-acpi_tables = { path = "../acpi_tables", optional = true }
-anyhow = "1.0.52"
-byteorder = "1.4.3"
+anyhow = { workspace = true }
+byteorder = { workspace = true }
 hypervisor = { path = "../hypervisor" }
-libc = "0.2.112"
-linux-loader = { version = "0.4.0", features = ["elf", "bzimage", "pe"] }
-log = "0.4.14"
-serde = { version = "1.0.133", features = ["rc"] }
-serde_derive = "1.0.133"
-thiserror = "1.0.30"
-versionize = "0.1.6"
-versionize_derive = "0.1.4"
-vm-memory = { version = "0.7.0", features = ["backend-mmap", "backend-bitmap"] }
-vm-migration = { path = "../vm-migration" }
-vmm-sys-util = { version = "0.9.0", features = ["with-serde"] }
+libc = { workspace = true }
+linux-loader = { workspace = true, features = ["bzimage", "elf", "pe"] }
+log = { workspace = true }
+serde = { workspace = true, features = ["derive", "rc"] }
+thiserror = { workspace = true }
+uuid = { workspace = true }
+vm-memory = { workspace = true, features = ["backend-bitmap", "backend-mmap"] }
+vmm-sys-util = { workspace = true, features = ["with-serde"] }
 
-[target.'cfg(target_arch = "aarch64")'.dependencies]
-fdt_parser = { version = "0.1.3", package = 'fdt'}
-vm-fdt = { git = "https://github.com/rust-vmm/vm-fdt", branch = "main" }
+[target.'cfg(any(target_arch = "aarch64", target_arch = "riscv64"))'.dependencies]
+fdt_parser = { version = "0.1.5", package = "fdt" }
+vm-fdt = { workspace = true }

arch/src/aarch64/fdt.rs

@@ -6,26 +6,29 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the THIRD-PARTY file.
 
-use crate::{NumaNodes, PciSpaceInfo};
-use byteorder::{BigEndian, ByteOrder};
-use std::cmp;
 use std::collections::HashMap;
 use std::ffi::CStr;
 use std::fmt::Debug;
-use std::result;
-use std::str;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+use std::{cmp, fs, result, str};
 
-use super::super::DeviceType;
-use super::super::GuestMemoryMmap;
-use super::super::InitramfsConfig;
-use super::get_fdt_addr;
-use super::gic::GicDevice;
-use super::layout::{
-    IRQ_BASE, MEM_32BIT_DEVICES_SIZE, MEM_32BIT_DEVICES_START, MEM_PCI_IO_SIZE, MEM_PCI_IO_START,
-    PCI_HIGH_BASE, PCI_MMIO_CONFIG_SIZE_PER_SEGMENT,
+use byteorder::{BigEndian, ByteOrder};
+use hypervisor::arch::aarch64::gic::Vgic;
+use hypervisor::arch::aarch64::regs::{
+    AARCH64_ARCH_TIMER_HYP_IRQ, AARCH64_ARCH_TIMER_PHYS_NONSECURE_IRQ,
+    AARCH64_ARCH_TIMER_PHYS_SECURE_IRQ, AARCH64_ARCH_TIMER_VIRT_IRQ, AARCH64_PMU_IRQ,
 };
+use thiserror::Error;
 use vm_fdt::{FdtWriter, FdtWriterResult};
-use vm_memory::{Address, Bytes, GuestAddress, GuestMemory, GuestMemoryError, GuestMemoryRegion};
+use vm_memory::{Address, Bytes, GuestMemory, GuestMemoryError, GuestMemoryRegion};
+
+use super::super::{DeviceType, GuestMemoryMmap, InitramfsConfig};
+use super::layout::{
+    GIC_V2M_COMPATIBLE, IRQ_BASE, MEM_32BIT_DEVICES_SIZE, MEM_32BIT_DEVICES_START, MEM_PCI_IO_SIZE,
+    MEM_PCI_IO_START, PCI_HIGH_BASE, PCI_MMIO_CONFIG_SIZE_PER_SEGMENT, SPI_BASE, SPI_NUM,
+};
+use crate::{NumaNodes, PciSpaceInfo};
 
 // This is a value for uniquely identifying the FDT node declaring the interrupt controller.
 const GIC_PHANDLE: u32 = 1;
@@ -40,8 +43,12 @@ const VIRTIO_IOMMU_PHANDLE: u32 = 5;
 // NOTE: Keep FIRST_VCPU_PHANDLE the last PHANDLE defined.
 // This is a value for uniquely identifying the FDT node containing the first vCPU.
 // The last number of vCPU phandle depends on the number of vCPUs.
-const FIRST_VCPU_PHANDLE: u32 = 6;
+const FIRST_VCPU_PHANDLE: u32 = 8;
 
+// This is a value for uniquely identifying the FDT node containing the L2 cache info
+const L2_CACHE_PHANDLE: u32 = 6;
+// This is a value for uniquely identifying the FDT node containing the L3 cache info
+const L3_CACHE_PHANDLE: u32 = 7;
 // Read the documentation specified when appending the root node to the FDT.
 const ADDRESS_CELLS: u32 = 0x2;
 const SIZE_CELLS: u32 = 0x2;
@@ -71,33 +78,149 @@ pub trait DeviceInfoForFdt {
 }
 
 /// Errors thrown while configuring the Flattened Device Tree for aarch64.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum Error {
     /// Failure in writing FDT in memory.
-    WriteFdtToMemory(GuestMemoryError),
+    #[error("Failure in writing FDT in memory")]
+    WriteFdtToMemory(#[source] GuestMemoryError),
 }
 type Result<T> = result::Result<T, Error>;
 
+pub enum CacheLevel {
+    /// L1 data cache
+    L1D = 0,
+    /// L1 instruction cache
+    L1I = 1,
+    /// L2 cache
+    L2 = 2,
+    /// L3 cache
+    L3 = 3,
+}
+
+/// NOTE: cache size file directory example,
+/// "/sys/devices/system/cpu/cpu0/cache/index0/size".
+pub fn get_cache_size(cache_level: CacheLevel) -> u32 {
+    let mut file_directory: String = "/sys/devices/system/cpu/cpu0/cache".to_string();
+    match cache_level {
+        CacheLevel::L1D => file_directory += "/index0/size",
+        CacheLevel::L1I => file_directory += "/index1/size",
+        CacheLevel::L2 => file_directory += "/index2/size",
+        CacheLevel::L3 => file_directory += "/index3/size",
+    }
+
+    let file_path = Path::new(&file_directory);
+    if !file_path.exists() {
+        0
+    } else {
+        let src = fs::read_to_string(file_directory).expect("File not exists or file corrupted.");
+        // The content of the file is as simple as a size, like: "32K"
+        let src = src.trim();
+        let src_digits: u32 = src[0..src.len() - 1].parse().unwrap();
+        let src_unit = &src[src.len() - 1..];
+
+        src_digits
+            * match src_unit {
+                "K" => 1024,
+                "M" => 1024u32.pow(2),
+                "G" => 1024u32.pow(3),
+                _ => 1,
+            }
+    }
+}
+
+/// NOTE: coherency_line_size file directory example,
+/// "/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size".
+pub fn get_cache_coherency_line_size(cache_level: CacheLevel) -> u32 {
+    let mut file_directory: String = "/sys/devices/system/cpu/cpu0/cache".to_string();
+    match cache_level {
+        CacheLevel::L1D => file_directory += "/index0/coherency_line_size",
+        CacheLevel::L1I => file_directory += "/index1/coherency_line_size",
+        CacheLevel::L2 => file_directory += "/index2/coherency_line_size",
+        CacheLevel::L3 => file_directory += "/index3/coherency_line_size",
+    }
+
+    let file_path = Path::new(&file_directory);
+    if !file_path.exists() {
+        0
+    } else {
+        let src = fs::read_to_string(file_directory).expect("File not exists or file corrupted.");
+        src.trim().parse::<u32>().unwrap()
+    }
+}
+
+/// NOTE: number_of_sets file directory example,
+/// "/sys/devices/system/cpu/cpu0/cache/index0/number_of_sets".
+pub fn get_cache_number_of_sets(cache_level: CacheLevel) -> u32 {
+    let mut file_directory: String = "/sys/devices/system/cpu/cpu0/cache".to_string();
+    match cache_level {
+        CacheLevel::L1D => file_directory += "/index0/number_of_sets",
+        CacheLevel::L1I => file_directory += "/index1/number_of_sets",
+        CacheLevel::L2 => file_directory += "/index2/number_of_sets",
+        CacheLevel::L3 => file_directory += "/index3/number_of_sets",
+    }
+
+    let file_path = Path::new(&file_directory);
+    if !file_path.exists() {
+        0
+    } else {
+        let src = fs::read_to_string(file_directory).expect("File not exists or file corrupted.");
+        src.trim().parse::<u32>().unwrap()
+    }
+}
+
+/// NOTE: shared_cpu_list file directory example,
+/// "/sys/devices/system/cpu/cpu0/cache/index0/shared_cpu_list".
+pub fn get_cache_shared(cache_level: CacheLevel) -> bool {
+    let mut file_directory: String = "/sys/devices/system/cpu/cpu0/cache".to_string();
+    let mut result = true;
+
+    match cache_level {
+        CacheLevel::L1D | CacheLevel::L1I => result = false,
+        CacheLevel::L2 => file_directory += "/index2/shared_cpu_list",
+        CacheLevel::L3 => file_directory += "/index3/shared_cpu_list",
+    }
+
+    if !result {
+        return false;
+    }
+
+    let file_path = Path::new(&file_directory);
+    if !file_path.exists() {
+        result = false;
+    } else {
+        let src = fs::read_to_string(file_directory).expect("File not exists or file corrupted.");
+        let src = src.trim();
+        if src.is_empty() {
+            result = false;
+        } else {
+            result = src.contains('-') || src.contains(',');
+        }
+    }
+
+    result
+}
+
 /// Creates the flattened device tree for this aarch64 VM.
 #[allow(clippy::too_many_arguments)]
 pub fn create_fdt<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
     guest_mem: &GuestMemoryMmap,
     cmdline: &str,
     vcpu_mpidr: Vec<u64>,
-    vcpu_topology: Option<(u8, u8, u8)>,
+    vcpu_topology: Option<(u16, u16, u16, u16)>,
     device_info: &HashMap<(DeviceType, String), T, S>,
-    gic_device: &dyn GicDevice,
+    gic_device: &Arc<Mutex<dyn Vgic>>,
     initrd: &Option<InitramfsConfig>,
     pci_space_info: &[PciSpaceInfo],
     numa_nodes: &NumaNodes,
     virtio_iommu_bdf: Option<u32>,
+    pmu_supported: bool,
 ) -> FdtWriterResult<Vec<u8>> {
     // Allocate stuff necessary for the holding the blob.
     let mut fdt = FdtWriter::new().unwrap();
 
     // For an explanation why these nodes were introduced in the blob take a look at
-    // https://github.com/torvalds/linux/blob/master/Documentation/devicetree/booting-without-of.txt#L845
-    // Look for "Required nodes and properties".
+    // the "Device Node Requirements" chapter of the Devicetree Specification.
+    // https://www.devicetree.org/specifications/
 
     // Header or the root node as per above mentioned documentation.
     let root_node = fdt.begin_node("")?;
@@ -114,6 +237,9 @@ pub fn create_fdt<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHash
     create_chosen_node(&mut fdt, cmdline, initrd)?;
     create_gic_node(&mut fdt, gic_device)?;
     create_timer_node(&mut fdt)?;
+    if pmu_supported {
+        create_pmu_node(&mut fdt)?;
+    }
     create_clock_node(&mut fdt)?;
     create_psci_node(&mut fdt)?;
     create_devices_node(&mut fdt, device_info)?;
@@ -132,9 +258,8 @@ pub fn create_fdt<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHash
 
 pub fn write_fdt_to_memory(fdt_final: Vec<u8>, guest_mem: &GuestMemoryMmap) -> Result<()> {
     // Write FDT to memory.
-    let fdt_address = GuestAddress(get_fdt_addr());
     guest_mem
-        .write_slice(fdt_final.as_slice(), fdt_address)
+        .write_slice(fdt_final.as_slice(), super::layout::FDT_START)
         .map_err(Error::WriteFdtToMemory)?;
     Ok(())
 }
@@ -143,7 +268,7 @@ pub fn write_fdt_to_memory(fdt_final: Vec<u8>, guest_mem: &GuestMemoryMmap) -> R
 fn create_cpu_nodes(
     fdt: &mut FdtWriter,
     vcpu_mpidr: &[u64],
-    vcpu_topology: Option<(u8, u8, u8)>,
+    vcpu_topology: Option<(u16, u16, u16, u16)>,
     numa_nodes: &NumaNodes,
 ) -> FdtWriterResult<()> {
     // See https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/arm/cpus.yaml.
@@ -152,12 +277,73 @@ fn create_cpu_nodes(
     fdt.property_u32("#size-cells", 0x0)?;
 
     let num_cpus = vcpu_mpidr.len();
-    let threads_per_core = vcpu_topology.unwrap_or_default().0 as u8;
-    let cores_per_package = vcpu_topology.unwrap_or_default().1 as u8;
-    let packages = vcpu_topology.unwrap_or_default().2 as u8;
+    let (threads_per_core, cores_per_die, dies_per_package, packages) =
+        vcpu_topology.unwrap_or((1, 1, 1, 1));
+    let cores_per_package = cores_per_die * dies_per_package;
+    let max_cpus: u32 =
+        threads_per_core as u32 * cores_per_die as u32 * dies_per_package as u32 * packages as u32;
+
+    // Add cache info.
+    // L1 Data Cache Info.
+    let mut l1_d_cache_size: u32 = 0;
+    let mut l1_d_cache_line_size: u32 = 0;
+    let mut l1_d_cache_sets: u32 = 0;
+
+    // L1 Instruction Cache Info.
+    let mut l1_i_cache_size: u32 = 0;
+    let mut l1_i_cache_line_size: u32 = 0;
+    let mut l1_i_cache_sets: u32 = 0;
+
+    // L2 Cache Info.
+    let mut l2_cache_size: u32 = 0;
+    let mut l2_cache_line_size: u32 = 0;
+    let mut l2_cache_sets: u32 = 0;
+
+    // L3 Cache Info.
+    let mut l3_cache_size: u32 = 0;
+    let mut l3_cache_line_size: u32 = 0;
+    let mut l3_cache_sets: u32 = 0;
+
+    // Cache Shared Info.
+    let mut l2_cache_shared: bool = false;
+    let mut l3_cache_shared: bool = false;
+
+    let cache_path = Path::new("/sys/devices/system/cpu/cpu0/cache");
+    let cache_exist: bool = cache_path.exists();
+    if !cache_exist {
+        warn!("cache sysfs system does not exist.");
+    } else {
+        // L1 Data Cache Info.
+        l1_d_cache_size = get_cache_size(CacheLevel::L1D);
+        l1_d_cache_line_size = get_cache_coherency_line_size(CacheLevel::L1D);
+        l1_d_cache_sets = get_cache_number_of_sets(CacheLevel::L1D);
+
+        // L1 Instruction Cache Info.
+        l1_i_cache_size = get_cache_size(CacheLevel::L1I);
+        l1_i_cache_line_size = get_cache_coherency_line_size(CacheLevel::L1I);
+        l1_i_cache_sets = get_cache_number_of_sets(CacheLevel::L1I);
+
+        // L2 Cache Info.
+        l2_cache_size = get_cache_size(CacheLevel::L2);
+        l2_cache_line_size = get_cache_coherency_line_size(CacheLevel::L2);
+        l2_cache_sets = get_cache_number_of_sets(CacheLevel::L2);
+
+        // L3 Cache Info.
+        l3_cache_size = get_cache_size(CacheLevel::L3);
+        l3_cache_line_size = get_cache_coherency_line_size(CacheLevel::L3);
+        l3_cache_sets = get_cache_number_of_sets(CacheLevel::L3);
+
+        // Cache Shared Info.
+        if l2_cache_size != 0 {
+            l2_cache_shared = get_cache_shared(CacheLevel::L2);
+        }
+        if l3_cache_size != 0 {
+            l3_cache_shared = get_cache_shared(CacheLevel::L3);
+        }
+    }
 
     for (cpu_id, mpidr) in vcpu_mpidr.iter().enumerate().take(num_cpus) {
-        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")?;
@@ -174,72 +360,126 @@ fn create_cpu_nodes(
         if numa_nodes.len() > 1 {
             for numa_node_idx in 0..numa_nodes.len() {
                 let numa_node = numa_nodes.get(&(numa_node_idx as u32));
-                if numa_node.unwrap().cpus.contains(&(cpu_id as u8)) {
+                if numa_node.unwrap().cpus.contains(&(cpu_id as u32)) {
                     fdt.property_u32("numa-node-id", numa_node_idx as u32)?;
                 }
             }
         }
 
+        if cache_exist && l1_d_cache_size != 0 && l1_i_cache_size != 0 {
+            // Add cache info.
+            fdt.property_u32("d-cache-size", l1_d_cache_size)?;
+            fdt.property_u32("d-cache-line-size", l1_d_cache_line_size)?;
+            fdt.property_u32("d-cache-sets", l1_d_cache_sets)?;
+
+            fdt.property_u32("i-cache-size", l1_i_cache_size)?;
+            fdt.property_u32("i-cache-line-size", l1_i_cache_line_size)?;
+            fdt.property_u32("i-cache-sets", l1_i_cache_sets)?;
+
+            if l2_cache_size != 0 && !l2_cache_shared {
+                fdt.property_u32(
+                    "next-level-cache",
+                    cpu_id as u32 + max_cpus + FIRST_VCPU_PHANDLE + L2_CACHE_PHANDLE,
+                )?;
+
+                let l2_cache_name = "l2-cache0";
+                let l2_cache_node = fdt.begin_node(l2_cache_name)?;
+                // PHANDLE is used to mark device node, and PHANDLE is unique. To avoid phandle
+                // conflicts with other device nodes, consider the previous CPU PHANDLE, so the
+                // CPU L2 cache PHANDLE must start from the largest CPU PHANDLE plus 1.
+                fdt.property_u32(
+                    "phandle",
+                    cpu_id as u32 + max_cpus + FIRST_VCPU_PHANDLE + L2_CACHE_PHANDLE,
+                )?;
+
+                fdt.property_string("compatible", "cache")?;
+                fdt.property_u32("cache-size", l2_cache_size)?;
+                fdt.property_u32("cache-line-size", l2_cache_line_size)?;
+                fdt.property_u32("cache-sets", l2_cache_sets)?;
+                fdt.property_u32("cache-level", 2)?;
+
+                if l3_cache_size != 0 && l3_cache_shared {
+                    let package_id: u32 = cpu_id as u32 / cores_per_package as u32;
+                    fdt.property_u32(
+                        "next-level-cache",
+                        package_id
+                            + num_cpus as u32
+                            + max_cpus
+                            + FIRST_VCPU_PHANDLE
+                            + L2_CACHE_PHANDLE
+                            + L3_CACHE_PHANDLE,
+                    )?;
+                }
+
+                fdt.end_node(l2_cache_node)?;
+            }
+        }
+
         fdt.end_node(cpu_node)?;
     }
 
-    // If there is a valid cpu topology config, create the cpu-map node.
-    if (threads_per_core > 0)
-        && (cores_per_package > 0)
-        && (packages > 0)
-        && (num_cpus as u8 == threads_per_core * cores_per_package * packages)
-    {
-        let cpu_map_node = fdt.begin_node("cpu-map")?;
-        // Create mappings between CPU index and cluster,core, and thread.
-        let mut cluster_core_thread_to_cpuidx = HashMap::new();
-        for cpu_idx in 0..num_cpus as u8 {
-            if threads_per_core > 1 {
-                cluster_core_thread_to_cpuidx.insert(
-                    (
-                        cpu_idx / (cores_per_package * threads_per_core),
-                        (cpu_idx / threads_per_core) % cores_per_package,
-                        cpu_idx % threads_per_core,
-                    ),
-                    cpu_idx,
-                );
-            } else {
-                cluster_core_thread_to_cpuidx.insert(
-                    (cpu_idx / cores_per_package, cpu_idx % cores_per_package, 0),
-                    cpu_idx,
-                );
-            }
+    if cache_exist && l3_cache_size != 0 && !l2_cache_shared && l3_cache_shared {
+        let mut i: u32 = 0;
+        while i < packages.into() {
+            let l3_cache_name = "l3-cache0";
+            let l3_cache_node = fdt.begin_node(l3_cache_name)?;
+            // ARM L3 cache is generally shared within the package (socket), so the
+            // L3 cache node pointed to by the CPU in the package has the same L3
+            // cache PHANDLE. The L3 cache phandle must start from the largest L2
+            // cache PHANDLE plus 1 to avoid duplication.
+            fdt.property_u32(
+                "phandle",
+                i + num_cpus as u32
+                    + max_cpus
+                    + FIRST_VCPU_PHANDLE
+                    + L2_CACHE_PHANDLE
+                    + L3_CACHE_PHANDLE,
+            )?;
+
+            fdt.property_string("compatible", "cache")?;
+            fdt.property_null("cache-unified")?;
+            fdt.property_u32("cache-size", l3_cache_size)?;
+            fdt.property_u32("cache-line-size", l3_cache_line_size)?;
+            fdt.property_u32("cache-sets", l3_cache_sets)?;
+            fdt.property_u32("cache-level", 3)?;
+            fdt.end_node(l3_cache_node)?;
+
+            i += 1;
         }
+    }
+
+    if let Some(topology) = vcpu_topology {
+        let (threads_per_core, cores_per_die, dies_per_package, packages) = topology;
+        let cores_per_package = cores_per_die * dies_per_package;
+        let cpu_map_node = fdt.begin_node("cpu-map")?;
 
         // 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_node = fdt.begin_node(&cluster_name)?;
+        for package_idx in 0..packages {
+            let package_name = format!("socket{package_idx:x}");
+            let package_node = fdt.begin_node(&package_name)?;
+
+            // Cluster is the container of cores, and it is mandatory in the CPU topology.
+            // Add a default "cluster0" in each socket/package.
+            let cluster_node = fdt.begin_node("cluster0")?;
 
             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)?;
 
-                if threads_per_core > 1 {
-                    for thread_idx in 0..threads_per_core {
-                        let thread_name = format!("thread{:x}", thread_idx);
-                        let thread_node = fdt.begin_node(&thread_name)?;
-                        let cpu_idx = cluster_core_thread_to_cpuidx
-                            .get(&(cluster_idx, core_idx, thread_idx))
-                            .unwrap();
-
-                        fdt.property_u32("cpu", *cpu_idx as u32 + FIRST_VCPU_PHANDLE)?;
-                        fdt.end_node(thread_node)?;
-                    }
-                } else {
-                    let cpu_idx = cluster_core_thread_to_cpuidx
-                        .get(&(cluster_idx, core_idx, 0))
-                        .unwrap();
-
-                    fdt.property_u32("cpu", *cpu_idx as u32 + FIRST_VCPU_PHANDLE)?;
+                for thread_idx in 0..threads_per_core {
+                    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 * package_idx
+                        + threads_per_core * core_idx
+                        + thread_idx;
+                    fdt.property_u32("cpu", cpu_idx as u32 + FIRST_VCPU_PHANDLE)?;
+                    fdt.end_node(thread_node)?;
                 }
+
                 fdt.end_node(core_node)?;
             }
             fdt.end_node(cluster_node)?;
+            fdt.end_node(package_node)?;
         }
         fdt.end_node(cpu_map_node)?;
     } else {
@@ -256,40 +496,116 @@ fn create_memory_node(
     guest_mem: &GuestMemoryMmap,
     numa_nodes: &NumaNodes,
 ) -> FdtWriterResult<()> {
+    // See https://github.com/torvalds/linux/blob/58ae0b51506802713aa0e9956d1853ba4c722c98/Documentation/devicetree/bindings/numa.txt
+    // for NUMA setting in memory node.
     if numa_nodes.len() > 1 {
         for numa_node_idx in 0..numa_nodes.len() {
             let numa_node = numa_nodes.get(&(numa_node_idx as u32));
+            let mut mem_reg_prop: Vec<u64> = Vec::new();
+            let mut node_memory_addr: u64 = 0;
             // Each memory zone of numa will have its own memory node, but
             // different numa nodes should not share same memory zones.
             for memory_region in numa_node.unwrap().memory_regions.iter() {
                 let memory_region_start_addr: u64 = memory_region.start_addr().raw_value();
                 let memory_region_size: u64 = memory_region.size() as u64;
-                let mem_reg_prop = [memory_region_start_addr, memory_region_size];
-                // With feature `acpi` enabled, RAM at 0-4M is for edk2 only
-                // and should be hidden to the guest.
-                #[cfg(feature = "acpi")]
-                if memory_region_start_addr == 0 {
-                    continue;
+                mem_reg_prop.push(memory_region_start_addr);
+                mem_reg_prop.push(memory_region_size);
+                // Set the node address the first non-zero region address
+                if node_memory_addr == 0 {
+                    node_memory_addr = memory_region_start_addr;
                 }
-
-                let memory_node_name = format!("memory@{:x}", memory_region_start_addr);
-                let memory_node = fdt.begin_node(&memory_node_name)?;
-                fdt.property_string("device_type", "memory")?;
-                fdt.property_array_u64("reg", &mem_reg_prop)?;
-                fdt.property_u32("numa-node-id", numa_node_idx as u32)?;
-                fdt.end_node(memory_node)?;
             }
+            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)?;
+            fdt.property_u32("numa-node-id", numa_node_idx as u32)?;
+            fdt.end_node(memory_node)?;
         }
     } else {
-        let mem_size = guest_mem.last_addr().raw_value() - super::layout::RAM_64BIT_START + 1;
-        // See https://github.com/torvalds/linux/blob/master/Documentation/devicetree/booting-without-of.txt#L960
-        // for an explanation of this.
-        let mem_reg_prop = [super::layout::RAM_64BIT_START as u64, mem_size as u64];
-        let memory_node = fdt.begin_node("memory")?;
+        // Note: memory regions from "GuestMemory" are sorted and non-zero sized.
+        let ram_regions = {
+            let mut ram_regions = Vec::new();
+            let mut current_start = guest_mem
+                .iter()
+                .next()
+                .map(GuestMemoryRegion::start_addr)
+                .expect("GuestMemory must have one memory region at least")
+                .raw_value();
+            let mut current_end = current_start;
 
-        fdt.property_string("device_type", "memory")?;
-        fdt.property_array_u64("reg", &mem_reg_prop)?;
-        fdt.end_node(memory_node)?;
+            for (start, size) in guest_mem
+                .iter()
+                .map(|m| (m.start_addr().raw_value(), m.len()))
+            {
+                if current_end == start {
+                    // This zone is continuous with the previous one.
+                    current_end += size;
+                } else {
+                    ram_regions.push((current_start, current_end));
+
+                    current_start = start;
+                    current_end = start + size;
+                }
+            }
+
+            ram_regions.push((current_start, current_end));
+
+            ram_regions
+        };
+
+        if ram_regions.len() > 2 {
+            panic!(
+                "There should be up to two non-continuous regions, divided by the
+                    gap at the end of 32bit address space."
+            );
+        }
+
+        // Create the memory node for memory region before the gap
+        {
+            let (first_region_start, first_region_end) = ram_regions
+                .first()
+                .expect("There should be at last one memory region");
+            let ram_start = super::layout::RAM_START.raw_value();
+            let mem_32bit_reserved_start = super::layout::MEM_32BIT_RESERVED_START.raw_value();
+
+            if !((first_region_start <= &ram_start)
+                && (first_region_end > &ram_start)
+                && (first_region_end <= &mem_32bit_reserved_start))
+            {
+                panic!(
+                    "Unexpected first memory region layout: (start: 0x{first_region_start:08x}, end: 0x{first_region_end:08x}).
+                    ram_start: 0x{ram_start:08x}, mem_32bit_reserved_start: 0x{mem_32bit_reserved_start:08x}"
+                );
+            }
+
+            let mem_size = first_region_end - ram_start;
+            let mem_reg_prop = [ram_start, mem_size];
+            let memory_node_name = format!("memory@{ram_start:x}");
+            let memory_node = fdt.begin_node(&memory_node_name)?;
+            fdt.property_string("device_type", "memory")?;
+            fdt.property_array_u64("reg", &mem_reg_prop)?;
+            fdt.end_node(memory_node)?;
+        }
+
+        // Create the memory map entry for memory region after the gap if any
+        if let Some((second_region_start, second_region_end)) = ram_regions.get(1) {
+            let ram_64bit_start = super::layout::RAM_64BIT_START.raw_value();
+
+            if second_region_start != &ram_64bit_start {
+                panic!(
+                    "Unexpected second memory region layout: start: 0x{second_region_start:08x}, ram_64bit_start: 0x{ram_64bit_start:08x}"
+                );
+            }
+
+            let mem_size = second_region_end - ram_64bit_start;
+            let mem_reg_prop = [ram_64bit_start, mem_size];
+            let memory_node_name = format!("memory@{ram_64bit_start:x}");
+            let memory_node = fdt.begin_node(&memory_node_name)?;
+            fdt.property_string("device_type", "memory")?;
+            fdt.property_array_u64("reg", &mem_reg_prop)?;
+            fdt.end_node(memory_node)?;
+        }
     }
 
     Ok(())
@@ -304,7 +620,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)?;
@@ -315,18 +631,18 @@ fn create_chosen_node(
     Ok(())
 }
 
-fn create_gic_node(fdt: &mut FdtWriter, gic_device: &dyn GicDevice) -> FdtWriterResult<()> {
-    let gic_reg_prop = gic_device.device_properties();
+fn create_gic_node(fdt: &mut FdtWriter, gic_device: &Arc<Mutex<dyn Vgic>>) -> FdtWriterResult<()> {
+    let gic_reg_prop = gic_device.lock().unwrap().device_properties();
 
     let intc_node = fdt.begin_node("intc")?;
 
-    fdt.property_string("compatible", gic_device.fdt_compatibility())?;
+    fdt.property_string("compatible", gic_device.lock().unwrap().fdt_compatibility())?;
     fdt.property_null("interrupt-controller")?;
     // "interrupt-cells" field specifies the number of cells needed to encode an
     // interrupt source. The type shall be a <u32> and the value shall be 3 if no PPI affinity description
     // is required.
     fdt.property_u32("#interrupt-cells", 3)?;
-    fdt.property_array_u64("reg", gic_reg_prop)?;
+    fdt.property_array_u64("reg", &gic_reg_prop)?;
     fdt.property_u32("phandle", GIC_PHANDLE)?;
     fdt.property_u32("#address-cells", 2)?;
     fdt.property_u32("#size-cells", 2)?;
@@ -334,18 +650,26 @@ fn create_gic_node(fdt: &mut FdtWriter, gic_device: &dyn GicDevice) -> FdtWriter
 
     let gic_intr_prop = [
         GIC_FDT_IRQ_TYPE_PPI,
-        gic_device.fdt_maint_irq(),
+        gic_device.lock().unwrap().fdt_maint_irq(),
         IRQ_TYPE_LEVEL_HI,
     ];
     fdt.property_array_u32("interrupts", &gic_intr_prop)?;
 
-    if gic_device.msi_compatible() {
+    if gic_device.lock().unwrap().msi_compatible() {
         let msic_node = fdt.begin_node("msic")?;
-        fdt.property_string("compatible", gic_device.msi_compatibility())?;
+        let msi_compatibility = gic_device.lock().unwrap().msi_compatibility().to_string();
+
+        fdt.property_string("compatible", msi_compatibility.as_str())?;
         fdt.property_null("msi-controller")?;
         fdt.property_u32("phandle", MSI_PHANDLE)?;
-        let msi_reg_prop = gic_device.msi_properties();
-        fdt.property_array_u64("reg", msi_reg_prop)?;
+        let msi_reg_prop = gic_device.lock().unwrap().msi_properties();
+        fdt.property_array_u64("reg", &msi_reg_prop)?;
+
+        if msi_compatibility == GIC_V2M_COMPATIBLE {
+            fdt.property_u32("arm,msi-base-spi", SPI_BASE)?;
+            fdt.property_u32("arm,msi-num-spis", SPI_NUM)?;
+        }
+
         fdt.end_node(msic_node)?;
     }
 
@@ -372,9 +696,14 @@ fn create_clock_node(fdt: &mut FdtWriter) -> FdtWriterResult<()> {
 
 fn create_timer_node(fdt: &mut FdtWriter) -> FdtWriterResult<()> {
     // See
-    // https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/interrupt-controller/arch_timer.txt
+    // https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/timer/arm%2Carch_timer.yaml
     // These are fixed interrupt numbers for the timer device.
-    let irqs = [13, 14, 11, 10];
+    let irqs = [
+        AARCH64_ARCH_TIMER_PHYS_SECURE_IRQ,
+        AARCH64_ARCH_TIMER_PHYS_NONSECURE_IRQ,
+        AARCH64_ARCH_TIMER_VIRT_IRQ,
+        AARCH64_ARCH_TIMER_HYP_IRQ,
+    ];
     let compatible = "arm,armv8-timer";
 
     let mut timer_reg_cells: Vec<u32> = Vec::new();
@@ -509,6 +838,21 @@ fn create_gpio_node<T: DeviceInfoForFdt + Clone + Debug>(
     Ok(())
 }
 
+// https://www.kernel.org/doc/Documentation/devicetree/bindings/arm/fw-cfg.txt
+#[cfg(feature = "fw_cfg")]
+fn create_fw_cfg_node<T: DeviceInfoForFdt + Clone + Debug>(
+    fdt: &mut FdtWriter,
+    dev_info: &T,
+) -> FdtWriterResult<()> {
+    // FwCfg node
+    let fw_cfg_node = fdt.begin_node(&format!("fw-cfg@{:x}", dev_info.addr()))?;
+    fdt.property("compatible", b"qemu,fw-cfg-mmio\0")?;
+    fdt.property_array_u64("reg", &[dev_info.addr(), dev_info.length()])?;
+    fdt.end_node(fw_cfg_node)?;
+
+    Ok(())
+}
+
 fn create_devices_node<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
     fdt: &mut FdtWriter,
     dev_info: &HashMap<(DeviceType, String), T, S>,
@@ -524,6 +868,8 @@ fn create_devices_node<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::Buil
             DeviceType::Virtio(_) => {
                 ordered_virtio_device.push(info);
             }
+            #[cfg(feature = "fw_cfg")]
+            DeviceType::FwCfg => create_fw_cfg_node(fdt, info)?,
         }
     }
 
@@ -540,6 +886,17 @@ fn create_devices_node<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::Buil
     Ok(())
 }
 
+fn create_pmu_node(fdt: &mut FdtWriter) -> FdtWriterResult<()> {
+    let compatible = "arm,armv8-pmuv3";
+    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)?;
+    fdt.property_array_u32("interrupts", &irq)?;
+    fdt.end_node(pmu_node)?;
+    Ok(())
+}
+
 fn create_pci_nodes(
     fdt: &mut FdtWriter,
     pci_device_info: &[PciSpaceInfo],
@@ -552,23 +909,22 @@ fn create_pci_nodes(
     for pci_device_info_elem in pci_device_info.iter() {
         // EDK2 requires the PCIe high space above 4G address.
         // The actual space in CLH follows the RAM. If the RAM space is small, the PCIe high space
-        // could fall bellow 4G.
+        // could fall below 4G.
         // Here we cut off PCI device space below 8G in FDT to workaround the EDK2 check.
         // But the address written in ACPI is not impacted.
-        let (pci_device_base_64bit, pci_device_size_64bit) = if cfg!(feature = "acpi")
-            && (pci_device_info_elem.pci_device_space_start < PCI_HIGH_BASE)
-        {
-            (
-                PCI_HIGH_BASE,
-                pci_device_info_elem.pci_device_space_size
-                    - (PCI_HIGH_BASE - pci_device_info_elem.pci_device_space_start),
-            )
-        } else {
-            (
-                pci_device_info_elem.pci_device_space_start,
-                pci_device_info_elem.pci_device_space_size,
-            )
-        };
+        let (pci_device_base_64bit, pci_device_size_64bit) =
+            if pci_device_info_elem.pci_device_space_start < PCI_HIGH_BASE.raw_value() {
+                (
+                    PCI_HIGH_BASE.raw_value(),
+                    pci_device_info_elem.pci_device_space_size
+                        - (PCI_HIGH_BASE.raw_value() - pci_device_info_elem.pci_device_space_start),
+                )
+            } else {
+                (
+                    pci_device_info_elem.pci_device_space_start,
+                    pci_device_info_elem.pci_device_space_size,
+                )
+            };
         // There is no specific requirement of the 32bit MMIO range, and
         // therefore at least we can make these ranges 4K aligned.
         let pci_device_size_32bit: u64 =
@@ -643,39 +999,39 @@ fn create_pci_nodes(
         fdt.property_array_u32("msi-map", &msi_map)?;
         fdt.property_u32("msi-parent", MSI_PHANDLE)?;
 
-        if pci_device_info_elem.pci_segment_id == 0 {
-            if let Some(virtio_iommu_bdf) = virtio_iommu_bdf {
-                // See kernel document Documentation/devicetree/bindings/pci/pci-iommu.txt
-                // for 'iommu-map' attribute setting.
-                let iommu_map = [
-                    0_u32,
-                    VIRTIO_IOMMU_PHANDLE,
-                    0_u32,
-                    virtio_iommu_bdf,
-                    virtio_iommu_bdf + 1,
-                    VIRTIO_IOMMU_PHANDLE,
-                    virtio_iommu_bdf + 1,
-                    0xffff - virtio_iommu_bdf,
-                ];
-                fdt.property_array_u32("iommu-map", &iommu_map)?;
+        if pci_device_info_elem.pci_segment_id == 0
+            && let Some(virtio_iommu_bdf) = virtio_iommu_bdf
+        {
+            // See kernel document Documentation/devicetree/bindings/pci/pci-iommu.txt
+            // for 'iommu-map' attribute setting.
+            let iommu_map = [
+                0_u32,
+                VIRTIO_IOMMU_PHANDLE,
+                0_u32,
+                virtio_iommu_bdf,
+                virtio_iommu_bdf + 1,
+                VIRTIO_IOMMU_PHANDLE,
+                virtio_iommu_bdf + 1,
+                0xffff - virtio_iommu_bdf,
+            ];
+            fdt.property_array_u32("iommu-map", &iommu_map)?;
 
-                // 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 = fdt.begin_node(&virtio_iommu_node_name)?;
-                fdt.property_u32("#iommu-cells", 1)?;
-                fdt.property_string("compatible", "virtio,pci-iommu")?;
+            // See kernel document Documentation/devicetree/bindings/virtio/iommu.txt
+            // for virtio-iommu node settings.
+            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")?;
 
-                // 'reg' is a five-cell address encoded as
-                // (phys.hi phys.mid phys.lo size.hi size.lo). phys.hi should contain the
-                // device's BDF as 0b00000000 bbbbbbbb dddddfff 00000000. The other cells
-                // should be zero.
-                let reg = [virtio_iommu_bdf << 8, 0_u32, 0_u32, 0_u32, 0_u32];
-                fdt.property_array_u32("reg", &reg)?;
-                fdt.property_u32("phandle", VIRTIO_IOMMU_PHANDLE)?;
+            // 'reg' is a five-cell address encoded as
+            // (phys.hi phys.mid phys.lo size.hi size.lo). phys.hi should contain the
+            // device's BDF as 0b00000000 bbbbbbbb dddddfff 00000000. The other cells
+            // should be zero.
+            let reg = [virtio_iommu_bdf << 8, 0_u32, 0_u32, 0_u32, 0_u32];
+            fdt.property_array_u32("reg", &reg)?;
+            fdt.property_u32("phandle", VIRTIO_IOMMU_PHANDLE)?;
 
-                fdt.end_node(virtio_iommu_node)?;
-            }
+            fdt.end_node(virtio_iommu_node)?;
         }
 
         fdt.end_node(pci_node)?;
@@ -770,10 +1126,7 @@ fn print_node(node: fdt_parser::node::FdtNode<'_, '_>, n_spaces: usize) {
         //   - At first, try to convert it to CStr and print,
         //   - If failed, print it as u32 array.
         let value_result = match CStr::from_bytes_with_nul(value) {
-            Ok(value_cstr) => match value_cstr.to_str() {
-                Ok(value_str) => Some(value_str),
-                Err(_e) => None,
-            },
+            Ok(value_cstr) => value_cstr.to_str().ok(),
             Err(_e) => None,
         };
 

arch/src/aarch64/gic/gicv3.rs

@@ -1,261 +0,0 @@
-// Copyright 2021 Arm Limited (or its affiliates). All rights reserved.
-// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-//
-// This file implements the GicV3 device.
-
-pub mod kvm {
-    use crate::aarch64::gic::dist_regs::{get_dist_regs, read_ctlr, set_dist_regs, write_ctlr};
-    use crate::aarch64::gic::icc_regs::{get_icc_regs, set_icc_regs};
-    use crate::aarch64::gic::kvm::{save_pending_tables, KvmGicDevice};
-    use crate::aarch64::gic::redist_regs::{
-        construct_gicr_typers, get_redist_regs, set_redist_regs,
-    };
-    use crate::aarch64::gic::GicDevice;
-    use crate::layout;
-    use anyhow::anyhow;
-    use hypervisor::kvm::kvm_bindings;
-    use hypervisor::CpuState;
-    use std::any::Any;
-    use std::convert::TryInto;
-    use std::sync::Arc;
-    use std::{boxed::Box, result};
-    use versionize::{VersionMap, Versionize, VersionizeResult};
-    use versionize_derive::Versionize;
-    use vm_migration::{
-        Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable,
-        VersionMapped,
-    };
-
-    /// Errors thrown while saving/restoring the GICv3.
-    #[derive(Debug)]
-    pub enum Error {
-        /// Error in saving RDIST pending tables into guest RAM.
-        SavePendingTables(crate::aarch64::gic::Error),
-        /// Error in saving GIC distributor registers.
-        SaveDistributorRegisters(crate::aarch64::gic::Error),
-        /// Error in restoring GIC distributor registers.
-        RestoreDistributorRegisters(crate::aarch64::gic::Error),
-        /// Error in saving GIC distributor control registers.
-        SaveDistributorCtrlRegisters(crate::aarch64::gic::Error),
-        /// Error in restoring GIC distributor control registers.
-        RestoreDistributorCtrlRegisters(crate::aarch64::gic::Error),
-        /// Error in saving GIC redistributor registers.
-        SaveRedistributorRegisters(crate::aarch64::gic::Error),
-        /// Error in restoring GIC redistributor registers.
-        RestoreRedistributorRegisters(crate::aarch64::gic::Error),
-        /// Error in saving GIC CPU interface registers.
-        SaveIccRegisters(crate::aarch64::gic::Error),
-        /// Error in restoring GIC CPU interface registers.
-        RestoreIccRegisters(crate::aarch64::gic::Error),
-    }
-
-    type Result<T> = result::Result<T, Error>;
-
-    pub struct KvmGicV3 {
-        /// The hypervisor agnostic device for the GicV3
-        device: Arc<dyn hypervisor::Device>,
-
-        /// Vector holding values of GICR_TYPER for each vCPU
-        gicr_typers: Vec<u64>,
-
-        /// GIC device properties, to be used for setting up the fdt entry
-        properties: [u64; 4],
-
-        /// Number of CPUs handled by the device
-        vcpu_count: u64,
-    }
-
-    #[derive(Versionize)]
-    pub struct Gicv3State {
-        dist: Vec<u32>,
-        rdist: Vec<u32>,
-        icc: Vec<u32>,
-        // special register that enables interrupts and affinity routing
-        gicd_ctlr: u32,
-    }
-
-    impl VersionMapped for Gicv3State {}
-
-    impl KvmGicV3 {
-        // Device trees specific constants
-        pub const ARCH_GIC_V3_MAINT_IRQ: u32 = 9;
-
-        /// Get the address of the GIC distributor.
-        pub fn get_dist_addr() -> u64 {
-            layout::GIC_V3_DIST_START
-        }
-
-        /// Get the size of the GIC distributor.
-        pub fn get_dist_size() -> u64 {
-            layout::GIC_V3_DIST_SIZE
-        }
-
-        /// Get the address of the GIC redistributors.
-        pub fn get_redists_addr(vcpu_count: u64) -> u64 {
-            KvmGicV3::get_dist_addr() - KvmGicV3::get_redists_size(vcpu_count)
-        }
-
-        /// Get the size of the GIC redistributors.
-        pub fn get_redists_size(vcpu_count: u64) -> u64 {
-            vcpu_count * layout::GIC_V3_REDIST_SIZE
-        }
-
-        /// Save the state of GIC.
-        fn state(&self, gicr_typers: &[u64]) -> Result<Gicv3State> {
-            let gicd_ctlr =
-                read_ctlr(self.device()).map_err(Error::SaveDistributorCtrlRegisters)?;
-
-            let dist_state =
-                get_dist_regs(self.device()).map_err(Error::SaveDistributorRegisters)?;
-
-            let rdist_state = get_redist_regs(self.device(), gicr_typers)
-                .map_err(Error::SaveRedistributorRegisters)?;
-
-            let icc_state =
-                get_icc_regs(self.device(), gicr_typers).map_err(Error::SaveIccRegisters)?;
-
-            Ok(Gicv3State {
-                dist: dist_state,
-                rdist: rdist_state,
-                icc: icc_state,
-                gicd_ctlr,
-            })
-        }
-
-        /// Restore the state of GIC.
-        fn set_state(&mut self, gicr_typers: &[u64], state: &Gicv3State) -> Result<()> {
-            write_ctlr(self.device(), state.gicd_ctlr)
-                .map_err(Error::RestoreDistributorCtrlRegisters)?;
-
-            set_dist_regs(self.device(), &state.dist)
-                .map_err(Error::RestoreDistributorRegisters)?;
-
-            set_redist_regs(self.device(), gicr_typers, &state.rdist)
-                .map_err(Error::RestoreRedistributorRegisters)?;
-
-            set_icc_regs(self.device(), gicr_typers, &state.icc)
-                .map_err(Error::RestoreIccRegisters)?;
-
-            Ok(())
-        }
-    }
-
-    impl GicDevice for KvmGicV3 {
-        fn device(&self) -> &Arc<dyn hypervisor::Device> {
-            &self.device
-        }
-
-        fn fdt_compatibility(&self) -> &str {
-            "arm,gic-v3"
-        }
-
-        fn fdt_maint_irq(&self) -> u32 {
-            KvmGicV3::ARCH_GIC_V3_MAINT_IRQ
-        }
-
-        fn device_properties(&self) -> &[u64] {
-            &self.properties
-        }
-
-        fn vcpu_count(&self) -> u64 {
-            self.vcpu_count
-        }
-
-        fn set_its_device(&mut self, _its_device: Option<Arc<dyn hypervisor::Device>>) {}
-
-        fn set_gicr_typers(&mut self, vcpu_states: &[CpuState]) {
-            let gicr_typers = construct_gicr_typers(vcpu_states);
-            self.gicr_typers = gicr_typers;
-        }
-
-        fn as_any_concrete_mut(&mut self) -> &mut dyn Any {
-            self
-        }
-    }
-
-    impl KvmGicDevice for KvmGicV3 {
-        fn version() -> u32 {
-            kvm_bindings::kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V3
-        }
-
-        fn create_device(
-            device: Arc<dyn hypervisor::Device>,
-            vcpu_count: u64,
-        ) -> Box<dyn GicDevice> {
-            Box::new(KvmGicV3 {
-                device,
-                gicr_typers: vec![0; vcpu_count.try_into().unwrap()],
-                properties: [
-                    KvmGicV3::get_dist_addr(),
-                    KvmGicV3::get_dist_size(),
-                    KvmGicV3::get_redists_addr(vcpu_count),
-                    KvmGicV3::get_redists_size(vcpu_count),
-                ],
-                vcpu_count,
-            })
-        }
-
-        fn init_device_attributes(
-            _vm: &Arc<dyn hypervisor::Vm>,
-            gic_device: &mut dyn GicDevice,
-        ) -> crate::aarch64::gic::Result<()> {
-            /* Setting up the distributor attribute.
-             We are placing the GIC below 1GB so we need to substract the size of the distributor.
-            */
-            Self::set_device_attribute(
-                gic_device.device(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ADDR,
-                u64::from(kvm_bindings::KVM_VGIC_V3_ADDR_TYPE_DIST),
-                &KvmGicV3::get_dist_addr() as *const u64 as u64,
-                0,
-            )?;
-
-            /* Setting up the redistributors' attribute.
-            We are calculating here the start of the redistributors address. We have one per CPU.
-            */
-            Self::set_device_attribute(
-                gic_device.device(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ADDR,
-                u64::from(kvm_bindings::KVM_VGIC_V3_ADDR_TYPE_REDIST),
-                &KvmGicV3::get_redists_addr(gic_device.vcpu_count()) as *const u64 as u64,
-                0,
-            )?;
-
-            Ok(())
-        }
-    }
-
-    pub const GIC_V3_SNAPSHOT_ID: &str = "gic-v3";
-    impl Snapshottable for KvmGicV3 {
-        fn id(&self) -> String {
-            GIC_V3_SNAPSHOT_ID.to_string()
-        }
-
-        fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-            let gicr_typers = self.gicr_typers.clone();
-            Snapshot::new_from_versioned_state(&self.id(), &self.state(&gicr_typers).unwrap())
-        }
-
-        fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-            let gicr_typers = self.gicr_typers.clone();
-            self.set_state(&gicr_typers, &snapshot.to_versioned_state(&self.id())?)
-                .map_err(|e| {
-                    MigratableError::Restore(anyhow!("Could not restore GICv3 state {:?}", e))
-                })
-        }
-    }
-
-    impl Pausable for KvmGicV3 {
-        fn pause(&mut self) -> std::result::Result<(), MigratableError> {
-            // Flush redistributors pending tables to guest RAM.
-            save_pending_tables(self.device()).map_err(|e| {
-                MigratableError::Pause(anyhow!("Could not save GICv3 GIC pending tables {:?}", e))
-            })?;
-
-            Ok(())
-        }
-    }
-    impl Transportable for KvmGicV3 {}
-    impl Migratable for KvmGicV3 {}
-}

arch/src/aarch64/gic/gicv3_its.rs

@@ -1,514 +0,0 @@
-// Copyright 2021 Arm Limited (or its affiliates). All rights reserved.
-// SPDX-License-Identifier: Apache-2.0
-//
-// This file implements the GicV3 device with ITS (Virtual Interrupt Translation Service).
-
-pub mod kvm {
-    use crate::aarch64::gic::dist_regs::{get_dist_regs, read_ctlr, set_dist_regs, write_ctlr};
-    use crate::aarch64::gic::icc_regs::{get_icc_regs, set_icc_regs};
-    use crate::aarch64::gic::redist_regs::{
-        construct_gicr_typers, get_redist_regs, set_redist_regs,
-    };
-
-    use crate::aarch64::gic::gicv3::kvm::KvmGicV3;
-    use crate::aarch64::gic::kvm::{save_pending_tables, KvmGicDevice};
-    use crate::aarch64::gic::GicDevice;
-    use crate::layout;
-    use anyhow::anyhow;
-    use hypervisor::kvm::kvm_bindings;
-    use hypervisor::CpuState;
-    use std::any::Any;
-    use std::convert::TryInto;
-    use std::sync::Arc;
-    use std::{boxed::Box, result};
-    use versionize::{VersionMap, Versionize, VersionizeResult};
-    use versionize_derive::Versionize;
-    use vm_migration::{
-        Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable,
-        VersionMapped,
-    };
-
-    const GITS_CTLR: u32 = 0x0000;
-    const GITS_IIDR: u32 = 0x0004;
-    const GITS_CBASER: u32 = 0x0080;
-    const GITS_CWRITER: u32 = 0x0088;
-    const GITS_CREADR: u32 = 0x0090;
-    const GITS_BASER: u32 = 0x0100;
-
-    /// Errors thrown while saving/restoring the GICv3ITS.
-    #[derive(Debug)]
-    pub enum Error {
-        /// Error in saving RDIST pending tables into guest RAM.
-        SavePendingTables(crate::aarch64::gic::Error),
-        /// Error in saving GIC distributor registers.
-        SaveDistributorRegisters(crate::aarch64::gic::Error),
-        /// Error in restoring GIC distributor registers.
-        RestoreDistributorRegisters(crate::aarch64::gic::Error),
-        /// Error in saving GIC distributor control registers.
-        SaveDistributorCtrlRegisters(crate::aarch64::gic::Error),
-        /// Error in restoring GIC distributor control registers.
-        RestoreDistributorCtrlRegisters(crate::aarch64::gic::Error),
-        /// Error in saving GIC redistributor registers.
-        SaveRedistributorRegisters(crate::aarch64::gic::Error),
-        /// Error in restoring GIC redistributor registers.
-        RestoreRedistributorRegisters(crate::aarch64::gic::Error),
-        /// Error in saving GIC CPU interface registers.
-        SaveIccRegisters(crate::aarch64::gic::Error),
-        /// Error in restoring GIC CPU interface registers.
-        RestoreIccRegisters(crate::aarch64::gic::Error),
-        /// Error in saving GICv3ITS IIDR register.
-        SaveITSIIDR(crate::aarch64::gic::Error),
-        /// Error in restoring GICv3ITS IIDR register.
-        RestoreITSIIDR(crate::aarch64::gic::Error),
-        /// Error in saving GICv3ITS CBASER register.
-        SaveITSCBASER(crate::aarch64::gic::Error),
-        /// Error in restoring GICv3ITS CBASER register.
-        RestoreITSCBASER(crate::aarch64::gic::Error),
-        /// Error in saving GICv3ITS CREADR register.
-        SaveITSCREADR(crate::aarch64::gic::Error),
-        /// Error in restoring GICv3ITS CREADR register.
-        RestoreITSCREADR(crate::aarch64::gic::Error),
-        /// Error in saving GICv3ITS CWRITER register.
-        SaveITSCWRITER(crate::aarch64::gic::Error),
-        /// Error in restoring GICv3ITS CWRITER register.
-        RestoreITSCWRITER(crate::aarch64::gic::Error),
-        /// Error in saving GICv3ITS BASER register.
-        SaveITSBASER(crate::aarch64::gic::Error),
-        /// Error in restoring GICv3ITS BASER register.
-        RestoreITSBASER(crate::aarch64::gic::Error),
-        /// Error in saving GICv3ITS CTLR register.
-        SaveITSCTLR(crate::aarch64::gic::Error),
-        /// Error in restoring GICv3ITS CTLR register.
-        RestoreITSCTLR(crate::aarch64::gic::Error),
-        /// Error in saving GICv3ITS restore tables.
-        SaveITSTables(crate::aarch64::gic::Error),
-        /// Error in restoring GICv3ITS restore tables.
-        RestoreITSTables(crate::aarch64::gic::Error),
-    }
-
-    type Result<T> = result::Result<T, Error>;
-
-    /// Access an ITS device attribute.
-    ///
-    /// This is a helper function to get/set the ITS device attribute depending
-    /// the bool parameter `set` provided.
-    pub fn gicv3_its_attr_access(
-        its_device: &Arc<dyn hypervisor::Device>,
-        group: u32,
-        attr: u32,
-        val: &u64,
-        set: bool,
-    ) -> crate::aarch64::gic::Result<()> {
-        let mut gicv3_its_attr = kvm_bindings::kvm_device_attr {
-            group,
-            attr: attr as u64,
-            addr: val as *const u64 as u64,
-            flags: 0,
-        };
-        if set {
-            its_device
-                .set_device_attr(&gicv3_its_attr)
-                .map_err(crate::aarch64::gic::Error::SetDeviceAttribute)?;
-        } else {
-            its_device
-                .get_device_attr(&mut gicv3_its_attr)
-                .map_err(crate::aarch64::gic::Error::GetDeviceAttribute)?;
-        }
-        Ok(())
-    }
-
-    /// Function that saves/restores ITS tables into guest RAM.
-    ///
-    /// The tables get flushed to guest RAM whenever the VM gets stopped.
-    pub fn gicv3_its_tables_access(
-        its_device: &Arc<dyn hypervisor::Device>,
-        save: bool,
-    ) -> crate::aarch64::gic::Result<()> {
-        let attr = if save {
-            u64::from(kvm_bindings::KVM_DEV_ARM_ITS_SAVE_TABLES)
-        } else {
-            u64::from(kvm_bindings::KVM_DEV_ARM_ITS_RESTORE_TABLES)
-        };
-
-        let init_gic_attr = kvm_bindings::kvm_device_attr {
-            group: kvm_bindings::KVM_DEV_ARM_VGIC_GRP_CTRL,
-            attr,
-            addr: 0,
-            flags: 0,
-        };
-        its_device
-            .set_device_attr(&init_gic_attr)
-            .map_err(crate::aarch64::gic::Error::SetDeviceAttribute)
-    }
-
-    pub struct KvmGicV3Its {
-        /// The hypervisor agnostic device for the GicV3
-        device: Arc<dyn hypervisor::Device>,
-
-        /// The hypervisor agnostic device for the Its device
-        its_device: Option<Arc<dyn hypervisor::Device>>,
-
-        /// Vector holding values of GICR_TYPER for each vCPU
-        gicr_typers: Vec<u64>,
-
-        /// GIC device properties, to be used for setting up the fdt entry
-        gic_properties: [u64; 4],
-
-        /// MSI device properties, to be used for setting up the fdt entry
-        msi_properties: [u64; 2],
-
-        /// Number of CPUs handled by the device
-        vcpu_count: u64,
-    }
-
-    #[derive(Versionize)]
-    pub struct Gicv3ItsState {
-        dist: Vec<u32>,
-        rdist: Vec<u32>,
-        icc: Vec<u32>,
-        // special register that enables interrupts and affinity routing
-        gicd_ctlr: u32,
-        its_ctlr: u64,
-        its_iidr: u64,
-        its_cbaser: u64,
-        its_cwriter: u64,
-        its_creadr: u64,
-        its_baser: [u64; 8],
-    }
-
-    impl VersionMapped for Gicv3ItsState {}
-
-    impl KvmGicV3Its {
-        fn get_msi_size() -> u64 {
-            layout::GIC_V3_ITS_SIZE
-        }
-
-        fn get_msi_addr(vcpu_count: u64) -> u64 {
-            KvmGicV3::get_redists_addr(vcpu_count) - KvmGicV3Its::get_msi_size()
-        }
-
-        /// Save the state of GICv3ITS.
-        fn state(&self, gicr_typers: &[u64]) -> Result<Gicv3ItsState> {
-            let gicd_ctlr =
-                read_ctlr(self.device()).map_err(Error::SaveDistributorCtrlRegisters)?;
-
-            let dist_state =
-                get_dist_regs(self.device()).map_err(Error::SaveDistributorRegisters)?;
-
-            let rdist_state = get_redist_regs(self.device(), gicr_typers)
-                .map_err(Error::SaveRedistributorRegisters)?;
-
-            let icc_state =
-                get_icc_regs(self.device(), gicr_typers).map_err(Error::SaveIccRegisters)?;
-
-            let its_baser_state: [u64; 8] = [0; 8];
-            for i in 0..8 {
-                gicv3_its_attr_access(
-                    self.its_device().unwrap(),
-                    kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                    GITS_BASER + i * 8,
-                    &its_baser_state[i as usize],
-                    false,
-                )
-                .map_err(Error::SaveITSBASER)?;
-            }
-
-            let its_ctlr_state: u64 = 0;
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_CTLR,
-                &its_ctlr_state,
-                false,
-            )
-            .map_err(Error::SaveITSCTLR)?;
-
-            let its_cbaser_state: u64 = 0;
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_CBASER,
-                &its_cbaser_state,
-                false,
-            )
-            .map_err(Error::SaveITSCBASER)?;
-
-            let its_creadr_state: u64 = 0;
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_CREADR,
-                &its_creadr_state,
-                false,
-            )
-            .map_err(Error::SaveITSCREADR)?;
-
-            let its_cwriter_state: u64 = 0;
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_CWRITER,
-                &its_cwriter_state,
-                false,
-            )
-            .map_err(Error::SaveITSCWRITER)?;
-
-            let its_iidr_state: u64 = 0;
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_IIDR,
-                &its_iidr_state,
-                false,
-            )
-            .map_err(Error::SaveITSIIDR)?;
-
-            Ok(Gicv3ItsState {
-                dist: dist_state,
-                rdist: rdist_state,
-                icc: icc_state,
-                gicd_ctlr,
-                its_ctlr: its_ctlr_state,
-                its_iidr: its_iidr_state,
-                its_cbaser: its_cbaser_state,
-                its_cwriter: its_cwriter_state,
-                its_creadr: its_creadr_state,
-                its_baser: its_baser_state,
-            })
-        }
-
-        /// Restore the state of GICv3ITS.
-        fn set_state(&mut self, gicr_typers: &[u64], state: &Gicv3ItsState) -> Result<()> {
-            write_ctlr(self.device(), state.gicd_ctlr)
-                .map_err(Error::RestoreDistributorCtrlRegisters)?;
-
-            set_dist_regs(self.device(), &state.dist)
-                .map_err(Error::RestoreDistributorRegisters)?;
-
-            set_redist_regs(self.device(), gicr_typers, &state.rdist)
-                .map_err(Error::RestoreRedistributorRegisters)?;
-
-            set_icc_regs(self.device(), gicr_typers, &state.icc)
-                .map_err(Error::RestoreIccRegisters)?;
-
-            //Restore GICv3ITS registers
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_IIDR,
-                &state.its_iidr,
-                true,
-            )
-            .map_err(Error::RestoreITSIIDR)?;
-
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_CBASER,
-                &state.its_cbaser,
-                true,
-            )
-            .map_err(Error::RestoreITSCBASER)?;
-
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_CREADR,
-                &state.its_creadr,
-                true,
-            )
-            .map_err(Error::RestoreITSCREADR)?;
-
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_CWRITER,
-                &state.its_cwriter,
-                true,
-            )
-            .map_err(Error::RestoreITSCWRITER)?;
-
-            for i in 0..8 {
-                gicv3_its_attr_access(
-                    self.its_device().unwrap(),
-                    kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                    GITS_BASER + i * 8,
-                    &state.its_baser[i as usize],
-                    true,
-                )
-                .map_err(Error::RestoreITSBASER)?;
-            }
-
-            // Restore ITS tables
-            gicv3_its_tables_access(self.its_device().unwrap(), false)
-                .map_err(Error::RestoreITSTables)?;
-
-            gicv3_its_attr_access(
-                self.its_device().unwrap(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ITS_REGS,
-                GITS_CTLR,
-                &state.its_ctlr,
-                true,
-            )
-            .map_err(Error::RestoreITSCTLR)?;
-
-            Ok(())
-        }
-    }
-
-    impl GicDevice for KvmGicV3Its {
-        fn device(&self) -> &Arc<dyn hypervisor::Device> {
-            &self.device
-        }
-
-        fn its_device(&self) -> Option<&Arc<dyn hypervisor::Device>> {
-            self.its_device.as_ref()
-        }
-
-        fn fdt_compatibility(&self) -> &str {
-            "arm,gic-v3"
-        }
-
-        fn msi_compatible(&self) -> bool {
-            true
-        }
-
-        fn msi_compatibility(&self) -> &str {
-            "arm,gic-v3-its"
-        }
-
-        fn fdt_maint_irq(&self) -> u32 {
-            KvmGicV3::ARCH_GIC_V3_MAINT_IRQ
-        }
-
-        fn msi_properties(&self) -> &[u64] {
-            &self.msi_properties
-        }
-
-        fn device_properties(&self) -> &[u64] {
-            &self.gic_properties
-        }
-
-        fn vcpu_count(&self) -> u64 {
-            self.vcpu_count
-        }
-
-        fn set_its_device(&mut self, its_device: Option<Arc<dyn hypervisor::Device>>) {
-            self.its_device = its_device;
-        }
-
-        fn set_gicr_typers(&mut self, vcpu_states: &[CpuState]) {
-            let gicr_typers = construct_gicr_typers(vcpu_states);
-            self.gicr_typers = gicr_typers;
-        }
-
-        fn as_any_concrete_mut(&mut self) -> &mut dyn Any {
-            self
-        }
-    }
-
-    impl KvmGicDevice for KvmGicV3Its {
-        fn version() -> u32 {
-            KvmGicV3::version()
-        }
-
-        fn create_device(
-            device: Arc<dyn hypervisor::Device>,
-            vcpu_count: u64,
-        ) -> Box<dyn GicDevice> {
-            Box::new(KvmGicV3Its {
-                device,
-                its_device: None,
-                gicr_typers: vec![0; vcpu_count.try_into().unwrap()],
-                gic_properties: [
-                    KvmGicV3::get_dist_addr(),
-                    KvmGicV3::get_dist_size(),
-                    KvmGicV3::get_redists_addr(vcpu_count),
-                    KvmGicV3::get_redists_size(vcpu_count),
-                ],
-                msi_properties: [
-                    KvmGicV3Its::get_msi_addr(vcpu_count),
-                    KvmGicV3Its::get_msi_size(),
-                ],
-                vcpu_count,
-            })
-        }
-
-        fn init_device_attributes(
-            vm: &Arc<dyn hypervisor::Vm>,
-            gic_device: &mut dyn GicDevice,
-        ) -> crate::aarch64::gic::Result<()> {
-            KvmGicV3::init_device_attributes(vm, gic_device)?;
-
-            let mut its_device = kvm_bindings::kvm_create_device {
-                type_: kvm_bindings::kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_ITS,
-                fd: 0,
-                flags: 0,
-            };
-
-            let its_fd = vm
-                .create_device(&mut its_device)
-                .map_err(crate::aarch64::gic::Error::CreateGic)?;
-
-            Self::set_device_attribute(
-                &its_fd,
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_ADDR,
-                u64::from(kvm_bindings::KVM_VGIC_ITS_ADDR_TYPE),
-                &KvmGicV3Its::get_msi_addr(gic_device.vcpu_count()) as *const u64 as u64,
-                0,
-            )?;
-
-            Self::set_device_attribute(
-                &its_fd,
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_CTRL,
-                u64::from(kvm_bindings::KVM_DEV_ARM_VGIC_CTRL_INIT),
-                0,
-                0,
-            )?;
-
-            gic_device.set_its_device(Some(its_fd));
-
-            Ok(())
-        }
-    }
-
-    pub const GIC_V3_ITS_SNAPSHOT_ID: &str = "gic-v3-its";
-    impl Snapshottable for KvmGicV3Its {
-        fn id(&self) -> String {
-            GIC_V3_ITS_SNAPSHOT_ID.to_string()
-        }
-
-        fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-            let gicr_typers = self.gicr_typers.clone();
-            Snapshot::new_from_versioned_state(&self.id(), &self.state(&gicr_typers).unwrap())
-        }
-
-        fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-            let gicr_typers = self.gicr_typers.clone();
-            self.set_state(&gicr_typers, &snapshot.to_versioned_state(&self.id())?)
-                .map_err(|e| {
-                    MigratableError::Restore(anyhow!("Could not restore GICv3ITS state {:?}", e))
-                })
-        }
-    }
-
-    impl Pausable for KvmGicV3Its {
-        fn pause(&mut self) -> std::result::Result<(), MigratableError> {
-            // Flush redistributors pending tables to guest RAM.
-            save_pending_tables(self.device()).map_err(|e| {
-                MigratableError::Pause(anyhow!(
-                    "Could not save GICv3ITS GIC pending tables {:?}",
-                    e
-                ))
-            })?;
-            // Flush ITS tables to guest RAM.
-            gicv3_its_tables_access(self.its_device().unwrap(), true).map_err(|e| {
-                MigratableError::Pause(anyhow!("Could not save GICv3ITS ITS tables {:?}", e))
-            })?;
-
-            Ok(())
-        }
-    }
-    impl Transportable for KvmGicV3Its {}
-    impl Migratable for KvmGicV3Its {}
-}

arch/src/aarch64/gic/mod.rs

@@ -1,220 +0,0 @@
-// Copyright 2021 Arm Limited (or its affiliates). All rights reserved.
-// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod dist_regs;
-pub mod gicv3;
-pub mod gicv3_its;
-pub mod icc_regs;
-pub mod redist_regs;
-
-pub use self::dist_regs::{get_dist_regs, read_ctlr, set_dist_regs, write_ctlr};
-pub use self::icc_regs::{get_icc_regs, set_icc_regs};
-pub use self::redist_regs::{get_redist_regs, set_redist_regs};
-use hypervisor::CpuState;
-use std::any::Any;
-use std::result;
-use std::sync::Arc;
-
-/// Errors thrown while setting up the GIC.
-#[derive(Debug)]
-pub enum Error {
-    /// Error while calling KVM ioctl for setting up the global interrupt controller.
-    CreateGic(hypervisor::HypervisorVmError),
-    /// Error while setting device attributes for the GIC.
-    SetDeviceAttribute(hypervisor::HypervisorDeviceError),
-    /// Error while getting device attributes for the GIC.
-    GetDeviceAttribute(hypervisor::HypervisorDeviceError),
-}
-type Result<T> = result::Result<T, Error>;
-
-pub trait GicDevice: Send {
-    /// Returns the hypervisor agnostic Device of the GIC device
-    fn device(&self) -> &Arc<dyn hypervisor::Device>;
-
-    /// Returns the hypervisor agnostic Device of the ITS device
-    fn its_device(&self) -> Option<&Arc<dyn hypervisor::Device>> {
-        None
-    }
-
-    /// Returns the fdt compatibility property of the device
-    fn fdt_compatibility(&self) -> &str;
-
-    /// Returns the maint_irq fdt property of the device
-    fn fdt_maint_irq(&self) -> u32;
-
-    /// Returns an array with GIC device properties
-    fn device_properties(&self) -> &[u64];
-
-    /// Returns the number of vCPUs this GIC handles
-    fn vcpu_count(&self) -> u64;
-
-    /// Returns whether the GIC device is MSI compatible or not
-    fn msi_compatible(&self) -> bool {
-        false
-    }
-
-    /// Returns the MSI compatibility property of the device
-    fn msi_compatibility(&self) -> &str {
-        ""
-    }
-
-    /// Returns the MSI reg property of the device
-    fn msi_properties(&self) -> &[u64] {
-        &[]
-    }
-
-    fn set_its_device(&mut self, its_device: Option<Arc<dyn hypervisor::Device>>);
-
-    /// Get the values of GICR_TYPER for each vCPU.
-    fn set_gicr_typers(&mut self, vcpu_states: &[CpuState]);
-
-    /// Downcast the trait object to its concrete type.
-    fn as_any_concrete_mut(&mut self) -> &mut dyn Any;
-}
-
-pub mod kvm {
-    use super::GicDevice;
-    use super::Result;
-    use crate::aarch64::gic::gicv3_its::kvm::KvmGicV3Its;
-    use crate::layout;
-    use hypervisor::kvm::kvm_bindings;
-    use std::boxed::Box;
-    use std::sync::Arc;
-
-    /// Trait for GIC devices.
-    pub trait KvmGicDevice: Send + Sync + GicDevice {
-        /// Returns the GIC version of the device
-        fn version() -> u32;
-
-        /// Create the GIC device object
-        fn create_device(
-            device: Arc<dyn hypervisor::Device>,
-            vcpu_count: u64,
-        ) -> Box<dyn GicDevice>;
-
-        /// Setup the device-specific attributes
-        fn init_device_attributes(
-            vm: &Arc<dyn hypervisor::Vm>,
-            gic_device: &mut dyn GicDevice,
-        ) -> Result<()>;
-
-        /// Initialize a GIC device
-        fn init_device(vm: &Arc<dyn hypervisor::Vm>) -> Result<Arc<dyn hypervisor::Device>> {
-            let mut gic_device = kvm_bindings::kvm_create_device {
-                type_: Self::version(),
-                fd: 0,
-                flags: 0,
-            };
-
-            vm.create_device(&mut gic_device)
-                .map_err(super::Error::CreateGic)
-        }
-
-        /// Set a GIC device attribute
-        fn set_device_attribute(
-            device: &Arc<dyn hypervisor::Device>,
-            group: u32,
-            attr: u64,
-            addr: u64,
-            flags: u32,
-        ) -> Result<()> {
-            let attr = kvm_bindings::kvm_device_attr {
-                flags,
-                group,
-                attr,
-                addr,
-            };
-            device
-                .set_device_attr(&attr)
-                .map_err(super::Error::SetDeviceAttribute)?;
-
-            Ok(())
-        }
-
-        /// Get a GIC device attribute
-        fn get_device_attribute(
-            device: &Arc<dyn hypervisor::Device>,
-            group: u32,
-            attr: u64,
-            addr: u64,
-            flags: u32,
-        ) -> Result<()> {
-            let mut attr = kvm_bindings::kvm_device_attr {
-                flags,
-                group,
-                attr,
-                addr,
-            };
-            device
-                .get_device_attr(&mut attr)
-                .map_err(super::Error::GetDeviceAttribute)?;
-
-            Ok(())
-        }
-
-        /// Finalize the setup of a GIC device
-        fn finalize_device(gic_device: &dyn GicDevice) -> Result<()> {
-            /* We need to tell the kernel how many irqs to support with this vgic.
-             * See the `layout` module for details.
-             */
-            let nr_irqs: u32 = layout::IRQ_NUM;
-            let nr_irqs_ptr = &nr_irqs as *const u32;
-            Self::set_device_attribute(
-                gic_device.device(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
-                0,
-                nr_irqs_ptr as u64,
-                0,
-            )?;
-
-            /* Finalize the GIC.
-             * See https://code.woboq.org/linux/linux/virt/kvm/arm/vgic/vgic-kvm-device.c.html#211.
-             */
-            Self::set_device_attribute(
-                gic_device.device(),
-                kvm_bindings::KVM_DEV_ARM_VGIC_GRP_CTRL,
-                u64::from(kvm_bindings::KVM_DEV_ARM_VGIC_CTRL_INIT),
-                0,
-                0,
-            )?;
-
-            Ok(())
-        }
-
-        /// Method to initialize the GIC device
-        #[allow(clippy::new_ret_no_self)]
-        fn new(vm: &Arc<dyn hypervisor::Vm>, vcpu_count: u64) -> Result<Box<dyn GicDevice>> {
-            let vgic_fd = Self::init_device(vm)?;
-
-            let mut device = Self::create_device(vgic_fd, vcpu_count);
-
-            Self::init_device_attributes(vm, &mut *device)?;
-
-            Self::finalize_device(&*device)?;
-
-            Ok(device)
-        }
-    }
-
-    /// Create a GICv3-ITS device.
-    ///
-    pub fn create_gic(vm: &Arc<dyn hypervisor::Vm>, vcpu_count: u64) -> Result<Box<dyn GicDevice>> {
-        debug!("creating a GICv3-ITS");
-        KvmGicV3Its::new(vm, vcpu_count)
-    }
-
-    /// Function that saves RDIST pending tables into guest RAM.
-    ///
-    /// The tables get flushed to guest RAM whenever the VM gets stopped.
-    pub fn save_pending_tables(gic: &Arc<dyn hypervisor::Device>) -> Result<()> {
-        let init_gic_attr = kvm_bindings::kvm_device_attr {
-            group: kvm_bindings::KVM_DEV_ARM_VGIC_GRP_CTRL,
-            attr: u64::from(kvm_bindings::KVM_DEV_ARM_VGIC_SAVE_PENDING_TABLES),
-            addr: 0,
-            flags: 0,
-        };
-        gic.set_device_attr(&init_gic_attr)
-            .map_err(super::Error::SetDeviceAttribute)
-    }
-}

arch/src/aarch64/layout.rs

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 //
-// Memory layout of Aarch64 guest:
+// Memory layout of AArch64 guest:
 //
 // Physical  +---------------------------------------------------------------+
 // address   |                                                               |
@@ -20,6 +20,13 @@
 //           |                            DRAM                               |
 //           |                                                               |
 //           |                                                               |
+// 4GB       +---------------------------------------------------------------+
+//           |                      32-bit devices hole                      |
+// 4GB-64M   +---------------------------------------------------------------+
+//           |                                                               |
+//           |                                                               |
+//           |                            DRAM                               |
+//           |                                                               |
 //           |                                                               |
 // 1GB       +---------------------------------------------------------------+
 //           |                                                               |
@@ -35,11 +42,11 @@
 //           |                        Legacy devices space                   |
 //           |                                                               |
 // 144 M     +---------------------------------------------------------------|
+//           |                                                               |
 //           |                    Reserved (now GIC is here)                 |
-// 64  M     +---------------------------------------------------------------+
-//           |                                                               |
-//           |                          UEFI space                           |
 //           |                                                               |
+//  4  M     +---------------------------------------------------------------+
+//           |                          UEFI flash                           |
 // 0GB       +---------------------------------------------------------------+
 //
 //
@@ -48,17 +55,16 @@ use vm_memory::GuestAddress;
 
 /// 0x0 ~ 0x40_0000 (4 MiB) is reserved to UEFI
 /// UEFI binary size is required less than 3 MiB, reserving 4 MiB is enough.
-pub const UEFI_START: u64 = 0x0;
-pub const MEM_UEFI_START: GuestAddress = GuestAddress(0);
+pub const UEFI_START: GuestAddress = GuestAddress(0);
 pub const UEFI_SIZE: u64 = 0x040_0000;
 
 /// Below this address will reside the GIC, above this address will reside the MMIO devices.
-pub const MAPPED_IO_START: u64 = 0x0900_0000;
+const MAPPED_IO_START: GuestAddress = GuestAddress(0x0900_0000);
 
 /// See kernel file arch/arm64/include/uapi/asm/kvm.h for the GIC related definitions.
 /// 0x08ff_0000 ~ 0x0900_0000 is reserved for GICv3 Distributor
 pub const GIC_V3_DIST_SIZE: u64 = 0x01_0000;
-pub const GIC_V3_DIST_START: u64 = MAPPED_IO_START - GIC_V3_DIST_SIZE;
+pub const GIC_V3_DIST_START: GuestAddress = GuestAddress(MAPPED_IO_START.0 - GIC_V3_DIST_SIZE);
 /// Below 0x08ff_0000 is reserved for GICv3 Redistributor.
 /// The size defined here is for each vcpu.
 /// The total size is 'number_of_vcpu * GIC_V3_REDIST_SIZE'
@@ -67,9 +73,9 @@ pub const GIC_V3_REDIST_SIZE: u64 = 0x02_0000;
 pub const GIC_V3_ITS_SIZE: u64 = 0x02_0000;
 
 /// Space 0x0900_0000 ~ 0x0905_0000 is reserved for legacy devices.
-pub const LEGACY_SERIAL_MAPPED_IO_START: u64 = 0x0900_0000;
-pub const LEGACY_RTC_MAPPED_IO_START: u64 = 0x0901_0000;
-pub const LEGACY_GPIO_MAPPED_IO_START: u64 = 0x0902_0000;
+pub const LEGACY_SERIAL_MAPPED_IO_START: GuestAddress = MAPPED_IO_START;
+pub const LEGACY_RTC_MAPPED_IO_START: GuestAddress = GuestAddress(0x0901_0000);
+pub const LEGACY_GPIO_MAPPED_IO_START: GuestAddress = GuestAddress(0x0902_0000);
 
 /// Space 0x0905_0000 ~ 0x0906_0000 is reserved for pcie io address
 pub const MEM_PCI_IO_START: GuestAddress = GuestAddress(0x0905_0000);
@@ -85,28 +91,41 @@ pub const PCI_MMCONFIG_SIZE: u64 = 256 << 20;
 // One bus with potentially 256 devices (32 slots x 8 functions).
 pub const PCI_MMIO_CONFIG_SIZE_PER_SEGMENT: u64 = 4096 * 256;
 
-/// Start of RAM on 64 bit ARM.
-pub const RAM_64BIT_START: u64 = 0x4000_0000;
+/// Start of RAM.
+pub const RAM_START: GuestAddress = GuestAddress(0x4000_0000);
+
+/// 32-bit reserved area: 64MiB before 4GiB
+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);
 
 /// Kernel command line maximum size.
 /// As per `arch/arm64/include/uapi/asm/setup.h`.
 pub const CMDLINE_MAX_SIZE: usize = 2048;
 
 /// FDT is at the beginning of RAM.
-/// Maximum size of the device tree blob as specified in https://www.kernel.org/doc/Documentation/arm64/booting.txt.
-pub const FDT_START: u64 = RAM_64BIT_START;
-pub const FDT_MAX_SIZE: usize = 0x20_0000;
+pub const FDT_START: GuestAddress = RAM_START;
+/// Maximum size of the device tree blob as specified in [the kernel
+/// documentation](https://www.kernel.org/doc/Documentation/arm64/booting.txt).
+pub const FDT_MAX_SIZE: u64 = 0x20_0000;
 
 /// Put ACPI table above dtb
-pub const ACPI_START: u64 = RAM_64BIT_START + FDT_MAX_SIZE as u64;
-pub const ACPI_MAX_SIZE: usize = 0x20_0000;
-pub const RSDP_POINTER: GuestAddress = GuestAddress(ACPI_START);
+pub const ACPI_START: GuestAddress = GuestAddress(RAM_START.0 + FDT_MAX_SIZE);
+pub const ACPI_MAX_SIZE: u64 = 0x20_0000;
+pub const RSDP_POINTER: GuestAddress = ACPI_START;
 
 /// Kernel start after FDT and ACPI
-pub const KERNEL_START: u64 = ACPI_START + ACPI_MAX_SIZE as u64;
+pub const KERNEL_START: GuestAddress = GuestAddress(ACPI_START.0 + ACPI_MAX_SIZE);
 
 /// Pci high memory base
-pub const PCI_HIGH_BASE: u64 = 0x2_0000_0000_u64;
+pub const PCI_HIGH_BASE: GuestAddress = GuestAddress(0x2_0000_0000);
 
 // As per virt/kvm/arm/vgic/vgic-kvm-device.c we need
 // the number of interrupts our GIC will support to be:
@@ -119,3 +138,12 @@ pub const IRQ_BASE: u32 = 32;
 
 /// Number of supported interrupts
 pub const IRQ_NUM: u32 = 256;
+
+/// Base SPI interrupt number
+pub const SPI_BASE: u32 = 32;
+
+/// Total number of SPIs
+pub const SPI_NUM: u32 = 64;
+
+/// GICv2M compatible string
+pub const GIC_V2M_COMPATIBLE: &str = "arm,gic-v2m-frame";

arch/src/aarch64/mod.rs

@@ -4,51 +4,56 @@
 
 /// Module for the flattened device tree.
 pub mod fdt;
-/// Module for the global interrupt controller configuration.
-pub mod gic;
 /// Layout for this aarch64 system.
 pub mod layout;
-/// Logic for configuring aarch64 registers.
-pub mod regs;
 /// Module for loading UEFI binary.
 pub mod uefi;
 
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::sync::{Arc, Mutex};
+
+use hypervisor::arch::aarch64::gic::Vgic;
+use hypervisor::arch::aarch64::regs::MPIDR_EL1;
+use log::{Level, log_enabled};
+use thiserror::Error;
+use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic};
+
 pub use self::fdt::DeviceInfoForFdt;
 use crate::{DeviceType, GuestMemoryMmap, NumaNodes, PciSpaceInfo, RegionType};
-use gic::GicDevice;
-use log::{log_enabled, Level};
-use std::collections::HashMap;
-use std::convert::TryInto;
-use std::fmt::Debug;
-use std::sync::Arc;
-use vm_memory::{Address, GuestAddress, GuestMemory, GuestUsize};
+
+pub const _NSIG: i32 = 65;
 
 /// Errors thrown while configuring aarch64 system.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum Error {
     /// Failed to create a FDT.
+    #[error("Failed to create a FDT")]
     SetupFdt,
 
     /// Failed to write FDT to memory.
-    WriteFdtToMemory(fdt::Error),
+    #[error("Failed to write FDT to memory")]
+    WriteFdtToMemory(#[source] fdt::Error),
 
     /// Failed to create a GIC.
-    SetupGic(gic::Error),
+    #[error("Failed to create a GIC")]
+    SetupGic,
 
     /// Failed to compute the initramfs address.
+    #[error("Failed to compute the initramfs address")]
     InitramfsAddress,
 
     /// Error configuring the general purpose registers
-    RegsConfiguration(regs::Error),
+    #[error("Error configuring the general purpose registers")]
+    RegsConfiguration(#[source] hypervisor::HypervisorCpuError),
 
     /// Error configuring the MPIDR register
-    VcpuRegMpidr(hypervisor::HypervisorCpuError),
-}
+    #[error("Error configuring the MPIDR register")]
+    VcpuRegMpidr(#[source] hypervisor::HypervisorCpuError),
 
-impl From<Error> for super::Error {
-    fn from(e: Error) -> super::Error {
-        super::Error::AArch64Setup(e)
-    }
+    /// Error initializing PMU for vcpu
+    #[error("Error initializing PMU for vcpu")]
+    VcpuInitPmu,
 }
 
 #[derive(Debug, Copy, Clone)]
@@ -61,45 +66,29 @@ pub struct EntryPoint {
 
 /// Configure the specified VCPU, and return its MPIDR.
 pub fn configure_vcpu(
-    fd: &Arc<dyn hypervisor::Vcpu>,
-    id: u8,
-    kernel_entry_point: Option<EntryPoint>,
+    vcpu: &Arc<dyn hypervisor::Vcpu>,
+    id: u32,
+    boot_setup: Option<(EntryPoint, &GuestMemoryAtomic<GuestMemoryMmap>)>,
 ) -> super::Result<u64> {
-    if let Some(kernel_entry_point) = kernel_entry_point {
-        regs::setup_regs(fd, id, kernel_entry_point.entry_addr.raw_value())
-            .map_err(Error::RegsConfiguration)?;
+    if let Some((kernel_entry_point, _guest_memory)) = boot_setup {
+        vcpu.setup_regs(
+            id,
+            kernel_entry_point.entry_addr.raw_value(),
+            super::layout::FDT_START.raw_value(),
+        )
+        .map_err(Error::RegsConfiguration)?;
     }
 
-    let mpidr = fd.read_mpidr().map_err(Error::VcpuRegMpidr)?;
+    let mpidr = vcpu.get_sys_reg(MPIDR_EL1).map_err(Error::VcpuRegMpidr)?;
     Ok(mpidr)
 }
 
-pub fn arch_memory_regions(size: GuestUsize) -> Vec<(GuestAddress, usize, RegionType)> {
-    // Normally UEFI should be loaded to a flash area at the beginning of memory.
-    // But now flash memory type is not supported.
-    // As a workaround, we take 4 MiB memory from the main RAM for UEFI.
-    // As a result, the RAM that the guest can see is less than what has been
-    // assigned in command line, when ACPI and UEFI is enabled.
-    let ram_deduction = if cfg!(feature = "acpi") {
-        layout::UEFI_SIZE
-    } else {
-        0
-    };
-
+pub fn arch_memory_regions() -> Vec<(GuestAddress, usize, RegionType)> {
     vec![
-        // 0 ~ 4 MiB: Reserved for UEFI space
-        #[cfg(feature = "acpi")]
-        (GuestAddress(0), layout::UEFI_SIZE as usize, RegionType::Ram),
-        #[cfg(not(feature = "acpi"))]
+        // 0 MiB ~ 256 MiB: UEFI, GIC and legacy devices
         (
             GuestAddress(0),
-            layout::UEFI_SIZE as usize,
-            RegionType::Reserved,
-        ),
-        // 4 MiB ~ 256 MiB: Gic and legacy devices
-        (
-            GuestAddress(layout::UEFI_SIZE),
-            (layout::MEM_32BIT_DEVICES_START.0 - layout::UEFI_SIZE) as usize,
+            layout::MEM_32BIT_DEVICES_START.0 as usize,
             RegionType::Reserved,
         ),
         // 256 MiB ~ 768 MiB: MMIO space
@@ -114,12 +103,20 @@ pub fn arch_memory_regions(size: GuestUsize) -> Vec<(GuestAddress, usize, Region
             layout::PCI_MMCONFIG_SIZE as usize,
             RegionType::Reserved,
         ),
-        // 1 GiB ~ : Ram
+        // 1GiB ~ 4032 MiB: RAM before the gap
         (
-            GuestAddress(layout::RAM_64BIT_START),
-            (size - ram_deduction) as usize,
+            layout::RAM_START,
+            layout::MEM_32BIT_RESERVED_START.unchecked_offset_from(layout::RAM_START) as usize,
             RegionType::Ram,
         ),
+        // 4GiB ~ inf: RAM after the gap
+        (layout::RAM_64BIT_START, usize::MAX, RegionType::Ram),
+        // Add the 32-bit reserved memory hole as a reserved region
+        (
+            layout::MEM_32BIT_RESERVED_START,
+            layout::MEM_32BIT_RESERVED_SIZE as usize,
+            RegionType::Reserved,
+        ),
     ]
 }
 
@@ -129,13 +126,14 @@ pub fn configure_system<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::Bui
     guest_mem: &GuestMemoryMmap,
     cmdline: &str,
     vcpu_mpidr: Vec<u64>,
-    vcpu_topology: Option<(u8, u8, u8)>,
+    vcpu_topology: Option<(u16, u16, u16, u16)>,
     device_info: &HashMap<(DeviceType, String), T, S>,
     initrd: &Option<super::InitramfsConfig>,
     pci_space_info: &[PciSpaceInfo],
     virtio_iommu_bdf: Option<u32>,
-    gic_device: &dyn GicDevice,
+    gic_device: &Arc<Mutex<dyn Vgic>>,
     numa_nodes: &NumaNodes,
+    pmu_supported: bool,
 ) -> super::Result<()> {
     let fdt_final = fdt::create_fdt(
         guest_mem,
@@ -148,6 +146,7 @@ pub fn configure_system<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::Bui
         pci_space_info,
         numa_nodes,
         virtio_iommu_bdf,
+        pmu_supported,
     )
     .map_err(|_| Error::SetupFdt)?;
 
@@ -174,33 +173,15 @@ pub fn initramfs_load_addr(
             if guest_mem.address_in_range(offset) {
                 Ok(offset.raw_value())
             } else {
-                Err(super::Error::AArch64Setup(Error::InitramfsAddress))
+                Err(super::Error::PlatformSpecific(Error::InitramfsAddress))
             }
         }
-        None => Err(super::Error::AArch64Setup(Error::InitramfsAddress)),
+        None => Err(super::Error::PlatformSpecific(Error::InitramfsAddress)),
     }
 }
 
-/// Returns the memory address where the kernel could be loaded.
-pub fn get_kernel_start() -> u64 {
-    layout::KERNEL_START
-}
-
-///Return guest memory address where the uefi should be loaded.
-pub fn get_uefi_start() -> u64 {
-    layout::UEFI_START
-}
-
-// Auxiliary function to get the address where the device tree blob is loaded.
-fn get_fdt_addr() -> u64 {
-    layout::FDT_START
-}
-
-pub fn get_host_cpu_phys_bits() -> u8 {
-    // A dummy hypervisor created only for querying the host IPA size and will
-    // be freed after the query.
-    let hv = hypervisor::new().unwrap();
-    let host_cpu_phys_bits = hv.get_host_ipa_limit().try_into().unwrap();
+pub fn get_host_cpu_phys_bits(hypervisor: &Arc<dyn hypervisor::Hypervisor>) -> u8 {
+    let host_cpu_phys_bits = hypervisor.get_host_ipa_limit().try_into().unwrap();
     if host_cpu_phys_bits == 0 {
         // Host kernel does not support `get_host_ipa_limit`,
         // we return the default value 40 here.
@@ -216,10 +197,11 @@ mod tests {
 
     #[test]
     fn test_arch_memory_regions_dram() {
-        let regions = arch_memory_regions((1usize << 32) as u64); //4GB
-        assert_eq!(5, regions.len());
-        assert_eq!(GuestAddress(layout::RAM_64BIT_START), regions[4].0);
-        assert_eq!(1usize << 32, regions[4].1);
+        let regions = arch_memory_regions();
+        assert_eq!(6, regions.len());
+        assert_eq!(layout::RAM_START, regions[3].0);
+        assert_eq!(RegionType::Ram, regions[3].2);
+        assert_eq!(RegionType::Reserved, regions[5].2);
         assert_eq!(RegionType::Ram, regions[4].2);
     }
 }

arch/src/aarch64/regs.rs

@@ -1,75 +0,0 @@
-// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Portions Copyright 2017 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 THIRD-PARTY file.
-
-use super::get_fdt_addr;
-use hypervisor::kvm::kvm_bindings::{
-    kvm_regs, user_pt_regs, KVM_REG_ARM64, KVM_REG_ARM_CORE, KVM_REG_SIZE_U64,
-};
-use hypervisor::{arm64_core_reg_id, offset__of};
-use std::sync::Arc;
-use std::{mem, result};
-
-/// Errors thrown while setting aarch64 registers.
-#[derive(Debug)]
-pub enum Error {
-    /// Failed to set core register (PC, PSTATE or general purpose ones).
-    SetCoreRegister(hypervisor::HypervisorCpuError),
-    /// Failed to get a system register.
-    GetSysRegister(hypervisor::HypervisorCpuError),
-}
-type Result<T> = result::Result<T, Error>;
-
-#[allow(non_upper_case_globals)]
-// PSR (Processor State Register) bits.
-// Taken from arch/arm64/include/uapi/asm/ptrace.h.
-const PSR_MODE_EL1h: u64 = 0x0000_0005;
-const PSR_F_BIT: u64 = 0x0000_0040;
-const PSR_I_BIT: u64 = 0x0000_0080;
-const PSR_A_BIT: u64 = 0x0000_0100;
-const PSR_D_BIT: u64 = 0x0000_0200;
-// Taken from arch/arm64/kvm/inject_fault.c.
-const PSTATE_FAULT_BITS_64: u64 = PSR_MODE_EL1h | PSR_A_BIT | PSR_F_BIT | PSR_I_BIT | PSR_D_BIT;
-
-/// Configure core registers for a given CPU.
-///
-/// # Arguments
-///
-/// * `vcpu` - Structure for the VCPU that holds the VCPU's fd.
-/// * `cpu_id` - Index of current vcpu.
-/// * `boot_ip` - Starting instruction pointer.
-/// * `mem` - Reserved DRAM for current VM.
-pub fn setup_regs(vcpu: &Arc<dyn hypervisor::Vcpu>, cpu_id: u8, boot_ip: u64) -> Result<()> {
-    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;
-    vcpu.set_reg(
-        arm64_core_reg_id!(KVM_REG_SIZE_U64, pstate),
-        PSTATE_FAULT_BITS_64,
-    )
-    .map_err(Error::SetCoreRegister)?;
-
-    // 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;
-        vcpu.set_reg(arm64_core_reg_id!(KVM_REG_SIZE_U64, pc), boot_ip as u64)
-            .map_err(Error::SetCoreRegister)?;
-
-        // Last mandatory thing to set -> the address pointing to the FDT (also called DTB).
-        // "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;
-        vcpu.set_reg(
-            arm64_core_reg_id!(KVM_REG_SIZE_U64, regs0),
-            get_fdt_addr() as u64,
-        )
-        .map_err(Error::SetCoreRegister)?;
-    }
-    Ok(())
-}

arch/src/aarch64/uefi.rs

@@ -1,19 +1,28 @@
 // Copyright 2020 Arm Limited (or its affiliates). All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
 
 use std::io::{Read, Seek, SeekFrom};
+use std::os::fd::AsFd;
 use std::result;
-use vm_memory::{Bytes, GuestAddress, GuestMemory};
+
+use thiserror::Error;
+use vm_memory::{GuestAddress, GuestMemory};
 
 /// Errors thrown while loading UEFI binary
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum Error {
     /// Unable to seek to UEFI image start.
+    #[error("Unable to seek to UEFI image start")]
     SeekUefiStart,
     /// Unable to seek to UEFI image end.
+    #[error("Unable to seek to UEFI image end")]
     SeekUefiEnd,
     /// UEFI image too big.
+    #[error("UEFI image too big")]
     UefiTooBig,
     /// Unable to read UEFI image
+    #[error("Unable to read UEFI image")]
     ReadUefiImage,
 }
 type Result<T> = result::Result<T, Error>;
@@ -24,7 +33,7 @@ pub fn load_uefi<F, M: GuestMemory>(
     uefi_image: &mut F,
 ) -> Result<()>
 where
-    F: Read + Seek,
+    F: Read + Seek + AsFd,
 {
     let uefi_size = uefi_image
         .seek(SeekFrom::End(0))
@@ -34,10 +43,8 @@ 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)
+        .read_exact_volatile_from(guest_addr, &mut uefi_image.as_fd(), uefi_size)
         .map_err(|_| Error::ReadUefiImage)
 }

arch/src/lib.rs

@@ -1,3 +1,4 @@
+// Copyright © 2024 Institute of Software, CAS. All rights reserved.
 // Copyright 2020 Arm Limited (or its affiliates). All rights reserved.
 // Copyright © 2020, Oracle and/or its affiliates.
 //
@@ -5,60 +6,58 @@
 // SPDX-License-Identifier: Apache-2.0
 
 //! Implements platform specific functionality.
-//! Supported platforms: x86_64, aarch64.
+//! Supported platforms: x86_64, aarch64, riscv64.
 
 #[macro_use]
 extern crate log;
-#[macro_use]
-extern crate serde_derive;
 
-#[cfg(target_arch = "x86_64")]
-use crate::x86_64::SgxEpcSection;
 use std::collections::BTreeMap;
-use std::fmt;
-use std::result;
 use std::sync::Arc;
-use versionize::{VersionMap, Versionize, VersionizeError, VersionizeResult};
-use versionize_derive::Versionize;
-use vm_migration::VersionMapped;
+use std::{fmt, result};
+
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
 
 type GuestMemoryMmap = vm_memory::GuestMemoryMmap<vm_memory::bitmap::AtomicBitmap>;
 type GuestRegionMmap = vm_memory::GuestRegionMmap<vm_memory::bitmap::AtomicBitmap>;
 
 /// Type for returning error code.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum Error {
     #[cfg(target_arch = "x86_64")]
-    /// X86_64 specific error triggered during system configuration.
-    X86_64Setup(x86_64::Error),
+    #[error("Platform specific error (x86_64)")]
+    PlatformSpecific(#[from] x86_64::Error),
     #[cfg(target_arch = "aarch64")]
-    /// AArch64 specific error triggered during system configuration.
-    AArch64Setup(aarch64::Error),
-    /// The zero page extends past the end of guest_mem.
-    ZeroPagePastRamEnd,
-    /// Error writing the zero page of guest memory.
-    ZeroPageSetup(vm_memory::GuestMemoryError),
-    /// The memory map table extends past the end of guest memory.
+    #[error("Platform specific error (aarch64)")]
+    PlatformSpecific(#[from] aarch64::Error),
+    #[cfg(target_arch = "riscv64")]
+    #[error("Platform specific error (riscv64)")]
+    PlatformSpecific(#[from] riscv64::Error),
+    #[error("The memory map table extends past the end of guest memory")]
     MemmapTablePastRamEnd,
-    /// Error writing memory map table to guest memory.
+    #[error("Error writing memory map table to guest memory")]
     MemmapTableSetup,
-    /// The hvm_start_info structure extends past the end of guest memory.
+    #[error("The hvm_start_info structure extends past the end of guest memory")]
     StartInfoPastRamEnd,
-    /// Error writing hvm_start_info to guest memory.
+    #[error("Error writing hvm_start_info to guest memory")]
     StartInfoSetup,
-    /// Failed to compute initramfs address.
+    #[error("Failed to compute initramfs address")]
     InitramfsAddress,
-    /// Error writing module entry to guest memory.
-    ModlistSetup(vm_memory::GuestMemoryError),
-    /// RSDP Beyond Guest Memory
+    #[error("Error writing module entry to guest memory")]
+    ModlistSetup(#[source] vm_memory::GuestMemoryError),
+    #[error("RSDP extends past the end of guest memory")]
     RsdpPastRamEnd,
+    #[error("Failed to setup Zero Page for bzImage")]
+    ZeroPageSetup(#[source] vm_memory::GuestMemoryError),
+    #[error("Zero Page for bzImage past RAM end")]
+    ZeroPagePastRamEnd,
 }
 
 /// Type for returning public functions outcome.
 pub type Result<T> = result::Result<T, Error>;
 
 /// Type for memory region types.
-#[derive(Clone, Copy, PartialEq, Debug, Serialize, Deserialize, Versionize)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize)]
 pub enum RegionType {
     /// RAM type
     Ram,
@@ -76,17 +75,26 @@ pub enum RegionType {
     Reserved,
 }
 
-impl VersionMapped for RegionType {}
-
 /// Module for aarch64 related functionality.
 #[cfg(target_arch = "aarch64")]
 pub mod aarch64;
 
 #[cfg(target_arch = "aarch64")]
 pub use aarch64::{
-    arch_memory_regions, configure_system, configure_vcpu, fdt::DeviceInfoForFdt,
-    get_host_cpu_phys_bits, get_kernel_start, get_uefi_start, initramfs_load_addr, layout,
-    layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, uefi, EntryPoint,
+    _NSIG, EntryPoint, arch_memory_regions, configure_system, configure_vcpu,
+    fdt::DeviceInfoForFdt, get_host_cpu_phys_bits, initramfs_load_addr, layout,
+    layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, uefi,
+};
+
+/// Module for riscv64 related functionality.
+#[cfg(target_arch = "riscv64")]
+pub mod riscv64;
+
+#[cfg(target_arch = "riscv64")]
+pub use riscv64::{
+    _NSIG, EntryPoint, arch_memory_regions, configure_system, configure_vcpu,
+    fdt::DeviceInfoForFdt, get_host_cpu_phys_bits, initramfs_load_addr, layout,
+    layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, uefi,
 };
 
 #[cfg(target_arch = "x86_64")]
@@ -94,16 +102,16 @@ pub mod x86_64;
 
 #[cfg(target_arch = "x86_64")]
 pub use x86_64::{
-    arch_memory_regions, configure_system, configure_vcpu, generate_common_cpuid,
-    get_host_cpu_phys_bits, initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE,
-    layout::CMDLINE_START, regs, CpuidFeatureEntry, EntryPoint,
+    _NSIG, CpuidConfig, CpuidFeatureEntry, EntryPoint, arch_memory_regions, configure_system,
+    configure_vcpu, generate_common_cpuid, generate_ram_ranges, get_host_cpu_phys_bits,
+    initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE, layout::CMDLINE_START, regs,
 };
 
 /// Safe wrapper for `sysconf(_SC_PAGESIZE)`.
 #[cfg(target_arch = "x86_64")]
 #[inline(always)]
 fn pagesize() -> usize {
-    // Trivially safe
+    // SAFETY: Trivially safe
     unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
 }
 
@@ -111,11 +119,10 @@ fn pagesize() -> usize {
 pub struct NumaNode {
     pub memory_regions: Vec<Arc<GuestRegionMmap>>,
     pub hotplug_regions: Vec<Arc<GuestRegionMmap>>,
-    pub cpus: Vec<u8>,
+    pub cpus: Vec<u32>,
+    pub pci_segments: Vec<u16>,
     pub distances: BTreeMap<u32, u8>,
     pub memory_zones: Vec<String>,
-    #[cfg(target_arch = "x86_64")]
-    pub sgx_epc_sections: Vec<SgxEpcSection>,
 }
 
 pub type NumaNodes = BTreeMap<u32, NumaNode>;
@@ -134,7 +141,7 @@ pub enum DeviceType {
     /// Device Type: Virtio.
     Virtio(u32),
     /// Device Type: Serial.
-    #[cfg(target_arch = "aarch64")]
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     Serial,
     /// Device Type: RTC.
     #[cfg(target_arch = "aarch64")]
@@ -142,6 +149,9 @@ pub enum DeviceType {
     /// Device Type: GPIO.
     #[cfg(target_arch = "aarch64")]
     Gpio,
+    /// Device Type: fw_cfg.
+    #[cfg(feature = "fw_cfg")]
+    FwCfg,
 }
 
 /// Default (smallest) memory page size for the supported architectures.
@@ -149,21 +159,22 @@ 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:?}")
     }
 }
 
 /// Structure to describe MMIO device information
 #[derive(Clone, Debug)]
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 pub struct MmioDeviceInfo {
     pub addr: u64,
+    pub len: u64,
     pub irq: u32,
 }
 
 /// Structure to describe PCI space information
 #[derive(Clone, Debug)]
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 pub struct PciSpaceInfo {
     pub pci_segment_id: u16,
     pub mmio_config_address: u64,
@@ -171,7 +182,7 @@ pub struct PciSpaceInfo {
     pub pci_device_space_size: u64,
 }
 
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 impl DeviceInfoForFdt for MmioDeviceInfo {
     fn addr(&self) -> u64 {
         self.addr
@@ -180,6 +191,6 @@ impl DeviceInfoForFdt for MmioDeviceInfo {
         self.irq
     }
     fn length(&self) -> u64 {
-        4096
+        self.len
     }
 }

arch/src/riscv64/fdt.rs

@@ -0,0 +1,481 @@
+// Copyright © 2024 Institute of Software, CAS. All rights reserved.
+// Copyright 2020 Arm Limited (or its affiliates). All rights reserved.
+// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Portions Copyright 2017 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 THIRD-PARTY file.
+
+use std::collections::HashMap;
+use std::ffi::CStr;
+use std::fmt::Debug;
+use std::sync::{Arc, Mutex};
+use std::{cmp, result, str};
+
+use byteorder::{BigEndian, ByteOrder};
+use hypervisor::arch::riscv64::aia::Vaia;
+use thiserror::Error;
+use vm_fdt::{FdtWriter, FdtWriterResult};
+use vm_memory::{Address, Bytes, GuestMemory, GuestMemoryError, GuestMemoryRegion};
+
+use super::super::{DeviceType, GuestMemoryMmap, InitramfsConfig};
+use super::layout::{
+    IRQ_BASE, MEM_32BIT_DEVICES_SIZE, MEM_32BIT_DEVICES_START, MEM_PCI_IO_SIZE, MEM_PCI_IO_START,
+    PCI_HIGH_BASE, PCI_MMIO_CONFIG_SIZE_PER_SEGMENT,
+};
+use crate::PciSpaceInfo;
+
+const AIA_APLIC_PHANDLE: u32 = 1;
+const AIA_IMSIC_PHANDLE: u32 = 2;
+const CPU_INTC_BASE_PHANDLE: u32 = 3;
+const CPU_BASE_PHANDLE: u32 = 256 + CPU_INTC_BASE_PHANDLE;
+// Read the documentation specified when appending the root node to the FDT.
+const ADDRESS_CELLS: u32 = 0x2;
+const SIZE_CELLS: u32 = 0x2;
+
+// From https://elixir.bootlin.com/linux/v6.10/source/include/dt-bindings/interrupt-controller/irq.h#L14
+const _IRQ_TYPE_EDGE_RISING: u32 = 1;
+const IRQ_TYPE_LEVEL_HI: u32 = 4;
+
+const S_MODE_EXT_IRQ: u32 = 9;
+
+/// Trait for devices to be added to the Flattened Device Tree.
+pub trait DeviceInfoForFdt {
+    /// Returns the address where this device will be loaded.
+    fn addr(&self) -> u64;
+    /// Returns the associated interrupt for this device.
+    fn irq(&self) -> u32;
+    /// Returns the amount of memory that needs to be reserved for this device.
+    fn length(&self) -> u64;
+}
+
+/// Errors thrown while configuring the Flattened Device Tree for riscv64.
+#[derive(Debug, Error)]
+pub enum Error {
+    /// Failure in writing FDT in memory.
+    #[error("Failure in writing FDT in memory")]
+    WriteFdtToMemory(#[source] GuestMemoryError),
+}
+type Result<T> = result::Result<T, Error>;
+
+/// Creates the flattened device tree for this riscv64 VM.
+#[allow(clippy::too_many_arguments)]
+pub fn create_fdt<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
+    guest_mem: &GuestMemoryMmap,
+    cmdline: &str,
+    num_vcpu: u32,
+    device_info: &HashMap<(DeviceType, String), T, S>,
+    aia_device: &Arc<Mutex<dyn Vaia>>,
+    initrd: &Option<InitramfsConfig>,
+    pci_space_info: &[PciSpaceInfo],
+) -> FdtWriterResult<Vec<u8>> {
+    // Allocate stuff necessary for the holding the blob.
+    let mut fdt = FdtWriter::new()?;
+
+    // For an explanation why these nodes were introduced in the blob take a look at
+    // https://github.com/devicetree-org/devicetree-specification/releases/tag/v0.4
+    // In chapter 3.
+
+    // Header or the root node as per above mentioned documentation.
+    let root_node = fdt.begin_node("")?;
+    fdt.property_string("compatible", "linux,dummy-virt")?;
+    // For info on #address-cells and size-cells resort to Table 3.1 Root Node
+    // Properties
+    fdt.property_u32("#address-cells", ADDRESS_CELLS)?;
+    fdt.property_u32("#size-cells", SIZE_CELLS)?;
+    create_cpu_nodes(&mut fdt, num_vcpu)?;
+    create_memory_node(&mut fdt, guest_mem)?;
+    create_chosen_node(&mut fdt, cmdline, initrd)?;
+    create_aia_node(&mut fdt, aia_device)?;
+    create_devices_node(&mut fdt, device_info)?;
+    create_pci_nodes(&mut fdt, pci_space_info)?;
+
+    // End Header node.
+    fdt.end_node(root_node)?;
+
+    let fdt_final = fdt.finish()?;
+
+    Ok(fdt_final)
+}
+
+pub fn write_fdt_to_memory(fdt_final: Vec<u8>, guest_mem: &GuestMemoryMmap) -> Result<()> {
+    // Write FDT to memory.
+    guest_mem
+        .write_slice(fdt_final.as_slice(), super::layout::FDT_START)
+        .map_err(Error::WriteFdtToMemory)?;
+    Ok(())
+}
+
+// Following are the auxiliary function for creating the different nodes that we append to our FDT.
+fn create_cpu_nodes(fdt: &mut FdtWriter, num_cpus: u32) -> FdtWriterResult<()> {
+    // See https://elixir.bootlin.com/linux/v6.10/source/Documentation/devicetree/bindings/riscv/cpus.yaml
+    let cpus = fdt.begin_node("cpus")?;
+    // As per documentation, on RISC-V 64-bit systems value should be set to 1.
+    fdt.property_u32("#address-cells", 0x01)?;
+    fdt.property_u32("#size-cells", 0x0)?;
+    // TODO: Retrieve CPU frequency from cpu timer regs
+    let timebase_frequency: u32 = 0x989680;
+    fdt.property_u32("timebase-frequency", timebase_frequency)?;
+
+    for cpu_index in 0..num_cpus {
+        let cpu = fdt.begin_node(&format!("cpu@{cpu_index:x}"))?;
+        fdt.property_string("device_type", "cpu")?;
+        fdt.property_string("compatible", "riscv")?;
+        fdt.property_string("mmu-type", "sv48")?;
+        fdt.property_string("riscv,isa", "rv64imafdc_smaia_ssaia")?;
+        fdt.property_string("status", "okay")?;
+        fdt.property_u32("reg", cpu_index)?;
+        fdt.property_u32("phandle", CPU_BASE_PHANDLE + cpu_index)?;
+
+        // interrupt controller node
+        let intc_node = fdt.begin_node("interrupt-controller")?;
+        fdt.property_string("compatible", "riscv,cpu-intc")?;
+        fdt.property_u32("#interrupt-cells", 1u32)?;
+        fdt.property_null("interrupt-controller")?;
+        fdt.property_u32("phandle", CPU_INTC_BASE_PHANDLE + cpu_index)?;
+        fdt.end_node(intc_node)?;
+
+        fdt.end_node(cpu)?;
+    }
+
+    fdt.end_node(cpus)?;
+
+    Ok(())
+}
+
+fn create_memory_node(fdt: &mut FdtWriter, guest_mem: &GuestMemoryMmap) -> FdtWriterResult<()> {
+    // Note: memory regions from "GuestMemory" are sorted and non-zero sized.
+    let ram_regions = {
+        let mut ram_regions = Vec::new();
+        let mut current_start = guest_mem
+            .iter()
+            .next()
+            .map(GuestMemoryRegion::start_addr)
+            .expect("GuestMemory must have one memory region at least")
+            .raw_value();
+        let mut current_end = current_start;
+
+        for (start, size) in guest_mem
+            .iter()
+            .map(|m| (m.start_addr().raw_value(), m.len()))
+        {
+            if current_end == start {
+                // This zone is continuous with the previous one.
+                current_end += size;
+            } else {
+                ram_regions.push((current_start, current_end));
+
+                current_start = start;
+                current_end = start + size;
+            }
+        }
+
+        ram_regions.push((current_start, current_end));
+
+        ram_regions
+    };
+
+    let mut mem_reg_property = Vec::new();
+    for region in ram_regions {
+        let mem_size = region.1 - region.0;
+        mem_reg_property.push(region.0);
+        mem_reg_property.push(mem_size);
+    }
+
+    let ram_start = super::layout::RAM_START.raw_value();
+    let memory_node_name = format!("memory@{ram_start:x}");
+    let memory_node = fdt.begin_node(&memory_node_name)?;
+    fdt.property_string("device_type", "memory")?;
+    fdt.property_array_u64("reg", &mem_reg_property)?;
+    fdt.end_node(memory_node)?;
+
+    Ok(())
+}
+
+fn create_chosen_node(
+    fdt: &mut FdtWriter,
+    cmdline: &str,
+    initrd: &Option<InitramfsConfig>,
+) -> FdtWriterResult<()> {
+    let chosen_node = fdt.begin_node("chosen")?;
+    fdt.property_string("bootargs", cmdline)?;
+
+    if let Some(initrd_config) = initrd {
+        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)?;
+    }
+
+    fdt.end_node(chosen_node)?;
+
+    Ok(())
+}
+
+fn create_aia_node(fdt: &mut FdtWriter, aia_device: &Arc<Mutex<dyn Vaia>>) -> FdtWriterResult<()> {
+    // IMSIC
+    if aia_device.lock().unwrap().msi_compatible() {
+        use super::layout::IMSIC_START;
+        let imsic_name = format!("imsics@{:x}", IMSIC_START.0);
+        let imsic_node = fdt.begin_node(&imsic_name)?;
+
+        fdt.property_string(
+            "compatible",
+            aia_device.lock().unwrap().imsic_compatibility(),
+        )?;
+        let imsic_reg_prop = aia_device.lock().unwrap().imsic_properties();
+        fdt.property_array_u32("reg", &imsic_reg_prop)?;
+        fdt.property_u32("#interrupt-cells", 0u32)?;
+        fdt.property_null("interrupt-controller")?;
+        fdt.property_null("msi-controller")?;
+        // TODO complete num-ids
+        fdt.property_u32("riscv,num-ids", 2047u32)?;
+        fdt.property_u32("phandle", AIA_IMSIC_PHANDLE)?;
+
+        let mut irq_cells = Vec::new();
+        let num_cpus = aia_device.lock().unwrap().vcpu_count();
+        for i in 0..num_cpus {
+            irq_cells.push(CPU_INTC_BASE_PHANDLE + i);
+            irq_cells.push(S_MODE_EXT_IRQ);
+        }
+        fdt.property_array_u32("interrupts-extended", &irq_cells)?;
+
+        fdt.end_node(imsic_node)?;
+    }
+
+    // APLIC
+    use super::layout::APLIC_START;
+    let aplic_name = format!("aplic@{:x}", APLIC_START.0);
+    let aplic_node = fdt.begin_node(&aplic_name)?;
+
+    fdt.property_string(
+        "compatible",
+        aia_device.lock().unwrap().aplic_compatibility(),
+    )?;
+    let reg_cells = aia_device.lock().unwrap().aplic_properties();
+    fdt.property_array_u32("reg", &reg_cells)?;
+    fdt.property_u32("#interrupt-cells", 2u32)?;
+    fdt.property_null("interrupt-controller")?;
+    // TODO complete num-srcs
+    fdt.property_u32("riscv,num-sources", 96u32)?;
+    fdt.property_u32("phandle", AIA_APLIC_PHANDLE)?;
+    fdt.property_u32("msi-parent", AIA_IMSIC_PHANDLE)?;
+
+    fdt.end_node(aplic_node)?;
+
+    Ok(())
+}
+
+fn create_serial_node<T: DeviceInfoForFdt + Clone + Debug>(
+    fdt: &mut FdtWriter,
+    dev_info: &T,
+) -> FdtWriterResult<()> {
+    let serial_reg_prop = [dev_info.addr(), dev_info.length()];
+    let irq = [dev_info.irq() - IRQ_BASE, IRQ_TYPE_LEVEL_HI];
+
+    let serial_node = fdt.begin_node(&format!("serial@{:x}", dev_info.addr()))?;
+    fdt.property_string("compatible", "ns16550a")?;
+    fdt.property_array_u64("reg", &serial_reg_prop)?;
+    fdt.property_u32("clock-frequency", 3686400)?;
+    fdt.property_u32("interrupt-parent", AIA_APLIC_PHANDLE)?;
+    fdt.property_array_u32("interrupts", &irq)?;
+    fdt.end_node(serial_node)?;
+
+    Ok(())
+}
+
+fn create_devices_node<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
+    fdt: &mut FdtWriter,
+    dev_info: &HashMap<(DeviceType, String), T, S>,
+) -> FdtWriterResult<()> {
+    for ((device_type, _device_id), info) in dev_info {
+        match device_type {
+            DeviceType::Serial => create_serial_node(fdt, info)?,
+            DeviceType::Virtio(_) => unreachable!(),
+        }
+    }
+
+    Ok(())
+}
+
+fn create_pci_nodes(fdt: &mut FdtWriter, pci_device_info: &[PciSpaceInfo]) -> FdtWriterResult<()> {
+    // Add node for PCIe controller.
+    // See Documentation/devicetree/bindings/pci/host-generic-pci.txt in the kernel
+    // and https://elinux.org/Device_Tree_Usage.
+    // In multiple PCI segments setup, each PCI segment needs a PCI node.
+    for pci_device_info_elem in pci_device_info.iter() {
+        // EDK2 requires the PCIe high space above 4G address.
+        // The actual space in CLH follows the RAM. If the RAM space is small, the PCIe high space
+        // could fall below 4G.
+        // Here we cut off PCI device space below 8G in FDT to workaround the EDK2 check.
+        // But the address written in ACPI is not impacted.
+        let (pci_device_base_64bit, pci_device_size_64bit) =
+            if pci_device_info_elem.pci_device_space_start < PCI_HIGH_BASE.raw_value() {
+                (
+                    PCI_HIGH_BASE.raw_value(),
+                    pci_device_info_elem.pci_device_space_size
+                        - (PCI_HIGH_BASE.raw_value() - pci_device_info_elem.pci_device_space_start),
+                )
+            } else {
+                (
+                    pci_device_info_elem.pci_device_space_start,
+                    pci_device_info_elem.pci_device_space_size,
+                )
+            };
+        // There is no specific requirement of the 32bit MMIO range, and
+        // therefore at least we can make these ranges 4K aligned.
+        let pci_device_size_32bit: u64 =
+            MEM_32BIT_DEVICES_SIZE / ((1 << 12) * pci_device_info.len() as u64) * (1 << 12);
+        let pci_device_base_32bit: u64 = MEM_32BIT_DEVICES_START.0
+            + pci_device_size_32bit * pci_device_info_elem.pci_segment_id as u64;
+
+        let ranges = [
+            // io addresses. Since AArch64 will not use IO address,
+            // we can set the same IO address range for every segment.
+            0x1000000,
+            0_u32,
+            0_u32,
+            (MEM_PCI_IO_START.0 >> 32) as u32,
+            MEM_PCI_IO_START.0 as u32,
+            (MEM_PCI_IO_SIZE >> 32) as u32,
+            MEM_PCI_IO_SIZE as u32,
+            // mmio addresses
+            0x2000000,                            // (ss = 10: 32-bit memory space)
+            (pci_device_base_32bit >> 32) as u32, // PCI address
+            pci_device_base_32bit as u32,
+            (pci_device_base_32bit >> 32) as u32, // CPU address
+            pci_device_base_32bit as u32,
+            (pci_device_size_32bit >> 32) as u32, // size
+            pci_device_size_32bit as u32,
+            // device addresses
+            0x3000000,                            // (ss = 11: 64-bit memory space)
+            (pci_device_base_64bit >> 32) as u32, // PCI address
+            pci_device_base_64bit as u32,
+            (pci_device_base_64bit >> 32) as u32, // CPU address
+            pci_device_base_64bit as u32,
+            (pci_device_size_64bit >> 32) as u32, // size
+            pci_device_size_64bit as u32,
+        ];
+        let bus_range = [0, 0]; // Only bus 0
+        let reg = [
+            pci_device_info_elem.mmio_config_address,
+            PCI_MMIO_CONFIG_SIZE_PER_SEGMENT,
+        ];
+        // See kernel document Documentation/devicetree/bindings/pci/pci-msi.txt
+        let msi_map = [
+            // rid-base: A single cell describing the first RID matched by the entry.
+            0x0,
+            // msi-controller: A single phandle to an MSI controller.
+            AIA_IMSIC_PHANDLE,
+            // msi-base: An msi-specifier describing the msi-specifier produced for the
+            // first RID matched by the entry.
+            (pci_device_info_elem.pci_segment_id as u32) << 8,
+            // length: A single cell describing how many consecutive RIDs are matched
+            // following the rid-base.
+            0x100,
+        ];
+
+        let pci_node_name = format!("pci@{:x}", pci_device_info_elem.mmio_config_address);
+        let pci_node = fdt.begin_node(&pci_node_name)?;
+
+        fdt.property_string("compatible", "pci-host-ecam-generic")?;
+        fdt.property_string("device_type", "pci")?;
+        fdt.property_array_u32("ranges", &ranges)?;
+        fdt.property_array_u32("bus-range", &bus_range)?;
+        fdt.property_u32(
+            "linux,pci-domain",
+            pci_device_info_elem.pci_segment_id as u32,
+        )?;
+        fdt.property_u32("#address-cells", 3)?;
+        fdt.property_u32("#size-cells", 2)?;
+        fdt.property_array_u64("reg", &reg)?;
+        fdt.property_u32("#interrupt-cells", 1)?;
+        fdt.property_null("interrupt-map")?;
+        fdt.property_null("interrupt-map-mask")?;
+        fdt.property_null("dma-coherent")?;
+        fdt.property_array_u32("msi-map", &msi_map)?;
+        fdt.property_u32("msi-parent", AIA_IMSIC_PHANDLE)?;
+
+        fdt.end_node(pci_node)?;
+    }
+
+    Ok(())
+}
+
+// Parse the DTB binary and print for debugging
+pub fn print_fdt(dtb: &[u8]) {
+    match fdt_parser::Fdt::new(dtb) {
+        Ok(fdt) => {
+            if let Some(root) = fdt.find_node("/") {
+                debug!("Printing the FDT:");
+                print_node(root, 0);
+            } else {
+                debug!("Failed to find root node in FDT for debugging.");
+            }
+        }
+        Err(_) => debug!("Failed to parse FDT for debugging."),
+    }
+}
+
+fn print_node(node: fdt_parser::node::FdtNode<'_, '_>, n_spaces: usize) {
+    debug!("{:indent$}{}/", "", node.name, indent = n_spaces);
+    for property in node.properties() {
+        let name = property.name;
+
+        // If the property is 'compatible', its value requires special handling.
+        // The u8 array could contain multiple null-terminated strings.
+        // We copy the original array and simply replace all 'null' characters with spaces.
+        let value = if name == "compatible" {
+            let mut compatible = vec![0u8; 256];
+            let handled_value = property
+                .value
+                .iter()
+                .map(|&c| if c == 0 { b' ' } else { c })
+                .collect::<Vec<_>>();
+            let len = cmp::min(255, handled_value.len());
+            compatible[..len].copy_from_slice(&handled_value[..len]);
+            compatible[..(len + 1)].to_vec()
+        } else {
+            property.value.to_vec()
+        };
+        let value = &value;
+
+        // Now the value can be either:
+        //   - A null-terminated C string, or
+        //   - Binary data
+        // We follow a very simple logic to present the value:
+        //   - At first, try to convert it to CStr and print,
+        //   - If failed, print it as u32 array.
+        let value_result = match CStr::from_bytes_with_nul(value) {
+            Ok(value_cstr) => value_cstr.to_str().ok(),
+            Err(_e) => None,
+        };
+
+        if let Some(value_str) = value_result {
+            debug!(
+                "{:indent$}{} : {:#?}",
+                "",
+                name,
+                value_str,
+                indent = (n_spaces + 2)
+            );
+        } else {
+            let mut array = Vec::with_capacity(256);
+            array.resize(value.len() / 4, 0u32);
+            BigEndian::read_u32_into(value, &mut array);
+            debug!(
+                "{:indent$}{} : {:X?}",
+                "",
+                name,
+                array,
+                indent = (n_spaces + 2)
+            );
+        };
+    }
+
+    // Print children nodes if there is any
+    for child in node.children() {
+        print_node(child, n_spaces + 2);
+    }
+}

arch/src/riscv64/layout.rs

@@ -0,0 +1,112 @@
+// Copyright © 2024 Institute of Software, CAS. All rights reserved.
+// Copyright 2020 Arm Limited (or its affiliates). All rights reserved.
+// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+//
+// Memory layout of RISC-V 64-bit guest:
+//
+// Physical  +---------------------------------------------------------------+
+// address   |                                                               |
+// end       |                                                               |
+//           ~                   ~                       ~                   ~
+//           |                                                               |
+//           |                    Highmem PCI MMIO space                     |
+//           |                                                               |
+// RAM end   +---------------------------------------------------------------+
+// (dynamic, |                                                               |
+// including |                                                               |
+// hotplug   ~                   ~                       ~                   ~
+// memory)   |                                                               |
+//           |                             DRAM                              |
+//           |                                                               |
+//           |                                                               |
+//           |                                                               |
+//           |                                                               |
+//    1 GB   +---------------------------------------------------------------+
+//           |                                                               |
+//           |                      PCI MMCONFIG space                       |
+//           |                                                               |
+//  768 MB   +---------------------------------------------------------------+
+//           |                                                               |
+//           |                                                               |
+//           |                        PCI MMIO space                         |
+//           |                                                               |
+//  256 MB   +---------------------------------------------------------------|
+//           |                                                               |
+//           |                     Legacy devices space                      |
+//           |                                                               |
+//  128 MB   +---------------------------------------------------------------|
+//           |                                                               |
+//           |                            IMSICs                             |
+//           |                                                               |
+//   64 MB   +---------------------------------------------------------------+
+//           |                                                               |
+//           |                            APLICs                             |
+//           |                                                               |
+//    4 MB   +---------------------------------------------------------------+
+//           |                          UEFI flash                           |
+//    0 GB   +---------------------------------------------------------------+
+//
+//
+
+use vm_memory::GuestAddress;
+
+/// 0x0 ~ 0x40_0000 (4 MiB) is reserved to UEFI
+/// UEFI binary size is required less than 3 MiB, reserving 4 MiB is enough.
+pub const UEFI_START: GuestAddress = GuestAddress(0);
+pub const UEFI_SIZE: u64 = 0x040_0000;
+
+/// AIA related devices
+/// See https://elixir.bootlin.com/linux/v6.10/source/arch/riscv/include/uapi/asm/kvm.h
+/// 0x40_0000 ~ 0x0400_0000 (64 MiB) resides APLICs
+pub const APLIC_START: GuestAddress = GuestAddress(0x40_0000);
+pub const APLIC_SIZE: u64 = 0x4000;
+
+/// 0x0400_0000 ~ 0x0800_0000 (64 MiB) resides IMSICs
+pub const IMSIC_START: GuestAddress = GuestAddress(0x0400_0000);
+pub const IMSIC_SIZE: u64 = 0x1000;
+
+/// Below this address will reside the AIA, above this address will reside the MMIO devices.
+const MAPPED_IO_START: GuestAddress = GuestAddress(0x0800_0000);
+
+/// Space 0x0800_0000 ~ 0x1000_0000 is reserved for legacy devices.
+pub const LEGACY_SERIAL_MAPPED_IO_START: GuestAddress = MAPPED_IO_START;
+
+/// Space 0x0905_0000 ~ 0x0906_0000 is reserved for pcie io address
+pub const MEM_PCI_IO_START: GuestAddress = GuestAddress(0x0905_0000);
+pub const MEM_PCI_IO_SIZE: u64 = 0x1_0000;
+
+/// Starting from 0x1000_0000 (256MiB) to 0x3000_0000 (768MiB) is used for PCIE MMIO
+pub const MEM_32BIT_DEVICES_START: GuestAddress = GuestAddress(0x1000_0000);
+pub const MEM_32BIT_DEVICES_SIZE: u64 = 0x2000_0000;
+
+/// PCI MMCONFIG space (start: after the device space at 768MiB, length: 256MiB)
+pub const PCI_MMCONFIG_START: GuestAddress = GuestAddress(0x3000_0000);
+pub const PCI_MMCONFIG_SIZE: u64 = 256 << 20;
+// One bus with potentially 256 devices (32 slots x 8 functions).
+pub const PCI_MMIO_CONFIG_SIZE_PER_SEGMENT: u64 = 4096 * 256;
+
+/// Start of RAM.
+pub const RAM_START: GuestAddress = GuestAddress(0x4000_0000);
+
+/// Kernel command line maximum size on RISC-V.
+/// See https://elixir.bootlin.com/linux/v6.10/source/arch/riscv/include/uapi/asm/setup.h
+pub const CMDLINE_MAX_SIZE: usize = 1024;
+
+/// FDT is at the beginning of RAM.
+pub const FDT_START: GuestAddress = RAM_START;
+pub const FDT_MAX_SIZE: u64 = 0x1_0000;
+
+/// Kernel start after FDT
+pub const KERNEL_START: GuestAddress = GuestAddress(RAM_START.0 + FDT_MAX_SIZE);
+
+/// Pci high memory base
+pub const PCI_HIGH_BASE: GuestAddress = GuestAddress(0x2_0000_0000);
+
+/// First usable interrupt on riscv64
+pub const IRQ_BASE: u32 = 0;
+
+// As per https://elixir.bootlin.com/linux/v6.10/source/arch/riscv/include/asm/kvm_host.h#L31
+/// Number of supported interrupts
+pub const IRQ_NUM: u32 = 1023;

arch/src/riscv64/mod.rs

@@ -0,0 +1,169 @@
+// Copyright © 2024 Institute of Software, CAS. All rights reserved.
+// Copyright 2020 Arm Limited (or its affiliates). All rights reserved.
+// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/// Module for the flattened device tree.
+pub mod fdt;
+/// Layout for this riscv64 system.
+pub mod layout;
+/// Module for loading UEFI binary.
+pub mod uefi;
+
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::sync::{Arc, Mutex};
+
+use hypervisor::arch::riscv64::aia::Vaia;
+use log::{Level, log_enabled};
+use thiserror::Error;
+use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic};
+
+pub use self::fdt::DeviceInfoForFdt;
+use crate::{DeviceType, GuestMemoryMmap, PciSpaceInfo, RegionType};
+
+pub const _NSIG: i32 = 65;
+
+/// Errors thrown while configuring riscv64 system.
+#[derive(Debug, Error)]
+pub enum Error {
+    /// Failed to create a FDT.
+    #[error("Failed to create a FDT")]
+    SetupFdt,
+
+    /// Failed to write FDT to memory.
+    #[error("Failed to write FDT to memory")]
+    WriteFdtToMemory(#[source] fdt::Error),
+
+    /// Failed to create a AIA.
+    #[error("Failed to create a AIA")]
+    SetupAia,
+
+    /// Failed to compute the initramfs address.
+    #[error("Failed to compute the initramfs address")]
+    InitramfsAddress,
+
+    /// Error configuring the general purpose registers
+    #[error("Error configuring the general purpose registers")]
+    RegsConfiguration(#[source] hypervisor::HypervisorCpuError),
+}
+
+#[derive(Debug, Copy, Clone)]
+/// Specifies the entry point address where the guest must start
+/// executing code.
+pub struct EntryPoint {
+    /// Address in guest memory where the guest must start execution
+    pub entry_addr: GuestAddress,
+}
+
+/// Configure the specified VCPU, and return its MPIDR.
+pub fn configure_vcpu(
+    vcpu: &Arc<dyn hypervisor::Vcpu>,
+    id: u32,
+    boot_setup: Option<(EntryPoint, &GuestMemoryAtomic<GuestMemoryMmap>)>,
+) -> super::Result<()> {
+    if let Some((kernel_entry_point, _guest_memory)) = boot_setup {
+        vcpu.setup_regs(
+            id,
+            kernel_entry_point.entry_addr.raw_value(),
+            layout::FDT_START.raw_value(),
+        )
+        .map_err(Error::RegsConfiguration)?;
+    }
+
+    Ok(())
+}
+
+pub fn arch_memory_regions() -> Vec<(GuestAddress, usize, RegionType)> {
+    vec![
+        // 0 MiB ~ 256 MiB: AIA and legacy devices
+        (
+            GuestAddress(0),
+            layout::MEM_32BIT_DEVICES_START.0 as usize,
+            RegionType::Reserved,
+        ),
+        // 256 MiB ~ 768 MiB: MMIO space
+        (
+            layout::MEM_32BIT_DEVICES_START,
+            layout::MEM_32BIT_DEVICES_SIZE as usize,
+            RegionType::SubRegion,
+        ),
+        // 768 MiB ~ 1 GiB: reserved. The leading 256M for PCIe MMCONFIG space
+        (
+            layout::PCI_MMCONFIG_START,
+            layout::PCI_MMCONFIG_SIZE as usize,
+            RegionType::Reserved,
+        ),
+        // 1GiB ~ inf: RAM
+        (layout::RAM_START, usize::MAX, RegionType::Ram),
+    ]
+}
+
+/// Configures the system and should be called once per vm before starting vcpu threads.
+#[allow(clippy::too_many_arguments)]
+pub fn configure_system<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
+    guest_mem: &GuestMemoryMmap,
+    cmdline: &str,
+    num_vcpu: u32,
+    device_info: &HashMap<(DeviceType, String), T, S>,
+    initrd: &Option<super::InitramfsConfig>,
+    pci_space_info: &[PciSpaceInfo],
+    aia_device: &Arc<Mutex<dyn Vaia>>,
+) -> super::Result<()> {
+    let fdt_final = fdt::create_fdt(
+        guest_mem,
+        cmdline,
+        num_vcpu,
+        device_info,
+        aia_device,
+        initrd,
+        pci_space_info,
+    )
+    .map_err(|_| Error::SetupFdt)?;
+
+    if log_enabled!(Level::Debug) {
+        fdt::print_fdt(&fdt_final);
+    }
+
+    fdt::write_fdt_to_memory(fdt_final, guest_mem).map_err(Error::WriteFdtToMemory)?;
+
+    Ok(())
+}
+
+/// Returns the memory address where the initramfs could be loaded.
+pub fn initramfs_load_addr(
+    guest_mem: &GuestMemoryMmap,
+    initramfs_size: usize,
+) -> super::Result<u64> {
+    let round_to_pagesize = |size| (size + (super::PAGE_SIZE - 1)) & !(super::PAGE_SIZE - 1);
+    match guest_mem
+        .last_addr()
+        .checked_sub(round_to_pagesize(initramfs_size) as u64 - 1)
+    {
+        Some(offset) => {
+            if guest_mem.address_in_range(offset) {
+                Ok(offset.raw_value())
+            } else {
+                Err(super::Error::PlatformSpecific(Error::InitramfsAddress))
+            }
+        }
+        None => Err(super::Error::PlatformSpecific(Error::InitramfsAddress)),
+    }
+}
+
+pub fn get_host_cpu_phys_bits(_hypervisor: &Arc<dyn hypervisor::Hypervisor>) -> u8 {
+    40
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_arch_memory_regions_dram() {
+        let regions = arch_memory_regions();
+        assert_eq!(4, regions.len());
+        assert_eq!(layout::RAM_START, regions[3].0);
+        assert_eq!(RegionType::Ram, regions[3].2);
+    }
+}

arch/src/riscv64/uefi.rs

@@ -0,0 +1,50 @@
+// Copyright 2020 Arm Limited (or its affiliates). All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+use std::io::{Read, Seek, SeekFrom};
+use std::os::fd::AsFd;
+use std::result;
+
+use thiserror::Error;
+use vm_memory::{GuestAddress, GuestMemory};
+
+/// Errors thrown while loading UEFI binary
+#[derive(Debug, Error)]
+pub enum Error {
+    /// Unable to seek to UEFI image start.
+    #[error("Unable to seek to UEFI image start")]
+    SeekUefiStart,
+    /// Unable to seek to UEFI image end.
+    #[error("Unable to seek to UEFI image end")]
+    SeekUefiEnd,
+    /// UEFI image too big.
+    #[error("UEFI image too big")]
+    UefiTooBig,
+    /// Unable to read UEFI image
+    #[error("Unable to read UEFI image")]
+    ReadUefiImage,
+}
+type Result<T> = result::Result<T, Error>;
+
+pub fn load_uefi<F, M: GuestMemory>(
+    guest_mem: &M,
+    guest_addr: GuestAddress,
+    uefi_image: &mut F,
+) -> Result<()>
+where
+    F: Read + Seek + AsFd,
+{
+    let uefi_size = uefi_image
+        .seek(SeekFrom::End(0))
+        .map_err(|_| Error::SeekUefiEnd)? as usize;
+
+    // edk2 image on virtual platform is smaller than 3M
+    if uefi_size > 0x300000 {
+        return Err(Error::UefiTooBig);
+    }
+    uefi_image.rewind().map_err(|_| Error::SeekUefiStart)?;
+    guest_mem
+        .read_exact_volatile_from(guest_addr, &mut uefi_image.as_fd(), uefi_size)
+        .map_err(|_| Error::ReadUefiImage)
+}

arch/src/x86_64/interrupts.rs

@@ -5,10 +5,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
-use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
-use hypervisor::x86_64::LapicState;
-use std::io::Cursor;
-use std::mem;
 use std::result;
 use std::sync::Arc;
 
@@ -20,32 +16,6 @@ pub const APIC_LVT1: usize = 0x360;
 pub const APIC_MODE_NMI: u32 = 0x4;
 pub const APIC_MODE_EXTINT: u32 = 0x7;
 
-pub fn get_klapic_reg(klapic: &LapicState, reg_offset: usize) -> u32 {
-    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).
-        mem::transmute::<&[i8], &[u8]>(&klapic.regs[reg_offset..])
-    };
-    let mut reader = Cursor::new(sliceu8);
-    // Following call can't fail if the offsets defined above are correct.
-    reader
-        .read_u32::<LittleEndian>()
-        .expect("Failed to read klapic register")
-}
-
-pub fn set_klapic_reg(klapic: &mut LapicState, reg_offset: usize, value: u32) {
-    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).
-        mem::transmute::<&mut [i8], &mut [u8]>(&mut klapic.regs[reg_offset..])
-    };
-    let mut writer = Cursor::new(sliceu8);
-    // Following call can't fail if the offsets defined above are correct.
-    writer
-        .write_u32::<LittleEndian>(value)
-        .expect("Failed to write klapic register")
-}
-
 pub fn set_apic_delivery_mode(reg: u32, mode: u32) -> u32 {
     ((reg) & !0x700) | ((mode) << 8)
 }
@@ -57,42 +27,13 @@ pub fn set_apic_delivery_mode(reg: u32, mode: u32) -> u32 {
 pub fn set_lint(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
     let mut klapic = vcpu.get_lapic()?;
 
-    let lvt_lint0 = get_klapic_reg(&klapic, APIC_LVT0);
-    set_klapic_reg(
-        &mut klapic,
+    let lvt_lint0 = klapic.get_klapic_reg(APIC_LVT0);
+    klapic.set_klapic_reg(
         APIC_LVT0,
         set_apic_delivery_mode(lvt_lint0, APIC_MODE_EXTINT),
     );
-    let lvt_lint1 = get_klapic_reg(&klapic, APIC_LVT1);
-    set_klapic_reg(
-        &mut klapic,
-        APIC_LVT1,
-        set_apic_delivery_mode(lvt_lint1, APIC_MODE_NMI),
-    );
+    let lvt_lint1 = klapic.get_klapic_reg(APIC_LVT1);
+    klapic.set_klapic_reg(APIC_LVT1, set_apic_delivery_mode(lvt_lint1, APIC_MODE_NMI));
 
     vcpu.set_lapic(&klapic)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const KVM_APIC_REG_SIZE: usize = 0x400;
-
-    #[test]
-    fn test_set_and_get_klapic_reg() {
-        let reg_offset = 0x340;
-        let mut klapic = LapicState::default();
-        set_klapic_reg(&mut klapic, reg_offset, 3);
-        let value = get_klapic_reg(&klapic, reg_offset);
-        assert_eq!(value, 3);
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_set_and_get_klapic_out_of_bounds() {
-        let reg_offset = KVM_APIC_REG_SIZE + 10;
-        let mut klapic = LapicState::default();
-        set_klapic_reg(&mut klapic, reg_offset, 3);
-    }
-}

arch/src/x86_64/layout.rs

@@ -24,6 +24,9 @@ pub const LOW_RAM_START: GuestAddress = GuestAddress(0x0);
 
 // == Fixed addresses within the "Low RAM" range: ==
 
+// Location of EBDA address
+pub const EBDA_POINTER: GuestAddress = GuestAddress(0x40e);
+
 // Initial GDT/IDT needed to boot kernel
 pub const BOOT_GDT_START: GuestAddress = GuestAddress(0x500);
 pub const BOOT_IDT_START: GuestAddress = GuestAddress(0x520);
@@ -104,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;

arch/src/x86_64/mpspec.rs

@@ -1,6 +1,10 @@
 // Copyright 2017 The Chromium OS Authors. All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
+#![allow(non_camel_case_types)]
+use vm_memory::ByteValued;
 
 pub const MP_PROCESSOR: ::std::os::raw::c_uint = 0;
 pub const MP_BUS: ::std::os::raw::c_uint = 1;
@@ -15,7 +19,7 @@ pub const MP_IRQDIR_DEFAULT: ::std::os::raw::c_uint = 0;
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct mpf_intel {
-    pub signature: [::std::os::raw::c_char; 4usize],
+    pub signature: [::std::os::raw::c_uchar; 4usize],
     pub physptr: ::std::os::raw::c_uint,
     pub length: ::std::os::raw::c_uchar,
     pub specification: ::std::os::raw::c_uchar,
@@ -27,15 +31,22 @@ pub struct mpf_intel {
     pub feature5: ::std::os::raw::c_uchar,
 }
 
+const _: () = assert!(::core::mem::size_of::<mpf_intel>() == 16);
+// SAFETY: all members of this struct are plain integers
+// and the sum of their sizes is the size of the struct, so
+// padding and reserved values are not possible as there
+// would be nowhere for them to exist.
+unsafe impl ByteValued for mpf_intel {}
+
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct mpc_table {
-    pub signature: [::std::os::raw::c_char; 4usize],
+    pub signature: [::std::os::raw::c_uchar; 4usize],
     pub length: ::std::os::raw::c_ushort,
-    pub spec: ::std::os::raw::c_char,
-    pub checksum: ::std::os::raw::c_char,
-    pub oem: [::std::os::raw::c_char; 8usize],
-    pub productid: [::std::os::raw::c_char; 12usize],
+    pub spec: ::std::os::raw::c_uchar,
+    pub checksum: ::std::os::raw::c_uchar,
+    pub oem: [::std::os::raw::c_uchar; 8usize],
+    pub productid: [::std::os::raw::c_uchar; 12usize],
     pub oemptr: ::std::os::raw::c_uint,
     pub oemsize: ::std::os::raw::c_ushort,
     pub oemcount: ::std::os::raw::c_ushort,
@@ -43,6 +54,19 @@ pub struct mpc_table {
     pub reserved: ::std::os::raw::c_uint,
 }
 
+const _: () = {
+    assert!(::core::mem::size_of::<mpc_table>() == 4 + 2 + 1 + 1 + 8 + 12 + 4 + 2 + 2 + 4 + 4);
+    assert!(::core::mem::size_of::<::std::os::raw::c_uint>() == 4);
+    assert!(::core::mem::size_of::<::std::os::raw::c_ushort>() == 2);
+    assert!(::core::mem::size_of::<::std::os::raw::c_uchar>() == 1);
+};
+
+// SAFETY: all members of this struct are plain integers
+// and the sum of their sizes is the size of the struct, so
+// padding and reserved values are not possible as there
+// would be nowhere for them to exist.
+unsafe impl ByteValued for mpc_table {}
+
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct mpc_cpu {
@@ -55,6 +79,13 @@ pub struct mpc_cpu {
     pub reserved: [::std::os::raw::c_uint; 2usize],
 }
 
+const _: () = assert!(::core::mem::size_of::<mpc_cpu>() == 20);
+// SAFETY: all members of this struct are plain integers
+// and the sum of their sizes is the size of the struct, so
+// padding and reserved values are not possible as there
+// would be nowhere for them to exist.
+unsafe impl ByteValued for mpc_cpu {}
+
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct mpc_bus {
@@ -63,6 +94,13 @@ pub struct mpc_bus {
     pub bustype: [::std::os::raw::c_uchar; 6usize],
 }
 
+const _: () = assert!(::core::mem::size_of::<mpc_bus>() == 8);
+// SAFETY: all members of this struct are plain integers
+// and the sum of their sizes is the size of the struct, so
+// padding and reserved values are not possible as there
+// would be nowhere for them to exist.
+unsafe impl ByteValued for mpc_bus {}
+
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct mpc_ioapic {
@@ -73,6 +111,13 @@ pub struct mpc_ioapic {
     pub apicaddr: ::std::os::raw::c_uint,
 }
 
+const _: () = assert!(::core::mem::size_of::<mpc_ioapic>() == 8);
+// SAFETY: all members of this struct are plain integers
+// and the sum of their sizes is the size of the struct, so
+// padding and reserved values are not possible as there
+// would be nowhere for them to exist.
+unsafe impl ByteValued for mpc_ioapic {}
+
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct mpc_intsrc {
@@ -85,6 +130,13 @@ pub struct mpc_intsrc {
     pub dstirq: ::std::os::raw::c_uchar,
 }
 
+const _: () = assert!(::core::mem::size_of::<mpc_intsrc>() == 8);
+// SAFETY: all members of this struct are plain integers
+// and the sum of their sizes is the size of the struct, so
+// padding and reserved values are not possible as there
+// would be nowhere for them to exist.
+unsafe impl ByteValued for mpc_intsrc {}
+
 pub const MP_IRQ_SOURCE_TYPES_MP_INT: ::std::os::raw::c_uint = 0;
 pub const MP_IRQ_SOURCE_TYPES_MP_NMI: ::std::os::raw::c_uint = 1;
 pub const MP_IRQ_SOURCE_TYPES_MP_EXT_INT: ::std::os::raw::c_uint = 3;
@@ -101,12 +153,26 @@ pub struct mpc_lintsrc {
     pub destapiclint: ::std::os::raw::c_uchar,
 }
 
+const _: () = assert!(::core::mem::size_of::<mpc_lintsrc>() == 8);
+// SAFETY: all members of this struct are plain integers
+// and the sum of their sizes is the size of the struct, so
+// padding and reserved values are not possible as there
+// would be nowhere for them to exist.
+unsafe impl ByteValued for mpc_lintsrc {}
+
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct mpc_oemtable {
-    pub signature: [::std::os::raw::c_char; 4usize],
+    pub signature: [::std::os::raw::c_uchar; 4usize],
     pub length: ::std::os::raw::c_ushort,
-    pub rev: ::std::os::raw::c_char,
-    pub checksum: ::std::os::raw::c_char,
-    pub mpc: [::std::os::raw::c_char; 8usize],
+    pub rev: ::std::os::raw::c_uchar,
+    pub checksum: ::std::os::raw::c_uchar,
+    pub mpc: [::std::os::raw::c_uchar; 8usize],
 }
+
+const _: () = assert!(::core::mem::size_of::<mpc_oemtable>() == 16);
+// SAFETY: all members of this struct are plain integers
+// and the sum of their sizes is the size of the struct, so
+// padding and reserved values are not possible as there
+// would be nowhere for them to exist.
+unsafe impl ByteValued for mpc_oemtable {}

arch/src/x86_64/mptable.rs

@@ -5,16 +5,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
-use crate::layout::{APIC_START, HIGH_RAM_START, IOAPIC_START};
-use crate::x86_64::mpspec;
-use crate::GuestMemoryMmap;
-use libc::c_char;
-use std::io;
-use std::mem;
-use std::result;
-use std::slice;
+use std::{mem, result, slice};
+
+use libc::c_uchar;
+use thiserror::Error;
 use vm_memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryError};
 
+use super::MAX_SUPPORTED_CPUS_LEGACY;
+use crate::GuestMemoryMmap;
+use crate::layout::{APIC_START, HIGH_RAM_START, IOAPIC_START};
+use crate::x86_64::{get_x2apic_id, mpspec};
+
 // This is a workaround to the Rust enforcement specifying that any implementation of a foreign
 // trait (in this case `ByteValued`) where:
 // *    the type that is implementing the trait is foreign or
@@ -37,65 +38,69 @@ 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)]
+#[derive(Debug, Error)]
 pub enum Error {
     /// There was too little guest memory to store the entire MP table.
+    #[error("There was too little guest memory to store the entire MP table")]
     NotEnoughMemory,
     /// The MP table has too little address space to be stored.
+    #[error("The MP table has too little address space to be stored")]
     AddressOverflow,
     /// Failure while zeroing out the memory for the MP table.
-    Clear(GuestMemoryError),
-    /// Number of CPUs exceeds the maximum supported CPUs
-    TooManyCpus,
+    #[error("Failure while zeroing out the memory for the MP table")]
+    Clear(#[source] GuestMemoryError),
     /// Failure to write the MP floating pointer.
-    WriteMpfIntel(GuestMemoryError),
+    #[error("Failure to write the MP floating pointer")]
+    WriteMpfIntel(#[source] GuestMemoryError),
     /// Failure to write MP CPU entry.
-    WriteMpcCpu(GuestMemoryError),
+    #[error("Failure to write MP CPU entry")]
+    WriteMpcCpu(#[source] GuestMemoryError),
     /// Failure to write MP ioapic entry.
-    WriteMpcIoapic(GuestMemoryError),
+    #[error("Failure to write MP ioapic entry")]
+    WriteMpcIoapic(#[source] GuestMemoryError),
     /// Failure to write MP bus entry.
-    WriteMpcBus(GuestMemoryError),
+    #[error("Failure to write MP bus entry")]
+    WriteMpcBus(#[source] GuestMemoryError),
     /// Failure to write MP interrupt source entry.
-    WriteMpcIntsrc(GuestMemoryError),
+    #[error("Failure to write MP interrupt source entry")]
+    WriteMpcIntsrc(#[source] GuestMemoryError),
     /// Failure to write MP local interrupt source entry.
-    WriteMpcLintsrc(GuestMemoryError),
+    #[error("Failure to write MP local interrupt source entry")]
+    WriteMpcLintsrc(#[source] GuestMemoryError),
     /// Failure to write MP table header.
-    WriteMpcTable(GuestMemoryError),
+    #[error("Failure to write MP table header")]
+    WriteMpcTable(#[source] GuestMemoryError),
 }
 
 pub type Result<T> = result::Result<T, Error>;
 
-// With APIC/xAPIC, there are only 255 APIC IDs available. And IOAPIC occupies
-// one APIC ID, so only 254 CPUs at maximum may be supported. Actually it's
-// a large number for FC usecases.
-pub const MAX_SUPPORTED_CPUS: u32 = 254;
-
-// Convenience macro for making arrays of diverse character types.
-macro_rules! char_array {
-    ($t:ty; $( $c:expr ),*) => ( [ $( $c as $t ),* ] )
-}
-
 // Most of these variables are sourced from the Intel MP Spec 1.4.
-const SMP_MAGIC_IDENT: [c_char; 4] = char_array!(c_char; '_', 'M', 'P', '_');
-const MPC_SIGNATURE: [c_char; 4] = char_array!(c_char; 'P', 'C', 'M', 'P');
-const MPC_SPEC: i8 = 4;
-const MPC_OEM: [c_char; 8] = char_array!(c_char; 'F', 'C', ' ', ' ', ' ', ' ', ' ', ' ');
-const MPC_PRODUCT_ID: [c_char; 12] = ['0' as c_char; 12];
-const BUS_TYPE_ISA: [u8; 6] = char_array!(u8; 'I', 'S', 'A', ' ', ' ', ' ');
+const SMP_MAGIC_IDENT: &[c_uchar; 4] = b"_MP_";
+const MPC_SIGNATURE: &[c_uchar; 4] = b"PCMP";
+const MPC_SPEC: u8 = 4;
+const MPC_OEM: &[c_uchar; 8] = b"FC      ";
+const MPC_PRODUCT_ID: &[c_uchar; 12] = &[b'0'; 12];
+const BUS_TYPE_ISA: &[c_uchar; 6] = b"ISA   ";
 const APIC_VERSION: u8 = 0x14;
 const CPU_STEPPING: u32 = 0x600;
 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`.
+fn compute_checksum<T: Copy + ByteValued>(v: &T) -> u8 {
+    // 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() {
@@ -109,7 +114,7 @@ fn mpf_intel_compute_checksum(v: &mpspec::mpf_intel) -> u8 {
     (!checksum).wrapping_add(1)
 }
 
-fn compute_mp_size(num_cpus: u8) -> usize {
+fn compute_mp_size(num_cpus: u32) -> usize {
     mem::size_of::<MpfIntelWrapper>()
         + mem::size_of::<MpcTableWrapper>()
         + mem::size_of::<MpcCpuWrapper>() * (num_cpus as usize)
@@ -120,9 +125,19 @@ fn compute_mp_size(num_cpus: u8) -> usize {
 }
 
 /// Performs setup of the MP table for the given `num_cpus`.
-pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8) -> Result<()> {
-    if num_cpus as u32 > MAX_SUPPORTED_CPUS {
-        return Err(Error::TooManyCpus);
+pub fn setup_mptable(
+    offset: GuestAddress,
+    mem: &GuestMemoryMmap,
+    num_cpus: u32,
+    topology: Option<(u16, u16, u16, u16)>,
+) -> Result<()> {
+    if num_cpus > 0 {
+        let cpu_id_max = num_cpus - 1;
+        let x2apic_id_max = get_x2apic_id(cpu_id_max, topology);
+        if x2apic_id_max >= MAX_SUPPORTED_CPUS_LEGACY {
+            info!("Skipping mptable creation due to too many CPUs");
+            return Ok(());
+        }
     }
 
     // Used to keep track of the next base pointer into the MP table.
@@ -136,7 +151,7 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
     }
 
     let mut checksum: u8 = 0;
-    let ioapicid: u8 = num_cpus + 1;
+    let ioapicid: u8 = MAX_SUPPORTED_CPUS_LEGACY as u8 + 1;
 
     // The checked_add here ensures the all of the following base_mp.unchecked_add's will be without
     // overflow.
@@ -148,13 +163,13 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
         return Err(Error::AddressOverflow);
     }
 
-    mem.read_exact_from(base_mp, &mut io::repeat(0), mp_size)
+    mem.read_exact_volatile_from(base_mp, &mut vec![0; mp_size].as_slice(), mp_size)
         .map_err(Error::Clear)?;
 
     {
         let mut mpf_intel = MpfIntelWrapper(mpspec::mpf_intel::default());
         let size = mem::size_of::<MpfIntelWrapper>() as u64;
-        mpf_intel.0.signature = SMP_MAGIC_IDENT;
+        mpf_intel.0.signature = *SMP_MAGIC_IDENT;
         mpf_intel.0.length = 1;
         mpf_intel.0.specification = 4;
         mpf_intel.0.physptr = (base_mp.raw_value() + size) as u32;
@@ -174,7 +189,7 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
         for cpu_id in 0..num_cpus {
             let mut mpc_cpu = MpcCpuWrapper(mpspec::mpc_cpu::default());
             mpc_cpu.0.type_ = mpspec::MP_PROCESSOR as u8;
-            mpc_cpu.0.apicid = cpu_id;
+            mpc_cpu.0.apicid = get_x2apic_id(cpu_id, topology) as u8;
             mpc_cpu.0.apicver = APIC_VERSION;
             mpc_cpu.0.cpuflag = mpspec::CPU_ENABLED as u8
                 | if cpu_id == 0 {
@@ -195,7 +210,7 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
         let mut mpc_bus = MpcBusWrapper(mpspec::mpc_bus::default());
         mpc_bus.0.type_ = mpspec::MP_BUS as u8;
         mpc_bus.0.busid = 0;
-        mpc_bus.0.bustype = BUS_TYPE_ISA;
+        mpc_bus.0.bustype = *BUS_TYPE_ISA;
         mem.write_obj(mpc_bus, base_mp)
             .map_err(Error::WriteMpcBus)?;
         base_mp = base_mp.unchecked_add(size as u64);
@@ -266,14 +281,14 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
 
     {
         let mut mpc_table = MpcTableWrapper(mpspec::mpc_table::default());
-        mpc_table.0.signature = MPC_SIGNATURE;
+        mpc_table.0.signature = *MPC_SIGNATURE;
         mpc_table.0.length = table_end.unchecked_offset_from(table_base) as u16;
         mpc_table.0.spec = MPC_SPEC;
-        mpc_table.0.oem = MPC_OEM;
-        mpc_table.0.productid = MPC_PRODUCT_ID;
+        mpc_table.0.oem = *MPC_OEM;
+        mpc_table.0.productid = *MPC_PRODUCT_ID;
         mpc_table.0.lapic = APIC_START.0 as u32;
         checksum = checksum.wrapping_add(compute_checksum(&mpc_table.0));
-        mpc_table.0.checksum = (!checksum).wrapping_add(1) as i8;
+        mpc_table.0.checksum = (!checksum).wrapping_add(1);
         mem.write_obj(mpc_table, table_base)
             .map_err(Error::WriteMpcTable)?;
     }
@@ -283,9 +298,11 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
 
 #[cfg(test)]
 mod tests {
+    use vm_memory::bitmap::BitmapSlice;
+    use vm_memory::{GuestUsize, VolatileMemoryError, VolatileSlice, WriteVolatile};
+
     use super::*;
     use crate::layout::MPTABLE_START;
-    use vm_memory::{GuestAddress, GuestUsize};
 
     fn table_entry_size(type_: u8) -> usize {
         match type_ as u32 {
@@ -294,7 +311,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_}"),
         }
     }
 
@@ -304,7 +321,7 @@ mod tests {
         let mem =
             GuestMemoryMmap::from_ranges(&[(MPTABLE_START, compute_mp_size(num_cpus))]).unwrap();
 
-        setup_mptable(MPTABLE_START, &mem, num_cpus).unwrap();
+        setup_mptable(MPTABLE_START, &mem, num_cpus, None).unwrap();
     }
 
     #[test]
@@ -313,7 +330,7 @@ mod tests {
         let mem = GuestMemoryMmap::from_ranges(&[(MPTABLE_START, compute_mp_size(num_cpus) - 1)])
             .unwrap();
 
-        assert!(setup_mptable(MPTABLE_START, &mem, num_cpus).is_err());
+        setup_mptable(MPTABLE_START, &mem, num_cpus, None).unwrap_err();
     }
 
     #[test]
@@ -322,7 +339,7 @@ mod tests {
         let mem =
             GuestMemoryMmap::from_ranges(&[(MPTABLE_START, compute_mp_size(num_cpus))]).unwrap();
 
-        setup_mptable(MPTABLE_START, &mem, num_cpus).unwrap();
+        setup_mptable(MPTABLE_START, &mem, num_cpus, None).unwrap();
 
         let mpf_intel: MpfIntelWrapper = mem.read_obj(MPTABLE_START).unwrap();
 
@@ -338,27 +355,31 @@ mod tests {
         let mem =
             GuestMemoryMmap::from_ranges(&[(MPTABLE_START, compute_mp_size(num_cpus))]).unwrap();
 
-        setup_mptable(MPTABLE_START, &mem, num_cpus).unwrap();
+        setup_mptable(MPTABLE_START, &mem, num_cpus, None).unwrap();
 
         let mpf_intel: MpfIntelWrapper = mem.read_obj(MPTABLE_START).unwrap();
         let mpc_offset = GuestAddress(mpf_intel.0.physptr as GuestUsize);
         let mpc_table: MpcTableWrapper = mem.read_obj(mpc_offset).unwrap();
 
         struct Sum(u8);
-        impl io::Write for Sum {
-            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-                for v in buf.iter() {
+        impl WriteVolatile for Sum {
+            fn write_volatile<B: BitmapSlice>(
+                &mut self,
+                buf: &VolatileSlice<B>,
+            ) -> result::Result<usize, VolatileMemoryError> {
+                let mut tmp = vec![0u8; buf.len()];
+                tmp.write_all_volatile(buf)?;
+
+                for v in tmp.iter() {
                     self.0 = self.0.wrapping_add(*v);
                 }
+
                 Ok(buf.len())
             }
-            fn flush(&mut self) -> io::Result<()> {
-                Ok(())
-            }
         }
 
         let mut sum = Sum(0);
-        mem.write_to(mpc_offset, &mut sum, mpc_table.0.length as usize)
+        mem.write_volatile_to(mpc_offset, &mut sum, mpc_table.0.length as usize)
             .unwrap();
         assert_eq!(sum.0, 0);
     }
@@ -367,12 +388,12 @@ mod tests {
     fn cpu_entry_count() {
         let mem = GuestMemoryMmap::from_ranges(&[(
             MPTABLE_START,
-            compute_mp_size(MAX_SUPPORTED_CPUS as u8),
+            compute_mp_size(MAX_SUPPORTED_CPUS_LEGACY),
         )])
         .unwrap();
 
-        for i in 0..MAX_SUPPORTED_CPUS as u8 {
-            setup_mptable(MPTABLE_START, &mem, i).unwrap();
+        for i in 0..MAX_SUPPORTED_CPUS_LEGACY {
+            setup_mptable(MPTABLE_START, &mem, i, None).unwrap();
 
             let mpf_intel: MpfIntelWrapper = mem.read_obj(MPTABLE_START).unwrap();
             let mpc_offset = GuestAddress(mpf_intel.0.physptr as GuestUsize);
@@ -401,11 +422,9 @@ mod tests {
 
     #[test]
     fn cpu_entry_count_max() {
-        let cpus = MAX_SUPPORTED_CPUS + 1;
-        let mem =
-            GuestMemoryMmap::from_ranges(&[(MPTABLE_START, compute_mp_size(cpus as u8))]).unwrap();
+        let cpus = MAX_SUPPORTED_CPUS_LEGACY + 1;
+        let mem = GuestMemoryMmap::from_ranges(&[(MPTABLE_START, compute_mp_size(cpus))]).unwrap();
 
-        let result = setup_mptable(MPTABLE_START, &mem, cpus as u8);
-        assert!(result.is_err());
+        setup_mptable(MPTABLE_START, &mem, cpus, None).unwrap();
     }
 }

arch/src/x86_64/regs.rs

@@ -6,41 +6,58 @@
 // Portions Copyright 2017 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-BSD-3-Clause file.
-use crate::layout::{BOOT_GDT_START, BOOT_IDT_START, PVH_INFO_START};
-use crate::GuestMemoryMmap;
-use hypervisor::arch::x86::gdt::{gdt_entry, segment_from_gdt};
-use hypervisor::arch::x86::regs::*;
-use hypervisor::x86_64::{FpuState, SpecialRegisters, StandardRegisters};
 use std::sync::Arc;
 use std::{mem, result};
+
+use hypervisor::arch::x86::gdt::{gdt_entry, segment_from_gdt};
+use hypervisor::arch::x86::regs::CR0_PE;
+use hypervisor::arch::x86::{FpuState, SpecialRegisters};
+use thiserror::Error;
 use vm_memory::{Address, Bytes, GuestMemory, GuestMemoryError};
 
-#[derive(Debug)]
+use crate::layout::{
+    BOOT_GDT_START, BOOT_IDT_START, BOOT_STACK_POINTER, PVH_INFO_START, ZERO_PAGE_START,
+};
+use crate::{EntryPoint, GuestMemoryMmap};
+
+#[derive(Debug, Error)]
 pub enum Error {
     /// Failed to get SREGs for this CPU.
-    GetStatusRegisters(hypervisor::HypervisorCpuError),
+    #[error("Failed to get SREGs for this CPU")]
+    GetStatusRegisters(#[source] hypervisor::HypervisorCpuError),
     /// Failed to set base registers for this CPU.
-    SetBaseRegisters(hypervisor::HypervisorCpuError),
+    #[error("Failed to set base registers for this CPU")]
+    SetBaseRegisters(#[source] hypervisor::HypervisorCpuError),
     /// Failed to configure the FPU.
-    SetFpuRegisters(hypervisor::HypervisorCpuError),
+    #[error("Failed to configure the FPU")]
+    SetFpuRegisters(#[source] hypervisor::HypervisorCpuError),
     /// Setting up MSRs failed.
-    SetModelSpecificRegisters(hypervisor::HypervisorCpuError),
+    #[error("Setting up MSRs failed")]
+    SetModelSpecificRegisters(#[source] hypervisor::HypervisorCpuError),
     /// Failed to set SREGs for this CPU.
-    SetStatusRegisters(hypervisor::HypervisorCpuError),
+    #[error("Failed to set SREGs for this CPU")]
+    SetStatusRegisters(#[source] hypervisor::HypervisorCpuError),
     /// Checking the GDT address failed.
+    #[error("Checking the GDT address failed")]
     CheckGdtAddr,
     /// Writing the GDT to RAM failed.
-    WriteGdt(GuestMemoryError),
+    #[error("Writing the GDT to RAM failed")]
+    WriteGdt(#[source] GuestMemoryError),
     /// Writing the IDT to RAM failed.
-    WriteIdt(GuestMemoryError),
+    #[error("Writing the IDT to RAM failed")]
+    WriteIdt(#[source] GuestMemoryError),
     /// Writing PDPTE to RAM failed.
-    WritePdpteAddress(GuestMemoryError),
+    #[error("Writing PDPTE to RAM failed")]
+    WritePdpteAddress(#[source] GuestMemoryError),
     /// Writing PDE to RAM failed.
-    WritePdeAddress(GuestMemoryError),
+    #[error("Writing PDE to RAM failed")]
+    WritePdeAddress(#[source] GuestMemoryError),
     /// Writing PML4 to RAM failed.
-    WritePml4Address(GuestMemoryError),
+    #[error("Writing PML4 to RAM failed")]
+    WritePml4Address(#[source] GuestMemoryError),
     /// Writing PML5 to RAM failed.
-    WritePml5Address(GuestMemoryError),
+    #[error("Writing PML5 to RAM failed")]
+    WritePml5Address(#[source] GuestMemoryError),
 }
 
 pub type Result<T> = result::Result<T, Error>;
@@ -66,7 +83,7 @@ pub fn setup_fpu(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
 ///
 /// * `vcpu` - Structure for the VCPU that holds the VCPU's fd.
 pub fn setup_msrs(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
-    vcpu.set_msrs(&hypervisor::x86_64::boot_msr_entries())
+    vcpu.set_msrs(&vcpu.boot_msr_entries())
         .map_err(Error::SetModelSpecificRegisters)?;
 
     Ok(())
@@ -77,13 +94,21 @@ pub fn setup_msrs(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
 /// # Arguments
 ///
 /// * `vcpu` - Structure for the VCPU that holds the VCPU's fd.
-/// * `boot_ip` - Starting instruction pointer.
-pub fn setup_regs(vcpu: &Arc<dyn hypervisor::Vcpu>, boot_ip: u64) -> Result<()> {
-    let regs = StandardRegisters {
-        rflags: 0x0000000000000002u64,
-        rbx: PVH_INFO_START.raw_value(),
-        rip: boot_ip,
-        ..Default::default()
+/// * `entry_point` - Description of the boot entry to set up.
+pub fn setup_regs(vcpu: &Arc<dyn hypervisor::Vcpu>, entry_point: EntryPoint) -> Result<()> {
+    let mut regs = vcpu.create_standard_regs();
+    match entry_point.setup_header {
+        None => {
+            regs.set_rflags(0x0000000000000002u64);
+            regs.set_rip(entry_point.entry_addr.raw_value());
+            regs.set_rbx(PVH_INFO_START.raw_value());
+        }
+        Some(_) => {
+            regs.set_rflags(0x0000000000000002u64);
+            regs.set_rip(entry_point.entry_addr.raw_value());
+            regs.set_rsp(BOOT_STACK_POINTER.raw_value());
+            regs.set_rsi(ZERO_PAGE_START.raw_value());
+        }
     };
     vcpu.set_regs(&regs).map_err(Error::SetBaseRegisters)
 }
@@ -94,9 +119,13 @@ pub fn setup_regs(vcpu: &Arc<dyn hypervisor::Vcpu>, boot_ip: u64) -> Result<()>
 ///
 /// * `mem` - The memory that will be passed to the guest.
 /// * `vcpu` - Structure for the VCPU that holds the VCPU's fd.
-pub fn setup_sregs(mem: &GuestMemoryMmap, vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
+pub fn setup_sregs(
+    mem: &GuestMemoryMmap,
+    vcpu: &Arc<dyn hypervisor::Vcpu>,
+    enable_x2_apic_mode: bool,
+) -> Result<()> {
     let mut sregs: SpecialRegisters = vcpu.get_sregs().map_err(Error::GetStatusRegisters)?;
-    configure_segments_and_sregs(mem, &mut sregs)?;
+    configure_segments_and_sregs(mem, &mut sregs, enable_x2_apic_mode)?;
     vcpu.set_sregs(&sregs).map_err(Error::SetStatusRegisters)
 }
 
@@ -123,8 +152,9 @@ fn write_idt_value(val: u64, guest_mem: &GuestMemoryMmap) -> Result<()> {
 pub fn configure_segments_and_sregs(
     mem: &GuestMemoryMmap,
     sregs: &mut SpecialRegisters,
+    enable_x2_apic_mode: bool,
 ) -> 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
@@ -158,15 +188,20 @@ pub fn configure_segments_and_sregs(
     sregs.cr0 = CR0_PE;
     sregs.cr4 = 0;
 
+    if enable_x2_apic_mode {
+        const X2APIC_ENABLE_BIT: u64 = 1 << 10;
+        sregs.apic_base |= X2APIC_ENABLE_BIT;
+    }
+
     Ok(())
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::GuestMemoryMmap;
     use vm_memory::GuestAddress;
 
+    use super::*;
+
     fn create_guest_mem() -> GuestMemoryMmap {
         GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap()
     }
@@ -179,7 +214,7 @@ mod tests {
     fn segments_and_sregs() {
         let mut sregs: SpecialRegisters = Default::default();
         let gm = create_guest_mem();
-        configure_segments_and_sregs(&gm, &mut sregs).unwrap();
+        configure_segments_and_sregs(&gm, &mut sregs, false).unwrap();
         assert_eq!(0x0, read_u64(&gm, BOOT_GDT_START));
         assert_eq!(
             0xcf9b000000ffff,

arch/src/x86_64/smbios.rs

@@ -6,46 +6,35 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use crate::layout::SMBIOS_START;
-use crate::GuestMemoryMmap;
-use std::fmt::{self, Display};
-use std::mem;
-use std::result;
-use std::slice;
-use vm_memory::ByteValued;
-use vm_memory::{Address, Bytes, GuestAddress};
+use std::{mem, result, slice};
 
-#[allow(unused_variables)]
-#[derive(Debug)]
+use thiserror::Error;
+use uuid::Uuid;
+use vm_memory::{Address, ByteValued, Bytes, GuestAddress};
+
+use crate::GuestMemoryMmap;
+use crate::layout::SMBIOS_START;
+
+#[derive(Debug, Error)]
 pub enum Error {
     /// There was too little guest memory to store the entire SMBIOS table.
+    #[error("There was too little guest memory to store the SMBIOS table")]
     NotEnoughMemory,
     /// The SMBIOS table has too little address space to be stored.
+    #[error("The SMBIOS table has too little address space to be stored")]
     AddressOverflow,
     /// Failure while zeroing out the memory for the SMBIOS table.
+    #[error("Failure while zeroing out the memory for the SMBIOS table")]
     Clear,
     /// Failure to write SMBIOS entrypoint structure
+    #[error("Failure to write SMBIOS entrypoint structure")]
     WriteSmbiosEp,
     /// Failure to write additional data to memory
+    #[error("Failure to write additional data to memory")]
     WriteData,
-}
-
-impl std::error::Error for Error {}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::Error::*;
-
-        let description = match self {
-            NotEnoughMemory => "There was too little guest memory to store the SMBIOS table",
-            AddressOverflow => "The SMBIOS table has too little address space to be stored",
-            Clear => "Failure while zeroing out the memory for the SMBIOS table",
-            WriteSmbiosEp => "Failure to write SMBIOS entrypoint structure",
-            WriteData => "Failure to write additional data to memory",
-        };
-
-        write!(f, "SMBIOS error: {}", description)
-    }
+    /// Failure to parse uuid, uuid format may be error
+    #[error("Failure to parse uuid")]
+    ParseUuid(#[source] uuid::Error),
 }
 
 pub type Result<T> = result::Result<T, Error>;
@@ -54,12 +43,13 @@ pub type Result<T> = result::Result<T, Error>;
 const SM3_MAGIC_IDENT: &[u8; 5usize] = b"_SM3_";
 const BIOS_INFORMATION: u8 = 0;
 const SYSTEM_INFORMATION: u8 = 1;
+const OEM_STRINGS: u8 = 11;
 const END_OF_TABLE: u8 = 127;
 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() {
@@ -68,75 +58,85 @@ fn compute_checksum<T: Copy>(v: &T) -> u8 {
     (!checksum).wrapping_add(1)
 }
 
+#[repr(C)]
 #[repr(packed)]
-#[derive(Default, Copy)]
-pub struct Smbios30Entrypoint {
-    pub signature: [u8; 5usize],
-    pub checksum: u8,
-    pub length: u8,
-    pub majorver: u8,
-    pub minorver: u8,
-    pub docrev: u8,
-    pub revision: u8,
-    pub reserved: u8,
-    pub max_size: u32,
-    pub physptr: u64,
-}
-
-impl Clone for Smbios30Entrypoint {
-    fn clone(&self) -> Self {
-        *self
-    }
+#[derive(Default, Copy, Clone)]
+struct Smbios30Entrypoint {
+    signature: [u8; 5usize],
+    checksum: u8,
+    length: u8,
+    majorver: u8,
+    minorver: u8,
+    docrev: u8,
+    revision: u8,
+    reserved: u8,
+    max_size: u32,
+    physptr: u64,
 }
 
+#[repr(C)]
 #[repr(packed)]
-#[derive(Default, Copy)]
-pub struct SmbiosBiosInfo {
-    pub typ: u8,
-    pub length: u8,
-    pub handle: u16,
-    pub vendor: u8,
-    pub version: u8,
-    pub start_addr: u16,
-    pub release_date: u8,
-    pub rom_size: u8,
-    pub characteristics: u64,
-    pub characteristics_ext1: u8,
-    pub characteristics_ext2: u8,
-}
-
-impl Clone for SmbiosBiosInfo {
-    fn clone(&self) -> Self {
-        *self
-    }
+#[derive(Default, Copy, Clone)]
+struct SmbiosBiosInfo {
+    r#type: u8,
+    length: u8,
+    handle: u16,
+    vendor: u8,
+    version: u8,
+    start_addr: u16,
+    release_date: u8,
+    rom_size: u8,
+    characteristics: u64,
+    characteristics_ext1: u8,
+    characteristics_ext2: u8,
 }
 
+#[repr(C)]
 #[repr(packed)]
-#[derive(Default, Copy)]
-pub struct SmbiosSysInfo {
-    pub typ: u8,
-    pub length: u8,
-    pub handle: u16,
-    pub manufacturer: u8,
-    pub product_name: u8,
-    pub version: u8,
-    pub serial_number: u8,
-    pub uuid: [u8; 16usize],
-    pub wake_up_type: u8,
-    pub sku: u8,
-    pub family: u8,
+#[derive(Default, Copy, Clone)]
+struct SmbiosSysInfo {
+    r#type: u8,
+    length: u8,
+    handle: u16,
+    manufacturer: u8,
+    product_name: u8,
+    version: u8,
+    serial_number: u8,
+    uuid: [u8; 16usize],
+    wake_up_type: u8,
+    sku: u8,
+    family: u8,
 }
 
-impl Clone for SmbiosSysInfo {
-    fn clone(&self) -> Self {
-        *self
-    }
+#[repr(C)]
+#[repr(packed)]
+#[derive(Default, Copy, Clone)]
+struct SmbiosOemStrings {
+    r#type: u8,
+    length: u8,
+    handle: u16,
+    count: u8,
 }
 
-// SAFETY: These data structures only contain a series of integers
+#[repr(C)]
+#[repr(packed)]
+#[derive(Default, Copy, Clone)]
+struct SmbiosEndOfTable {
+    r#type: u8,
+    length: u8,
+    handle: u16,
+}
+
+// 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>(
     mem: &GuestMemoryMmap,
@@ -162,7 +162,12 @@ fn write_string(
     Ok(curptr)
 }
 
-pub fn setup_smbios(mem: &GuestMemoryMmap) -> Result<u64> {
+pub fn setup_smbios(
+    mem: &GuestMemoryMmap,
+    serial_number: Option<&str>,
+    uuid: Option<&str>,
+    oem_strings: Option<&[&str]>,
+) -> Result<u64> {
     let physptr = GuestAddress(SMBIOS_START)
         .checked_add(mem::size_of::<Smbios30Entrypoint>() as u64)
         .ok_or(Error::NotEnoughMemory)?;
@@ -172,7 +177,7 @@ pub fn setup_smbios(mem: &GuestMemoryMmap) -> Result<u64> {
     {
         handle += 1;
         let smbios_biosinfo = SmbiosBiosInfo {
-            typ: BIOS_INFORMATION,
+            r#type: BIOS_INFORMATION,
             length: mem::size_of::<SmbiosBiosInfo>() as u8,
             handle,
             vendor: 1,  // First string written in this section
@@ -189,29 +194,59 @@ pub fn setup_smbios(mem: &GuestMemoryMmap) -> Result<u64> {
 
     {
         handle += 1;
+
+        let uuid_number = uuid
+            .map(Uuid::parse_str)
+            .transpose()
+            .map_err(Error::ParseUuid)?
+            .unwrap_or(Uuid::nil());
         let smbios_sysinfo = SmbiosSysInfo {
-            typ: SYSTEM_INFORMATION,
+            r#type: SYSTEM_INFORMATION,
             length: mem::size_of::<SmbiosSysInfo>() as u8,
             handle,
             manufacturer: 1, // First string written in this section
             product_name: 2, // Second string written in this section
+            serial_number: serial_number.map(|_| 3).unwrap_or_default(), // 3rd string
+            uuid: uuid_number.to_bytes_le(), // set uuid
             ..Default::default()
         };
         curptr = write_and_incr(mem, smbios_sysinfo, curptr)?;
         curptr = write_string(mem, "Cloud Hypervisor", curptr)?;
         curptr = write_string(mem, "cloud-hypervisor", curptr)?;
+        if let Some(serial_number) = serial_number {
+            curptr = write_string(mem, serial_number, curptr)?;
+        }
+        curptr = write_and_incr(mem, 0u8, curptr)?;
+    }
+
+    if let Some(oem_strings) = oem_strings {
+        handle += 1;
+
+        let smbios_oemstrings = SmbiosOemStrings {
+            r#type: OEM_STRINGS,
+            length: mem::size_of::<SmbiosOemStrings>() as u8,
+            handle,
+            count: oem_strings.len() as u8,
+        };
+
+        curptr = write_and_incr(mem, smbios_oemstrings, curptr)?;
+
+        for s in oem_strings {
+            curptr = write_string(mem, s, curptr)?;
+        }
+
         curptr = write_and_incr(mem, 0u8, curptr)?;
     }
 
     {
         handle += 1;
-        let smbios_sysinfo = SmbiosSysInfo {
-            typ: END_OF_TABLE,
-            length: mem::size_of::<SmbiosSysInfo>() as u8,
+        let smbios_end = SmbiosEndOfTable {
+            r#type: END_OF_TABLE,
+            length: mem::size_of::<SmbiosEndOfTable>() as u8,
             handle,
-            ..Default::default()
         };
-        curptr = write_and_incr(mem, smbios_sysinfo, curptr)?;
+        curptr = write_and_incr(mem, smbios_end, curptr)?;
+        curptr = write_and_incr(mem, 0u8, curptr)?;
         curptr = write_and_incr(mem, 0u8, curptr)?;
     }
 
@@ -233,7 +268,7 @@ pub fn setup_smbios(mem: &GuestMemoryMmap) -> Result<u64> {
             .map_err(|_| Error::WriteSmbiosEp)?;
     }
 
-    Ok(curptr.unchecked_offset_from(physptr))
+    Ok(curptr.unchecked_offset_from(physptr) + std::mem::size_of::<Smbios30Entrypoint>() as u64)
 }
 
 #[cfg(test)]
@@ -263,7 +298,7 @@ mod tests {
     fn entrypoint_checksum() {
         let mem = GuestMemoryMmap::from_ranges(&[(GuestAddress(SMBIOS_START), 4096)]).unwrap();
 
-        setup_smbios(&mem).unwrap();
+        setup_smbios(&mem, None, None, None).unwrap();
 
         let smbios_ep: Smbios30Entrypoint = mem.read_obj(GuestAddress(SMBIOS_START)).unwrap();
 

arch/src/x86_64/tdx/mod.rs

@@ -1,30 +1,41 @@
 // Copyright © 2021 Intel Corporation
 //
 // SPDX-License-Identifier: Apache-2.0
-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};
 
+use crate::GuestMemoryMmap;
+
 #[derive(Error, Debug)]
 pub enum TdvfError {
-    #[error("Failed read TDVF descriptor: {0}")]
+    #[error("Failed read TDVF descriptor")]
     ReadDescriptor(#[source] std::io::Error),
-    #[error("Failed read TDVF descriptor offset: {0}")]
+    #[error("Failed read TDVF descriptor offset")]
     ReadDescriptorOffset(#[source] std::io::Error),
+    #[error("Failed read GUID table")]
+    ReadGuidTable(#[source] std::io::Error),
     #[error("Invalid descriptor signature")]
     InvalidDescriptorSignature,
     #[error("Invalid descriptor size")]
     InvalidDescriptorSize,
     #[error("Invalid descriptor version")]
     InvalidDescriptorVersion,
-    #[error("Failed to write HOB details to guest memory: {0}")]
+    #[error("Failed to write HOB details to guest memory")]
     GuestMemoryWriteHob(#[source] GuestMemoryError),
+    #[error("Failed to create Uuid")]
+    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)]
+#[repr(C, packed)]
 #[derive(Default)]
 pub struct TdvfDescriptor {
     signature: [u8; 4],
@@ -34,7 +45,7 @@ pub struct TdvfDescriptor {
 }
 
 // TDVF_SECTION
-#[repr(packed)]
+#[repr(C, packed)]
 #[derive(Clone, Copy, Default, Debug)]
 pub struct TdvfSection {
     pub data_offset: u32,
@@ -46,73 +57,85 @@ pub struct TdvfSection {
 }
 
 #[repr(u32)]
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Default)]
 pub enum TdvfSectionType {
     Bfv,
     Cfv,
     TdHob,
     TempMem,
+    PermMem,
+    Payload,
+    PayloadParam,
+    #[default]
     Reserved = 0xffffffff,
 }
 
-impl Default for TdvfSectionType {
-    fn default() -> Self {
-        TdvfSectionType::Reserved
+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 GUID 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,
+                ));
+            }
+        }
     }
-}
 
-#[repr(C)]
-#[derive(Clone, Copy, Default, Debug)]
-pub struct TdVmmDataRegion {
-    pub start_address: u64,
-    pub length: u64,
-    pub region_type: TdVmmDataRegionType,
-}
+    // 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.
 
-#[repr(u16)]
-#[derive(Clone, Copy, Debug)]
-pub enum TdVmmDataRegionType {
-    Signature = 0x0000,
-    InterfaceVersion = 0x0001,
-    SystemUuid = 0x0002,
-    RamSize = 0x0003,
-    GraphicsEnabled = 0x0004,
-    SmpCpuCount = 0x0005,
-    MachineId = 0x0006,
-    KernelAddress = 0x0007,
-    KernelSize = 0x0008,
-    KernelCommandLine = 0x0009,
-    InitrdAddress = 0x000a,
-    InitrdSize = 0x000b,
-    BootDevice = 0x000c,
-    NumaData = 0x000d,
-    BootMenu = 0x000e,
-    MaximumCpuCount = 0x000f,
-    KernelEntry = 0x0010,
-    KernelData = 0x0011,
-    InitrdData = 0x0012,
-    CommandLineAddress = 0x0013,
-    CommandLineSize = 0x0014,
-    CommandLineData = 0x0015,
-    KernelSetupAddress = 0x0016,
-    KernelSetupSize = 0x0017,
-    KernelSetupData = 0x0018,
-    FileDir = 0x0019,
-    AcpiTables = 0x8000,
-    SmbiosTables = 0x8001,
-    Irq0Override = 0x8002,
-    E820Table = 0x8003,
-    HpetData = 0x8004,
-    Reserved = 0xffff,
-}
-
-impl Default for TdVmmDataRegionType {
-    fn default() -> Self {
-        TdVmmDataRegionType::Reserved
-    }
-}
-
-pub fn parse_tdvf_sections(file: &mut File) -> Result<Vec<TdvfSection>, TdvfError> {
     // 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
@@ -122,13 +145,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,
@@ -155,7 +186,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,
@@ -164,26 +195,21 @@ pub fn parse_tdvf_sections(file: &mut File) -> Result<Vec<TdvfSection>, TdvfErro
     })
     .map_err(TdvfError::ReadDescriptor)?;
 
-    Ok(sections)
+    Ok((sections, guid_found))
 }
 
 #[repr(u16)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Default)]
 enum HobType {
     Handoff = 0x1,
     ResourceDescriptor = 0x3,
     GuidExtension = 0x4,
+    #[default]
     Unused = 0xfffe,
     EndOfHobList = 0xffff,
 }
 
-impl Default for HobType {
-    fn default() -> Self {
-        HobType::Unused
-    }
-}
-
-#[repr(C)]
+#[repr(C, packed)]
 #[derive(Copy, Clone, Default, Debug)]
 struct HobHeader {
     r#type: HobType,
@@ -191,7 +217,7 @@ struct HobHeader {
     reserved: u32,
 }
 
-#[repr(C)]
+#[repr(C, packed)]
 #[derive(Copy, Clone, Default, Debug)]
 struct HobHandoffInfoTable {
     header: HobHeader,
@@ -204,7 +230,7 @@ struct HobHandoffInfoTable {
     efi_end_of_hob_list: u64,
 }
 
-#[repr(C)]
+#[repr(C, packed)]
 #[derive(Copy, Clone, Default, Debug)]
 struct EfiGuid {
     data1: u32,
@@ -213,7 +239,7 @@ struct EfiGuid {
     data4: [u8; 8],
 }
 
-#[repr(C)]
+#[repr(C, packed)]
 #[derive(Copy, Clone, Default, Debug)]
 struct HobResourceDescriptor {
     header: HobHeader,
@@ -224,27 +250,48 @@ struct HobResourceDescriptor {
     resource_length: u64,
 }
 
-#[repr(C)]
+#[repr(C, packed)]
 #[derive(Copy, Clone, Default, Debug)]
 struct HobGuidType {
     header: HobHeader,
     name: EfiGuid,
 }
 
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-struct TdVmmData {
-    guid_type: HobGuidType,
-    region: TdVmmDataRegion,
+#[repr(u32)]
+#[derive(Clone, Copy, Debug, Default)]
+pub enum PayloadImageType {
+    #[default]
+    ExecutablePayload,
+    BzImage,
+    RawVmLinux,
 }
 
-// SAFETY: These data structures only contain a series of integers
-unsafe impl ByteValued for TdVmmDataRegion {}
+#[repr(C, packed)]
+#[derive(Copy, Clone, Default, Debug)]
+pub struct PayloadInfo {
+    pub image_type: PayloadImageType,
+    pub entry_point: u64,
+}
+
+#[repr(C, packed)]
+#[derive(Copy, Clone, Default, Debug)]
+struct TdPayload {
+    guid_type: HobGuidType,
+    payload_info: PayloadInfo,
+}
+
+// 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 {}
-unsafe impl ByteValued for TdVmmData {}
+// 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 {
     start_offset: u64,
@@ -252,7 +299,7 @@ pub struct TdHob {
 }
 
 fn align_hob(v: u64) -> u64 {
-    (v + 7) / 8 * 8
+    v.div_ceil(8) * 8
 }
 
 impl TdHob {
@@ -339,22 +386,29 @@ 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 */
             },
             /* TODO:
              * QEMU currently fills it in like this:
-             * EFI_RESOURCE_ATTRIBUTE_PRESENT | EFI_RESOURCE_ATTRIBUTE_INITIALIZED | EFI_RESOURCE_ATTRIBUTE_ENCRYPTED | EFI_RESOURCE_ATTRIBUTE_TESTED
+             * EFI_RESOURCE_ATTRIBUTE_PRESENT | EFI_RESOURCE_ATTRIBUTE_INITIALIZED | EFI_RESOURCE_ATTRIBUTE_TESTED
              * which differs from the spec (due to TDVF implementation issue?)
              */
-            0x04000007,
+            0x7,
         )
     }
 
@@ -376,35 +430,90 @@ impl TdHob {
         )
     }
 
-    pub fn add_td_vmm_data(
+    pub fn add_acpi_table(
         &mut self,
         mem: &GuestMemoryMmap,
-        region: TdVmmDataRegion,
+        table_content: &[u8],
     ) -> Result<(), TdvfError> {
-        let td_vmm_data = TdVmmData {
+        // We already know the HobGuidType size is 8 bytes multiple, but we
+        // need the total size to be 8 bytes multiple. That is why the ACPI
+        // table size must be 8 bytes multiple as well.
+        let length = std::mem::size_of::<HobGuidType>() as u16
+            + align_hob(table_content.len() as u64) as u16;
+        let hob_guid_type = HobGuidType {
+            header: HobHeader {
+                r#type: HobType::GuidExtension,
+                length,
+                reserved: 0,
+            },
+            // ACPI_TABLE_HOB_GUID
+            // 0x6a0c5870, 0xd4ed, 0x44f4, {0xa1, 0x35, 0xdd, 0x23, 0x8b, 0x6f, 0xc, 0x8d }
+            name: EfiGuid {
+                data1: 0x6a0c_5870,
+                data2: 0xd4ed,
+                data3: 0x44f4,
+                data4: [0xa1, 0x35, 0xdd, 0x23, 0x8b, 0x6f, 0xc, 0x8d],
+            },
+        };
+        info!(
+            "Writing HOB ACPI table {:x} {:x?} {:x?}",
+            self.current_offset, hob_guid_type, table_content
+        );
+        mem.write_obj(hob_guid_type, GuestAddress(self.current_offset))
+            .map_err(TdvfError::GuestMemoryWriteHob)?;
+        let current_offset = self.current_offset + std::mem::size_of::<HobGuidType>() as u64;
+
+        // In case the table is quite large, let's make sure we can handle
+        // retrying until everything has been correctly copied.
+        let mut offset: usize = 0;
+        loop {
+            let bytes_written = mem
+                .write(
+                    &table_content[offset..],
+                    GuestAddress(current_offset + offset as u64),
+                )
+                .map_err(TdvfError::GuestMemoryWriteHob)?;
+            offset += bytes_written;
+            if offset >= table_content.len() {
+                break;
+            }
+        }
+        self.current_offset += length as u64;
+
+        Ok(())
+    }
+
+    pub fn add_payload(
+        &mut self,
+        mem: &GuestMemoryMmap,
+        payload_info: PayloadInfo,
+    ) -> Result<(), TdvfError> {
+        let payload = TdPayload {
             guid_type: HobGuidType {
                 header: HobHeader {
                     r#type: HobType::GuidExtension,
-                    length: std::mem::size_of::<TdVmmData>() as u16,
+                    length: std::mem::size_of::<TdPayload>() as u16,
                     reserved: 0,
                 },
-                // TD_VMM_DATA_GUID CF2643E4-C0D3-46FF-0000-72EE623DDE38
+                // HOB_PAYLOAD_INFO_GUID
+                // 0xb96fa412, 0x461f, 0x4be3, {0x8c, 0xd, 0xad, 0x80, 0x5a, 0x49, 0x7a, 0xc0
                 name: EfiGuid {
-                    data1: 0xcf26_43e4,
-                    data2: 0xc0d3,
-                    data3: 0x46ff,
-                    data4: [0x00, 0x00, 0x72, 0xee, 0x62, 0x3d, 0xde, 0x38],
+                    data1: 0xb96f_a412,
+                    data2: 0x461f,
+                    data3: 0x4be3,
+                    data4: [0x8c, 0xd, 0xad, 0x80, 0x5a, 0x49, 0x7a, 0xc0],
                 },
             },
-            region,
+            payload_info,
         };
         info!(
-            "Writing HOB TD_VMM_DATA {:x} {:x?}",
-            self.current_offset, td_vmm_data
+            "Writing HOB TD_PAYLOAD {:x} {:x?}",
+            self.current_offset, payload
         );
-        mem.write_obj(td_vmm_data, GuestAddress(self.current_offset))
+        mem.write_obj(payload, GuestAddress(self.current_offset))
             .map_err(TdvfError::GuestMemoryWriteHob)?;
-        self.update_offset::<TdVmmData>();
+        self.update_offset::<TdPayload>();
+
         Ok(())
     }
 }
@@ -417,9 +526,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?}")
         }
     }
 }

block/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+authors = ["The Chromium OS Authors", "The Cloud Hypervisor Authors"]
+edition.workspace = true
+name = "block"
+version = "0.1.0"
+
+[features]
+default = []
+io_uring = ["dep:io-uring"]
+
+[dependencies]
+byteorder = { workspace = true }
+crc-any = "2.5.0"
+io-uring = { version = "0.7.10", optional = true }
+libc = { workspace = true }
+log = { workspace = true }
+remain = "0.2.15"
+serde = { workspace = true, features = ["derive"] }
+smallvec = "1.15.1"
+thiserror = { workspace = true }
+uuid = { workspace = true, features = ["v4"] }
+virtio-bindings = { workspace = true }
+virtio-queue = { workspace = true }
+vm-memory = { workspace = true, features = [
+  "backend-atomic",
+  "backend-bitmap",
+  "backend-mmap",
+] }
+vm-virtio = { path = "../vm-virtio" }
+vmm-sys-util = { workspace = true }

block/src/async_io.rs

@@ -0,0 +1,111 @@
+// Copyright © 2021 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+
+use std::marker::PhantomData;
+use std::os::fd::{AsRawFd, OwnedFd, RawFd};
+
+use thiserror::Error;
+use vmm_sys_util::eventfd::EventFd;
+
+use crate::{BatchRequest, DiskTopology};
+
+#[derive(Error, Debug)]
+pub enum DiskFileError {
+    /// Failed getting disk file size.
+    #[error("Failed getting disk file size")]
+    Size(#[source] std::io::Error),
+    /// Failed creating a new AsyncIo.
+    #[error("Failed creating a new AsyncIo")]
+    NewAsyncIo(#[source] std::io::Error),
+}
+
+pub type DiskFileResult<T> = std::result::Result<T, DiskFileError>;
+
+/// A wrapper for [`RawFd`] capturing the lifetime of a corresponding [`DiskFile`].
+///
+/// This fulfills the same role as [`BorrowedFd`] but is tailored to the limitations
+/// by some implementations of [`DiskFile`], which wrap the effective [`File`]
+/// in an `Arc<Mutex<T>>`, making the use of [`BorrowedFd`] impossible.
+///
+/// [`BorrowedFd`]: std::os::fd::BorrowedFd
+#[derive(Copy, Clone, Debug)]
+pub struct BorrowedDiskFd<'fd> {
+    raw_fd: RawFd,
+    _lifetime: PhantomData<&'fd OwnedFd>,
+}
+
+impl BorrowedDiskFd<'_> {
+    pub(super) fn new(raw_fd: RawFd) -> Self {
+        Self {
+            raw_fd,
+            _lifetime: PhantomData,
+        }
+    }
+}
+
+impl AsRawFd for BorrowedDiskFd<'_> {
+    fn as_raw_fd(&self) -> RawFd {
+        self.raw_fd
+    }
+}
+
+/// Abstraction over the effective [`File`] backing up a block device,
+/// with support for synchronous and asynchronous I/O.
+///
+/// This allows abstracting over raw image formats as well as structured
+/// image formats.
+pub trait DiskFile: Send {
+    fn size(&mut self) -> DiskFileResult<u64>;
+    fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>>;
+    fn topology(&mut self) -> DiskTopology {
+        DiskTopology::default()
+    }
+    /// Returns the file descriptor of the underlying disk image file.
+    ///
+    /// The file descriptor is supposed to be used for `fcntl()` calls but no
+    /// other operation.
+    fn fd(&mut self) -> BorrowedDiskFd<'_>;
+}
+
+#[derive(Error, Debug)]
+pub enum AsyncIoError {
+    /// Failed vectored reading from file.
+    #[error("Failed vectored reading from file")]
+    ReadVectored(#[source] std::io::Error),
+    /// Failed vectored writing to file.
+    #[error("Failed vectored writing to file")]
+    WriteVectored(#[source] std::io::Error),
+    /// Failed synchronizing file.
+    #[error("Failed synchronizing file")]
+    Fsync(#[source] std::io::Error),
+    /// Failed submitting batch requests.
+    #[error("Failed submitting batch requests: {0}")]
+    SubmitBatchRequests(#[source] std::io::Error),
+}
+
+pub type AsyncIoResult<T> = std::result::Result<T, AsyncIoError>;
+
+pub trait AsyncIo: Send {
+    fn notifier(&self) -> &EventFd;
+    fn read_vectored(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+    ) -> AsyncIoResult<()>;
+    fn write_vectored(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+    ) -> AsyncIoResult<()>;
+    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()>;
+    fn next_completed_request(&mut self) -> Option<(u64, i32)>;
+    fn batch_requests_enabled(&self) -> bool {
+        false
+    }
+    fn submit_batch_requests(&mut self, _batch_request: &[BatchRequest]) -> AsyncIoResult<()> {
+        Ok(())
+    }
+}

block/src/fcntl.rs

@@ -0,0 +1,173 @@
+// Copyright © 2025 Cyberus Technology GmbH
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+//! Helpers for advisory file locking.
+//!
+//! Under the hood, the implementation uses OFD locks for the entire file,
+//! as described in [[0]]. The advantage over `F_SETLKW` (currently used by
+//! Rust std: `File::try_lock()`) is that only the very last `close()` on a
+//! file descriptor releases the lock. This prevents mistakes and unexpected
+//! behavior.
+//!
+//! [0]: <https://apenwarr.ca/log/20101213>.
+
+use std::fmt::Debug;
+use std::io;
+use std::os::fd::{AsRawFd, RawFd};
+
+use thiserror::Error;
+
+/// Errors that can happen when working with file locks.
+#[derive(Error, Debug)]
+pub enum LockError {
+    /// The file is already locked.
+    ///
+    /// A call to [`get_lock_state`] can help to identify the reason.
+    #[error("The file is already locked")]
+    AlreadyLocked,
+    /// IO error.
+    #[error("The lock state could not be checked or set")]
+    Io(#[source] io::Error),
+}
+
+/// Commands for use with [`fcntl`].
+#[allow(non_camel_case_types)]
+enum FcntlArg<'a> {
+    /// Set an OFD lock from the given lock description.
+    F_OFD_SETLK(&'a libc::flock),
+    /// Get the first OFD lock for the given lock description.
+    F_OFD_GETLK(&'a mut libc::flock),
+}
+
+/// Wrapper for [`libc::fcntl`] that properly sets the function arguments.
+fn fcntl(fd: RawFd, arg: FcntlArg) -> libc::c_int {
+    // SAFETY: We use a valid FD.
+    unsafe {
+        match arg {
+            FcntlArg::F_OFD_SETLK(flock) => libc::fcntl(fd, libc::F_OFD_SETLK, flock),
+            FcntlArg::F_OFD_GETLK(flock) => libc::fcntl(fd, libc::F_OFD_GETLK, flock),
+        }
+    }
+}
+
+/// Describes the type of lock you want to set.
+#[derive(Clone, Copy, Debug)]
+pub enum LockType {
+    /// Clear a lock.
+    Unlock,
+    /// Set a write lock (exclusive).
+    Write,
+    /// Set a read lock (shared).
+    Read,
+}
+
+impl LockType {
+    pub const fn to_libc_val(self) -> libc::c_int {
+        match self {
+            Self::Unlock => libc::F_UNLCK as libc::c_int,
+            Self::Write => libc::F_WRLCK as libc::c_int,
+            Self::Read => libc::F_RDLCK as libc::c_int,
+        }
+    }
+}
+
+/// Describes the current state of a lock.
+#[derive(Debug)]
+pub enum LockState {
+    /// No lock set.
+    Unlocked,
+    /// Locked for reading (non-exclusive).
+    SharedRead,
+    /// Locked for writing (exclusive mode).
+    ExclusiveWrite,
+}
+
+impl LockState {
+    fn new(value: libc::c_int) -> Self {
+        const F_UNLCK: libc::c_int = libc::F_UNLCK as libc::c_int;
+        const F_WRLCK: libc::c_int = libc::F_WRLCK as libc::c_int;
+        const F_RDLCK: libc::c_int = libc::F_RDLCK as libc::c_int;
+        match value {
+            F_UNLCK => Self::Unlocked,
+            F_WRLCK => Self::ExclusiveWrite,
+            F_RDLCK => Self::SharedRead,
+            // This is so unlikely that we want to avoid the complexity of
+            // coping with this error case. Can only fail if either Linux
+            // is broken or memory is messed up.
+            other => panic!("Unexpected lock state: {other}"),
+        }
+    }
+}
+
+/// Returns a [`struct@libc::flock`] structure for the whole file.
+const fn get_flock(lock_type: LockType) -> libc::flock {
+    libc::flock {
+        l_type: lock_type.to_libc_val() as libc::c_short,
+        l_whence: libc::SEEK_SET as libc::c_short,
+        l_start: 0,
+        l_len: 0, /* EOF */
+        l_pid: 0, /* filled by callee */
+    }
+}
+
+/// Tries to acquire a lock using [`fcntl`] with respect to the given
+/// parameters.
+///
+/// Please note that `fcntl()` OFD locks are **advisory locks**, which do not
+/// prevent to `open()` a file if a lock is already placed.
+///
+/// # Parameters
+/// - `file`: The file to acquire a lock for [`LockType`]. The file's state will
+///   be logically mutated, but not technically.
+/// - `lock_type`: The [`LockType`]
+pub fn try_acquire_lock<Fd: AsRawFd>(file: Fd, lock_type: LockType) -> Result<(), LockError> {
+    let flock = get_flock(lock_type);
+
+    let res = fcntl(file.as_raw_fd(), FcntlArg::F_OFD_SETLK(&flock));
+    match res {
+        0 => Ok(()),
+        -1 => {
+            let io_error = io::Error::last_os_error();
+            let errno = io_error.raw_os_error().unwrap();
+            match errno {
+                // See man page for error code:
+                // <https://man7.org/linux/man-pages/man2/fcntl.2.html>
+                libc::EAGAIN | libc::EACCES => Err(LockError::AlreadyLocked),
+                _ => Err(LockError::Io(io_error)),
+            }
+        }
+        val => panic!("Unexpected return value from fcntl(): {val}"),
+    }
+}
+
+/// Clears a lock.
+///
+/// # Parameters
+/// - `file`: The file to clear all locks for [`LockType`].
+pub fn clear_lock<Fd: AsRawFd>(file: Fd) -> Result<(), LockError> {
+    try_acquire_lock(file, LockType::Unlock)
+}
+
+/// Returns the current lock state using [`fcntl`] with respect to the given
+/// parameters.
+///
+/// # Parameters
+/// - `file`: The file for which to get the lock state.
+pub fn get_lock_state<Fd: AsRawFd>(file: Fd) -> Result<LockState, LockError> {
+    let mut flock = get_flock(LockType::Write);
+    let res = fcntl(file.as_raw_fd(), FcntlArg::F_OFD_GETLK(&mut flock));
+    match res {
+        0 => {
+            let state = flock.l_type as libc::c_int;
+            let state = LockState::new(state);
+            Ok(state)
+        }
+        -1 => {
+            let io_error = io::Error::last_os_error();
+            Err(LockError::Io(io_error))
+        }
+        val => panic!("Unexpected return value from fcntl(): {val}"),
+    }
+}

block/src/fixed_vhd.rs

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

block/src/fixed_vhd_async.rs

@@ -2,42 +2,41 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::async_io::{
-    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
-};
-use crate::raw_async::RawFileAsync;
-use crate::vhd::VhdFooter;
 use std::fs::File;
 use std::os::unix::io::{AsRawFd, RawFd};
+
 use vmm_sys_util::eventfd::EventFd;
 
-pub struct FixedVhdDiskAsync {
-    file: File,
-    size: u64,
-}
+use crate::async_io::{
+    AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
+};
+use crate::fixed_vhd::FixedVhd;
+use crate::raw_async::RawFileAsync;
+use crate::{BatchRequest, BlockBackend};
+
+pub struct FixedVhdDiskAsync(FixedVhd);
 
 impl FixedVhdDiskAsync {
-    pub fn new(mut file: File) -> std::io::Result<Self> {
-        let footer = VhdFooter::new(&mut file)?;
-
-        Ok(FixedVhdDiskAsync {
-            file,
-            size: footer.current_size(),
-        })
+    pub fn new(file: File) -> std::io::Result<Self> {
+        Ok(Self(FixedVhd::new(file)?))
     }
 }
 
 impl DiskFile for FixedVhdDiskAsync {
     fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self.size)
+        Ok(self.0.size().unwrap())
     }
 
     fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
         Ok(Box::new(
-            FixedVhdAsync::new(self.file.as_raw_fd(), ring_depth, self.size)
+            FixedVhdAsync::new(self.0.as_raw_fd(), ring_depth, self.0.size().unwrap())
                 .map_err(DiskFileError::NewAsyncIo)?,
         ) as Box<dyn AsyncIo>)
     }
+
+    fn fd(&mut self) -> BorrowedDiskFd<'_> {
+        BorrowedDiskFd::new(self.0.as_raw_fd())
+    }
 }
 
 pub struct FixedVhdAsync {
@@ -64,7 +63,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 +82,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 +103,15 @@ 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()
+    }
+
+    fn batch_requests_enabled(&self) -> bool {
+        true
+    }
+
+    fn submit_batch_requests(&mut self, batch_request: &[BatchRequest]) -> AsyncIoResult<()> {
+        self.raw_file_async.submit_batch_requests(batch_request)
     }
 }

block/src/fixed_vhd_sync.rs

@@ -2,42 +2,41 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::async_io::{
-    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
-};
-use crate::raw_sync::RawFileSync;
-use crate::vhd::VhdFooter;
 use std::fs::File;
 use std::os::unix::io::{AsRawFd, RawFd};
+
 use vmm_sys_util::eventfd::EventFd;
 
-pub struct FixedVhdDiskSync {
-    file: File,
-    size: u64,
-}
+use crate::BlockBackend;
+use crate::async_io::{
+    AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
+};
+use crate::fixed_vhd::FixedVhd;
+use crate::raw_sync::RawFileSync;
+
+pub struct FixedVhdDiskSync(FixedVhd);
 
 impl FixedVhdDiskSync {
-    pub fn new(mut file: File) -> std::io::Result<Self> {
-        let footer = VhdFooter::new(&mut file)?;
-
-        Ok(FixedVhdDiskSync {
-            file,
-            size: footer.current_size(),
-        })
+    pub fn new(file: File) -> std::io::Result<Self> {
+        Ok(Self(FixedVhd::new(file)?))
     }
 }
 
 impl DiskFile for FixedVhdDiskSync {
     fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self.size)
+        Ok(self.0.size().unwrap())
     }
 
     fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
         Ok(Box::new(
-            FixedVhdSync::new(self.file.as_raw_fd(), self.size)
+            FixedVhdSync::new(self.0.as_raw_fd(), self.0.size().unwrap())
                 .map_err(DiskFileError::NewAsyncIo)?,
         ) as Box<dyn AsyncIo>)
     }
+
+    fn fd(&mut self) -> BorrowedDiskFd<'_> {
+        BorrowedDiskFd::new(self.0.as_raw_fd())
+    }
 }
 
 pub struct FixedVhdSync {
@@ -62,7 +61,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 +80,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 +100,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()
     }
 }

block/src/lib.rs

@@ -0,0 +1,922 @@
+// Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//
+// Portions Copyright 2017 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-BSD-3-Clause file.
+//
+// Copyright © 2020 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+
+#[macro_use]
+extern crate log;
+
+pub mod async_io;
+pub mod fcntl;
+pub mod fixed_vhd;
+#[cfg(feature = "io_uring")]
+/// Enabled with the `"io_uring"` feature
+pub mod fixed_vhd_async;
+pub mod fixed_vhd_sync;
+pub mod qcow;
+pub mod qcow_sync;
+#[cfg(feature = "io_uring")]
+/// Async primitives based on `io-uring`
+///
+/// Enabled with the `"io_uring"` feature
+pub mod raw_async;
+pub mod raw_async_aio;
+pub mod raw_sync;
+pub mod vhd;
+pub mod vhdx;
+pub mod vhdx_sync;
+
+use std::alloc::{Layout, alloc_zeroed, dealloc};
+use std::collections::VecDeque;
+use std::fmt::Debug;
+use std::fs::File;
+use std::io::{self, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
+use std::os::linux::fs::MetadataExt;
+use std::os::unix::io::AsRawFd;
+use std::path::Path;
+use std::sync::Arc;
+use std::time::Instant;
+use std::{cmp, result};
+
+#[cfg(feature = "io_uring")]
+use io_uring::{IoUring, Probe, opcode};
+use libc::{S_IFBLK, S_IFMT, ioctl};
+use serde::{Deserialize, Serialize};
+use smallvec::SmallVec;
+use thiserror::Error;
+use virtio_bindings::virtio_blk::*;
+use virtio_queue::DescriptorChain;
+use vm_memory::bitmap::Bitmap;
+use vm_memory::{
+    ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryError, GuestMemoryLoadGuard,
+};
+use vm_virtio::{AccessPlatform, Translatable};
+use vmm_sys_util::eventfd::EventFd;
+use vmm_sys_util::{aio, ioctl_io_nr};
+
+use crate::async_io::{AsyncIo, AsyncIoError, AsyncIoResult};
+use crate::vhdx::VhdxError;
+
+const SECTOR_SHIFT: u8 = 9;
+pub const SECTOR_SIZE: u64 = 0x01 << SECTOR_SHIFT;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("Guest gave us bad memory addresses")]
+    GuestMemory(#[source] GuestMemoryError),
+    #[error("Guest gave us offsets that would have overflowed a usize")]
+    CheckedOffset(GuestAddress, usize /* sector offset */),
+    #[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")]
+    UnexpectedReadOnlyDescriptor,
+    #[error("Guest gave us too few descriptors in a descriptor chain")]
+    DescriptorChainTooShort,
+    #[error("Guest gave us a descriptor that was too short to use")]
+    DescriptorLengthTooSmall,
+    #[error("Failed to detect image type")]
+    DetectImageType(#[source] std::io::Error),
+    #[error("Failure in fixed vhd")]
+    FixedVhdError(#[source] std::io::Error),
+    #[error("Getting a block's metadata fails for any reason")]
+    GetFileMetadata,
+    #[error("The requested operation would cause a seek beyond disk end")]
+    InvalidOffset,
+    #[error("Failure in qcow")]
+    QcowError(#[source] qcow::Error),
+    #[error("Failure in raw file")]
+    RawFileError(#[source] std::io::Error),
+    #[error("The requested operation does not support multiple descriptors")]
+    TooManyDescriptors,
+    #[error("Failure in vhdx")]
+    VhdxError(#[source] VhdxError),
+}
+
+fn build_device_id(disk_path: &Path) -> result::Result<String, Error> {
+    let blk_metadata = match disk_path.metadata() {
+        Err(_) => return Err(Error::GetFileMetadata),
+        Ok(m) => m,
+    };
+    // This is how kvmtool does it.
+    let device_id = format!(
+        "{}{}{}",
+        blk_metadata.st_dev(),
+        blk_metadata.st_rdev(),
+        blk_metadata.st_ino()
+    );
+    Ok(device_id)
+}
+
+pub fn build_serial(disk_path: &Path) -> Vec<u8> {
+    let mut default_serial = vec![0; VIRTIO_BLK_ID_BYTES as usize];
+    match build_device_id(disk_path) {
+        Err(_) => {
+            warn!("Could not generate device id. We'll use a default.");
+        }
+        Ok(m) => {
+            // The kernel only knows to read a maximum of VIRTIO_BLK_ID_BYTES.
+            // This will also zero out any leftover bytes.
+            let disk_id = m.as_bytes();
+            let bytes_to_copy = cmp::min(disk_id.len(), VIRTIO_BLK_ID_BYTES as usize);
+            default_serial[..bytes_to_copy].clone_from_slice(&disk_id[..bytes_to_copy])
+        }
+    }
+    default_serial
+}
+
+#[derive(Error, Debug)]
+pub enum ExecuteError {
+    #[error("Bad request")]
+    BadRequest(#[source] Error),
+    #[error("Failed to flush")]
+    Flush(#[source] io::Error),
+    #[error("Failed to read")]
+    Read(#[source] GuestMemoryError),
+    #[error("Failed to read_exact")]
+    ReadExact(#[source] io::Error),
+    #[error("Can't execute an operation other than `read` on a read-only device")]
+    ReadOnly,
+    #[error("Failed to seek")]
+    Seek(#[source] io::Error),
+    #[error("Failed to write")]
+    Write(#[source] GuestMemoryError),
+    #[error("Failed to write_all")]
+    WriteAll(#[source] io::Error),
+    #[error("Unsupported request: {0}")]
+    Unsupported(u32),
+    #[error("Failed to submit io uring")]
+    SubmitIoUring(#[source] io::Error),
+    #[error("Failed to get guest address")]
+    GetHostAddress(#[source] GuestMemoryError),
+    #[error("Failed to async read")]
+    AsyncRead(#[source] AsyncIoError),
+    #[error("Failed to async write")]
+    AsyncWrite(#[source] AsyncIoError),
+    #[error("failed to async flush")]
+    AsyncFlush(#[source] AsyncIoError),
+    #[error("Failed allocating a temporary buffer")]
+    TemporaryBufferAllocation(#[source] io::Error),
+}
+
+impl ExecuteError {
+    pub fn status(&self) -> u8 {
+        let status = match *self {
+            ExecuteError::BadRequest(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::Flush(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::Read(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::ReadExact(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::ReadOnly => VIRTIO_BLK_S_IOERR,
+            ExecuteError::Seek(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::Write(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::WriteAll(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::Unsupported(_) => VIRTIO_BLK_S_UNSUPP,
+            ExecuteError::SubmitIoUring(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::GetHostAddress(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::AsyncRead(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::AsyncWrite(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::AsyncFlush(_) => VIRTIO_BLK_S_IOERR,
+            ExecuteError::TemporaryBufferAllocation(_) => VIRTIO_BLK_S_IOERR,
+        };
+        status as u8
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RequestType {
+    In,
+    Out,
+    Flush,
+    GetDeviceId,
+    Unsupported(u32),
+}
+
+pub fn request_type<B: Bitmap + 'static>(
+    mem: &vm_memory::GuestMemoryMmap<B>,
+    desc_addr: GuestAddress,
+) -> result::Result<RequestType, Error> {
+    let type_ = mem.read_obj(desc_addr).map_err(Error::GuestMemory)?;
+    match type_ {
+        VIRTIO_BLK_T_IN => Ok(RequestType::In),
+        VIRTIO_BLK_T_OUT => Ok(RequestType::Out),
+        VIRTIO_BLK_T_FLUSH => Ok(RequestType::Flush),
+        VIRTIO_BLK_T_GET_ID => Ok(RequestType::GetDeviceId),
+        t => Ok(RequestType::Unsupported(t)),
+    }
+}
+
+fn sector<B: Bitmap + 'static>(
+    mem: &vm_memory::GuestMemoryMmap<B>,
+    desc_addr: GuestAddress,
+) -> result::Result<u64, Error> {
+    const SECTOR_OFFSET: usize = 8;
+    let addr = match mem.checked_offset(desc_addr, SECTOR_OFFSET) {
+        Some(v) => v,
+        None => return Err(Error::CheckedOffset(desc_addr, SECTOR_OFFSET)),
+    };
+
+    mem.read_obj(addr).map_err(Error::GuestMemory)
+}
+
+const DEFAULT_DESCRIPTOR_VEC_SIZE: usize = 32;
+
+#[derive(Debug)]
+pub struct AlignedOperation {
+    origin_ptr: u64,
+    aligned_ptr: u64,
+    size: usize,
+    layout: Layout,
+}
+
+pub struct BatchRequest {
+    pub offset: libc::off_t,
+    pub iovecs: SmallVec<[libc::iovec; DEFAULT_DESCRIPTOR_VEC_SIZE]>,
+    pub user_data: u64,
+    pub request_type: RequestType,
+}
+
+pub struct ExecuteAsync {
+    // `true` if the execution will complete asynchronously
+    pub async_complete: bool,
+    // request need to be batched for submission if any
+    pub batch_request: Option<BatchRequest>,
+}
+
+#[derive(Debug)]
+pub struct Request {
+    pub request_type: RequestType,
+    pub sector: u64,
+    pub data_descriptors: SmallVec<[(GuestAddress, u32); DEFAULT_DESCRIPTOR_VEC_SIZE]>,
+    pub status_addr: GuestAddress,
+    pub writeback: bool,
+    pub aligned_operations: SmallVec<[AlignedOperation; DEFAULT_DESCRIPTOR_VEC_SIZE]>,
+    pub start: Instant,
+}
+
+impl Request {
+    pub fn parse<B: Bitmap + 'static>(
+        desc_chain: &mut DescriptorChain<GuestMemoryLoadGuard<vm_memory::GuestMemoryMmap<B>>>,
+        access_platform: Option<&Arc<dyn AccessPlatform>>,
+    ) -> result::Result<Request, Error> {
+        let hdr_desc = desc_chain
+            .next()
+            .ok_or(Error::DescriptorChainTooShort)
+            .inspect_err(|_| {
+                error!("Missing head descriptor");
+            })?;
+
+        // The head contains the request type which MUST be readable.
+        if hdr_desc.is_write_only() {
+            return Err(Error::UnexpectedWriteOnlyDescriptor);
+        }
+
+        let hdr_desc_addr = hdr_desc
+            .addr()
+            .translate_gva(access_platform, hdr_desc.len() as usize);
+
+        let mut req = Request {
+            request_type: request_type(desc_chain.memory(), hdr_desc_addr)?,
+            sector: sector(desc_chain.memory(), hdr_desc_addr)?,
+            data_descriptors: SmallVec::with_capacity(DEFAULT_DESCRIPTOR_VEC_SIZE),
+            status_addr: GuestAddress(0),
+            writeback: true,
+            aligned_operations: SmallVec::with_capacity(DEFAULT_DESCRIPTOR_VEC_SIZE),
+            start: Instant::now(),
+        };
+
+        let status_desc;
+        let mut desc = desc_chain
+            .next()
+            .ok_or(Error::DescriptorChainTooShort)
+            .inspect_err(|_| {
+                error!("Only head descriptor present: request = {:?}", req);
+            })?;
+
+        if !desc.has_next() {
+            status_desc = desc;
+            // Only flush requests are allowed to skip the data descriptor.
+            if req.request_type != RequestType::Flush {
+                error!("Need a data descriptor: request = {:?}", req);
+                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);
+                }
+                if !desc.is_write_only() && req.request_type == RequestType::In {
+                    return Err(Error::UnexpectedReadOnlyDescriptor);
+                }
+                if !desc.is_write_only() && req.request_type == RequestType::GetDeviceId {
+                    return Err(Error::UnexpectedReadOnlyDescriptor);
+                }
+
+                req.data_descriptors.push((
+                    desc.addr()
+                        .translate_gva(access_platform, desc.len() as usize),
+                    desc.len(),
+                ));
+                desc = desc_chain
+                    .next()
+                    .ok_or(Error::DescriptorChainTooShort)
+                    .inspect_err(|_| {
+                        error!("DescriptorChain corrupted: request = {:?}", req);
+                    })?;
+            }
+            status_desc = desc;
+        }
+
+        // The status MUST always be writable.
+        if !status_desc.is_write_only() {
+            return Err(Error::UnexpectedReadOnlyDescriptor);
+        }
+
+        if status_desc.len() < 1 {
+            return Err(Error::DescriptorLengthTooSmall);
+        }
+
+        req.status_addr = status_desc
+            .addr()
+            .translate_gva(access_platform, status_desc.len() as usize);
+
+        Ok(req)
+    }
+
+    pub fn execute<T: Seek + Read + Write, B: Bitmap + 'static>(
+        &self,
+        disk: &mut T,
+        disk_nsectors: u64,
+        mem: &vm_memory::GuestMemoryMmap<B>,
+        serial: &[u8],
+    ) -> result::Result<u32, ExecuteError> {
+        disk.seek(SeekFrom::Start(self.sector << SECTOR_SHIFT))
+            .map_err(ExecuteError::Seek)?;
+        let mut len = 0;
+        for (data_addr, data_len) in &self.data_descriptors {
+            let mut top: u64 = u64::from(*data_len) / SECTOR_SIZE;
+            if u64::from(*data_len) % SECTOR_SIZE != 0 {
+                top += 1;
+            }
+            top = top
+                .checked_add(self.sector)
+                .ok_or(ExecuteError::BadRequest(Error::InvalidOffset))?;
+            if top > disk_nsectors {
+                return Err(ExecuteError::BadRequest(Error::InvalidOffset));
+            }
+
+            match self.request_type {
+                RequestType::In => {
+                    let mut buf = vec![0u8; *data_len as usize];
+                    disk.read_exact(&mut buf).map_err(ExecuteError::ReadExact)?;
+                    mem.read_exact_volatile_from(
+                        *data_addr,
+                        &mut buf.as_slice(),
+                        *data_len as usize,
+                    )
+                    .map_err(ExecuteError::Read)?;
+                    len += data_len;
+                }
+                RequestType::Out => {
+                    let mut buf: Vec<u8> = Vec::new();
+                    mem.write_all_volatile_to(*data_addr, &mut buf, *data_len as usize)
+                        .map_err(ExecuteError::Write)?;
+                    disk.write_all(&buf).map_err(ExecuteError::WriteAll)?;
+                    if !self.writeback {
+                        disk.flush().map_err(ExecuteError::Flush)?;
+                    }
+                }
+                RequestType::Flush => disk.flush().map_err(ExecuteError::Flush)?,
+                RequestType::GetDeviceId => {
+                    if (*data_len as usize) < serial.len() {
+                        return Err(ExecuteError::BadRequest(Error::InvalidOffset));
+                    }
+                    mem.write_slice(serial, *data_addr)
+                        .map_err(ExecuteError::Write)?;
+                }
+                RequestType::Unsupported(t) => return Err(ExecuteError::Unsupported(t)),
+            };
+        }
+        Ok(len)
+    }
+
+    pub fn execute_async<B: Bitmap + 'static>(
+        &mut self,
+        mem: &vm_memory::GuestMemoryMmap<B>,
+        disk_nsectors: u64,
+        disk_image: &mut dyn AsyncIo,
+        serial: &[u8],
+        user_data: u64,
+    ) -> result::Result<ExecuteAsync, ExecuteError> {
+        let sector = self.sector;
+        let request_type = self.request_type;
+        let offset = (sector << SECTOR_SHIFT) as libc::off_t;
+
+        let mut iovecs: SmallVec<[libc::iovec; DEFAULT_DESCRIPTOR_VEC_SIZE]> =
+            SmallVec::with_capacity(self.data_descriptors.len());
+        for &(data_addr, data_len) in &self.data_descriptors {
+            let _: u32 = data_len; // compiler-checked documentation
+            const _: () = assert!(
+                core::mem::size_of::<u32>() <= core::mem::size_of::<usize>(),
+                "unsupported platform"
+            );
+            if data_len == 0 {
+                continue;
+            }
+            let mut top: u64 = u64::from(data_len) / SECTOR_SIZE;
+            if u64::from(data_len) % SECTOR_SIZE != 0 {
+                top += 1;
+            }
+            let data_len = data_len as usize;
+            top = top
+                .checked_add(sector)
+                .ok_or(ExecuteError::BadRequest(Error::InvalidOffset))?;
+            if top > disk_nsectors {
+                return Err(ExecuteError::BadRequest(Error::InvalidOffset));
+            }
+
+            let origin_ptr = mem
+                .get_slice(data_addr, data_len)
+                .map_err(ExecuteError::GetHostAddress)?
+                .ptr_guard();
+
+            // Verify the buffer alignment.
+            // In case it's not properly aligned, an intermediate buffer is
+            // created with the correct alignment, and a copy from/to the
+            // origin buffer is performed, depending on the type of operation.
+            let iov_base = if !(origin_ptr.as_ptr() as u64).is_multiple_of(SECTOR_SIZE) {
+                let layout = Layout::from_size_align(data_len, SECTOR_SIZE as usize).unwrap();
+                // SAFETY: layout has non-zero size
+                let aligned_ptr = unsafe { alloc_zeroed(layout) };
+                if aligned_ptr.is_null() {
+                    return Err(ExecuteError::TemporaryBufferAllocation(
+                        io::Error::last_os_error(),
+                    ));
+                }
+
+                // We need to perform the copy beforehand in case we're writing
+                // data out.
+                if request_type == RequestType::Out {
+                    // SAFETY: destination buffer has been allocated with
+                    // the proper size.
+                    unsafe { std::ptr::copy(origin_ptr.as_ptr(), aligned_ptr, data_len) };
+                }
+
+                // Store both origin and aligned pointers for complete_async()
+                // to process them.
+                self.aligned_operations.push(AlignedOperation {
+                    origin_ptr: origin_ptr.as_ptr() as u64,
+                    aligned_ptr: aligned_ptr as u64,
+                    size: data_len,
+                    layout,
+                });
+
+                aligned_ptr as *mut libc::c_void
+            } else {
+                origin_ptr.as_ptr() as *mut libc::c_void
+            };
+
+            let iovec = libc::iovec {
+                iov_base,
+                iov_len: data_len as libc::size_t,
+            };
+            iovecs.push(iovec);
+        }
+
+        let mut ret = ExecuteAsync {
+            async_complete: true,
+            batch_request: None,
+        };
+        // Queue operations expected to be submitted.
+        match request_type {
+            RequestType::In => {
+                for (data_addr, data_len) in &self.data_descriptors {
+                    mem.get_slice(*data_addr, *data_len as usize)
+                        .map_err(ExecuteError::GetHostAddress)?
+                        .bitmap()
+                        .mark_dirty(0, *data_len as usize);
+                }
+                if disk_image.batch_requests_enabled() {
+                    ret.batch_request = Some(BatchRequest {
+                        offset,
+                        iovecs,
+                        user_data,
+                        request_type,
+                    });
+                } else {
+                    disk_image
+                        .read_vectored(offset, &iovecs, user_data)
+                        .map_err(ExecuteError::AsyncRead)?;
+                }
+            }
+            RequestType::Out => {
+                if disk_image.batch_requests_enabled() {
+                    ret.batch_request = Some(BatchRequest {
+                        offset,
+                        iovecs,
+                        user_data,
+                        request_type,
+                    });
+                } else {
+                    disk_image
+                        .write_vectored(offset, &iovecs, user_data)
+                        .map_err(ExecuteError::AsyncWrite)?;
+                }
+            }
+            RequestType::Flush => {
+                disk_image
+                    .fsync(Some(user_data))
+                    .map_err(ExecuteError::AsyncFlush)?;
+            }
+            RequestType::GetDeviceId => {
+                let (data_addr, data_len) = if self.data_descriptors.len() == 1 {
+                    (self.data_descriptors[0].0, self.data_descriptors[0].1)
+                } else {
+                    return Err(ExecuteError::BadRequest(Error::TooManyDescriptors));
+                };
+                if (data_len as usize) < serial.len() {
+                    return Err(ExecuteError::BadRequest(Error::InvalidOffset));
+                }
+                mem.write_slice(serial, data_addr)
+                    .map_err(ExecuteError::Write)?;
+                ret.async_complete = false;
+                return Ok(ret);
+            }
+            RequestType::Unsupported(t) => return Err(ExecuteError::Unsupported(t)),
+        }
+
+        Ok(ret)
+    }
+
+    pub fn complete_async(&mut self) -> result::Result<(), Error> {
+        for aligned_operation in self.aligned_operations.drain(..) {
+            // 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 {
+                // SAFETY: origin buffer has been allocated with the
+                // proper size.
+                unsafe {
+                    std::ptr::copy(
+                        aligned_operation.aligned_ptr as *const u8,
+                        aligned_operation.origin_ptr as *mut u8,
+                        aligned_operation.size,
+                    )
+                };
+            }
+
+            // Free the temporary aligned buffer.
+            // SAFETY: aligned_ptr was allocated by alloc_zeroed with the same
+            // layout
+            unsafe {
+                dealloc(
+                    aligned_operation.aligned_ptr as *mut u8,
+                    aligned_operation.layout,
+                )
+            };
+        }
+
+        Ok(())
+    }
+
+    pub fn set_writeback(&mut self, writeback: bool) {
+        self.writeback = writeback
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize)]
+#[repr(C, packed)]
+pub struct VirtioBlockConfig {
+    pub capacity: u64,
+    pub size_max: u32,
+    pub seg_max: u32,
+    pub geometry: VirtioBlockGeometry,
+    pub blk_size: u32,
+    pub physical_block_exp: u8,
+    pub alignment_offset: u8,
+    pub min_io_size: u16,
+    pub opt_io_size: u32,
+    pub writeback: u8,
+    pub unused: u8,
+    pub num_queues: u16,
+    pub max_discard_sectors: u32,
+    pub max_discard_seg: u32,
+    pub discard_sector_alignment: u32,
+    pub max_write_zeroes_sectors: u32,
+    pub max_write_zeroes_seg: u32,
+    pub write_zeroes_may_unmap: u8,
+    pub unused1: [u8; 3],
+}
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize)]
+#[repr(C, packed)]
+pub struct VirtioBlockGeometry {
+    pub cylinders: u16,
+    pub heads: u8,
+    pub sectors: u8,
+}
+
+// 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 aio can be used on the current system.
+pub fn block_aio_is_supported() -> bool {
+    aio::IoContext::new(1).is_ok()
+}
+
+/// Check if io_uring for block device can be used on the current system, as
+/// it correctly supports the expected io_uring features.
+pub fn block_io_uring_is_supported() -> bool {
+    #[cfg(not(feature = "io_uring"))]
+    {
+        info!("io_uring is disabled by crate features");
+        false
+    }
+
+    #[cfg(feature = "io_uring")]
+    {
+        let error_msg = "io_uring not supported:";
+
+        // Check we can create an io_uring instance, which effectively verifies
+        // that io_uring_setup() syscall is supported.
+        let io_uring = match IoUring::new(1) {
+            Ok(io_uring) => io_uring,
+            Err(e) => {
+                info!("{} failed to create io_uring instance: {}", error_msg, e);
+                return false;
+            }
+        };
+
+        let submitter = io_uring.submitter();
+
+        let mut probe = Probe::new();
+
+        // Check we can register a probe to validate supported operations.
+        match submitter.register_probe(&mut probe) {
+            Ok(_) => {}
+            Err(e) => {
+                info!("{} failed to register a probe: {}", error_msg, e);
+                return false;
+            }
+        }
+
+        // Check IORING_OP_FSYNC is supported
+        if !probe.is_supported(opcode::Fsync::CODE) {
+            info!("{} IORING_OP_FSYNC operation not supported", error_msg);
+            return false;
+        }
+
+        // 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_WRITEV is supported
+        if !probe.is_supported(opcode::Writev::CODE) {
+            info!("{} IORING_OP_WRITEV operation not supported", error_msg);
+            return false;
+        }
+
+        true
+    }
+}
+
+pub trait AsyncAdaptor {
+    fn read_vectored_sync(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+        eventfd: &EventFd,
+        completion_list: &mut VecDeque<(u64, i32)>,
+    ) -> AsyncIoResult<()>
+    where
+        Self: Read + Seek,
+    {
+        // Convert libc::iovec into IoSliceMut
+        let mut slices: SmallVec<[IoSliceMut; DEFAULT_DESCRIPTOR_VEC_SIZE]> =
+            SmallVec::with_capacity(iovecs.len());
+        for iovec in iovecs.iter() {
+            // SAFETY: on Linux IoSliceMut wraps around libc::iovec
+            slices.push(IoSliceMut::new(unsafe {
+                std::mem::transmute::<libc::iovec, &mut [u8]>(*iovec)
+            }));
+        }
+
+        let result = {
+            // Move the cursor to the right offset
+            self.seek(SeekFrom::Start(offset as u64))
+                .map_err(AsyncIoError::ReadVectored)?;
+
+            let mut r = 0;
+            for b in slices.iter_mut() {
+                r += self.read(b).map_err(AsyncIoError::ReadVectored)?;
+            }
+            r
+        };
+
+        completion_list.push_back((user_data, result as i32));
+        eventfd.write(1).unwrap();
+
+        Ok(())
+    }
+
+    fn write_vectored_sync(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+        eventfd: &EventFd,
+        completion_list: &mut VecDeque<(u64, i32)>,
+    ) -> AsyncIoResult<()>
+    where
+        Self: Write + Seek,
+    {
+        // Convert libc::iovec into IoSlice
+        let mut slices: SmallVec<[IoSlice; DEFAULT_DESCRIPTOR_VEC_SIZE]> =
+            SmallVec::with_capacity(iovecs.len());
+        for iovec in iovecs.iter() {
+            // SAFETY: on Linux IoSlice wraps around libc::iovec
+            slices.push(IoSlice::new(unsafe {
+                std::mem::transmute::<libc::iovec, &mut [u8]>(*iovec)
+            }));
+        }
+
+        let result = {
+            // Move the cursor to the right offset
+            self.seek(SeekFrom::Start(offset as u64))
+                .map_err(AsyncIoError::WriteVectored)?;
+
+            let mut r = 0;
+            for b in slices.iter() {
+                r += self.write(b).map_err(AsyncIoError::WriteVectored)?;
+            }
+            r
+        };
+
+        completion_list.push_back((user_data, result as i32));
+        eventfd.write(1).unwrap();
+
+        Ok(())
+    }
+
+    fn fsync_sync(
+        &mut self,
+        user_data: Option<u64>,
+        eventfd: &EventFd,
+        completion_list: &mut VecDeque<(u64, i32)>,
+    ) -> AsyncIoResult<()>
+    where
+        Self: Write,
+    {
+        let result: i32 = {
+            // Flush
+            self.flush().map_err(AsyncIoError::Fsync)?;
+
+            0
+        };
+
+        if let Some(user_data) = user_data {
+            completion_list.push_back((user_data, result));
+            eventfd.write(1).unwrap();
+        }
+
+        Ok(())
+    }
+}
+
+pub enum ImageType {
+    FixedVhd,
+    Qcow2,
+    Raw,
+    Vhdx,
+}
+
+const QCOW_MAGIC: u32 = 0x5146_49fb;
+const VHDX_SIGN: u64 = 0x656C_6966_7864_6876;
+
+/// Read a block into memory aligned by the source block size (needed for O_DIRECT)
+pub fn read_aligned_block_size(f: &mut File) -> std::io::Result<Vec<u8>> {
+    let blocksize = DiskTopology::probe(f)?.logical_block_size as usize;
+    // SAFETY: We are allocating memory that is naturally aligned (size = alignment) and we meet
+    // requirements for safety from Vec::from_raw_parts() as we are using the global allocator
+    // and transferring ownership of the memory.
+    let mut data = unsafe {
+        Vec::from_raw_parts(
+            alloc_zeroed(Layout::from_size_align_unchecked(blocksize, blocksize)),
+            blocksize,
+            blocksize,
+        )
+    };
+    f.read_exact(&mut data)?;
+    Ok(data)
+}
+
+/// Determine image type through file parsing.
+pub fn detect_image_type(f: &mut File) -> std::io::Result<ImageType> {
+    let block = read_aligned_block_size(f)?;
+
+    // Check 4 first bytes to get the header value and determine the image type
+    let image_type = if u32::from_be_bytes(block[0..4].try_into().unwrap()) == QCOW_MAGIC {
+        ImageType::Qcow2
+    } else if vhd::is_fixed_vhd(f)? {
+        ImageType::FixedVhd
+    } else if u64::from_le_bytes(block[0..8].try_into().unwrap()) == VHDX_SIGN {
+        ImageType::Vhdx
+    } else {
+        ImageType::Raw
+    };
+
+    Ok(image_type)
+}
+
+pub trait BlockBackend: Read + Write + Seek + Send + Debug {
+    fn size(&self) -> Result<u64, Error>;
+}
+
+#[derive(Debug)]
+pub struct DiskTopology {
+    pub logical_block_size: u64,
+    pub physical_block_size: u64,
+    pub minimum_io_size: u64,
+    pub optimal_io_size: u64,
+}
+
+impl Default for DiskTopology {
+    fn default() -> Self {
+        Self {
+            logical_block_size: 512,
+            physical_block_size: 512,
+            minimum_io_size: 512,
+            optimal_io_size: 0,
+        }
+    }
+}
+
+ioctl_io_nr!(BLKSSZGET, 0x12, 104);
+ioctl_io_nr!(BLKPBSZGET, 0x12, 123);
+ioctl_io_nr!(BLKIOMIN, 0x12, 120);
+ioctl_io_nr!(BLKIOOPT, 0x12, 121);
+
+enum BlockSize {
+    LogicalBlock,
+    PhysicalBlock,
+    MinimumIo,
+    OptimalIo,
+}
+
+impl DiskTopology {
+    fn is_block_device(f: &File) -> std::io::Result<bool> {
+        let mut stat = std::mem::MaybeUninit::<libc::stat>::uninit();
+        // SAFETY: FFI call with a valid fd and buffer
+        let ret = unsafe { libc::fstat(f.as_raw_fd(), stat.as_mut_ptr()) };
+        if ret != 0 {
+            return Err(std::io::Error::last_os_error());
+        }
+
+        // SAFETY: stat is valid at this point
+        let is_block = unsafe { (*stat.as_ptr()).st_mode & S_IFMT == S_IFBLK };
+        Ok(is_block)
+    }
+
+    // libc::ioctl() takes different types on different architectures
+    fn query_block_size(f: &File, block_size_type: BlockSize) -> std::io::Result<u64> {
+        let mut block_size = 0;
+        // SAFETY: FFI call with correct arguments
+        let ret = unsafe {
+            ioctl(
+                f.as_raw_fd(),
+                match block_size_type {
+                    BlockSize::LogicalBlock => BLKSSZGET(),
+                    BlockSize::PhysicalBlock => BLKPBSZGET(),
+                    BlockSize::MinimumIo => BLKIOMIN(),
+                    BlockSize::OptimalIo => BLKIOOPT(),
+                } as _,
+                &mut block_size,
+            )
+        };
+        if ret != 0 {
+            return Err(std::io::Error::last_os_error());
+        };
+
+        Ok(block_size)
+    }
+
+    pub fn probe(f: &File) -> std::io::Result<Self> {
+        if !Self::is_block_device(f)? {
+            return Ok(DiskTopology::default());
+        }
+
+        Ok(DiskTopology {
+            logical_block_size: Self::query_block_size(f, BlockSize::LogicalBlock)?,
+            physical_block_size: Self::query_block_size(f, BlockSize::PhysicalBlock)?,
+            minimum_io_size: Self::query_block_size(f, BlockSize::MinimumIo)?,
+            optimal_io_size: Self::query_block_size(f, BlockSize::OptimalIo)?,
+        })
+    }
+}

block/src/qcow/qcow_raw_file.rs

@@ -1,12 +1,17 @@
 // 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-BSD-3-Clause file.
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+
+use std::io::{self, BufWriter, Seek, SeekFrom, Write};
+use std::mem::size_of;
+use std::os::fd::{AsRawFd, RawFd};
+
+use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
+use vmm_sys_util::write_zeroes::WriteZeroes;
 
 use super::RawFile;
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
-use std::io::{self, BufWriter, Seek, SeekFrom};
-use std::mem::size_of;
-use vmm_sys_util::write_zeroes::WriteZeroes;
 
 /// A qcow file. Allows reading/writing clusters and appending clusters.
 #[derive(Debug)]
@@ -20,7 +25,7 @@ impl QcowRawFile {
     /// Creates a `QcowRawFile` from the given `File`, `None` is returned if `cluster_size` is not
     /// a power of two.
     pub fn from(file: RawFile, cluster_size: u64) -> Option<Self> {
-        if cluster_size.count_ones() != 1 {
+        if !cluster_size.is_power_of_two() {
             return None;
         }
         Some(QcowRawFile {
@@ -31,7 +36,7 @@ impl QcowRawFile {
     }
 
     /// Reads `count` 64 bit offsets and returns them as a vector.
-    /// `mask` optionally ands out some of the bits on the file.
+    /// `mask` optionally `&`s out some of the bits on the file.
     pub fn read_pointer_table(
         &mut self,
         offset: u64,
@@ -50,7 +55,7 @@ impl QcowRawFile {
     }
 
     /// Reads a cluster's worth of 64 bit offsets and returns them as a vector.
-    /// `mask` optionally ands out some of the bits on the file.
+    /// `mask` optionally `&`s out some of the bits on the file.
     pub fn read_pointer_cluster(&mut self, offset: u64, mask: Option<u64>) -> io::Result<Vec<u64>> {
         let count = self.cluster_size / size_of::<u64>() as u64;
         self.read_pointer_table(offset, count, mask)
@@ -66,7 +71,7 @@ impl QcowRawFile {
         non_zero_flags: u64,
     ) -> io::Result<()> {
         self.file.seek(SeekFrom::Start(offset))?;
-        let mut buffer = BufWriter::with_capacity(table.len() * size_of::<u64>(), &mut self.file);
+        let mut buffer = BufWriter::with_capacity(std::mem::size_of_val(table), &mut self.file);
         for addr in table {
             let val = if *addr == 0 {
                 0
@@ -91,7 +96,8 @@ impl QcowRawFile {
     /// Writes a refcount block to the file.
     pub fn write_refcount_block(&mut self, offset: u64, table: &[u16]) -> io::Result<()> {
         self.file.seek(SeekFrom::Start(offset))?;
-        let mut buffer = BufWriter::with_capacity(table.len() * size_of::<u16>(), &mut self.file);
+        let mut buffer = BufWriter::with_capacity(std::mem::size_of_val(table), &mut self.file);
+
         for count in table {
             buffer.write_u16::<BigEndian>(*count)?;
         }
@@ -136,6 +142,13 @@ impl QcowRawFile {
         self.file.write_zeroes(cluster_size)?;
         Ok(())
     }
+
+    /// Writes
+    pub fn write_cluster(&mut self, address: u64, data: Vec<u8>) -> io::Result<()> {
+        let cluster_size = self.cluster_size as usize;
+        self.file.seek(SeekFrom::Start(address))?;
+        self.file.write_all(&data[0..cluster_size])
+    }
 }
 
 impl Clone for QcowRawFile {
@@ -147,3 +160,9 @@ impl Clone for QcowRawFile {
         }
     }
 }
+
+impl AsRawFd for QcowRawFile {
+    fn as_raw_fd(&self) -> RawFd {
+        self.file.as_raw_fd()
+    }
+}

block/src/qcow/raw_file.rs

@@ -8,20 +8,24 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use libc::c_void;
-use std::alloc::{alloc_zeroed, dealloc, Layout};
-use std::convert::TryInto;
+use std::alloc::{Layout, alloc_zeroed, dealloc};
 use std::fs::{File, Metadata};
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::os::unix::io::{AsRawFd, RawFd};
 use std::slice;
-use vmm_sys_util::{seek_hole::SeekHole, write_zeroes::PunchHole, write_zeroes::WriteZeroesAt};
+
+use libc::c_void;
+use vmm_sys_util::seek_hole::SeekHole;
+use vmm_sys_util::write_zeroes::{PunchHole, WriteZeroesAt};
+
+use crate::BlockBackend;
 
 #[derive(Debug)]
 pub struct RawFile {
     file: File,
     alignment: usize,
     position: u64,
+    direct_io: bool,
 }
 
 const BLK_ALIGNMENTS: [usize; 2] = [512, 4096];
@@ -64,12 +68,13 @@ impl RawFile {
             file,
             alignment,
             position: 0,
+            direct_io,
         }
     }
 
     fn round_up(&self, offset: u64) -> u64 {
         let align: u64 = self.alignment.try_into().unwrap();
-        ((offset / (align + 1)) + 1) * align
+        offset.div_ceil(align) * align
     }
 
     fn round_down(&self, offset: u64) -> u64 {
@@ -84,9 +89,9 @@ impl RawFile {
 
         let align64: u64 = self.alignment.try_into().unwrap();
 
-        (self.position % align64 == 0)
-            && ((buf.as_ptr() as usize) % self.alignment == 0)
-            && (buf.len() % self.alignment == 0)
+        self.position.is_multiple_of(align64)
+            && (buf.as_ptr() as usize).is_multiple_of(self.alignment)
+            && buf.len().is_multiple_of(self.alignment)
     }
 
     pub fn set_len(&self, size: u64) -> std::io::Result<()> {
@@ -102,6 +107,7 @@ impl RawFile {
             file: self.file.try_clone().expect("RawFile cloning failed"),
             alignment: self.alignment,
             position: self.position,
+            direct_io: self.direct_io,
         })
     }
 
@@ -112,6 +118,10 @@ impl RawFile {
     pub fn sync_data(&self) -> std::io::Result<()> {
         self.file.sync_data()
     }
+
+    pub fn is_direct(&self) -> bool {
+        self.direct_io
+    }
 }
 
 impl Read for RawFile {
@@ -231,6 +241,7 @@ impl Write for RawFile {
                 return Err(io::Error::last_os_error());
             }
 
+            // SAFETY: tmp_ptr is at least rounded_len long
             let tmp_buf = unsafe { slice::from_raw_parts_mut(tmp_ptr, rounded_len) };
 
             // This can eventually replaced with read_at once its interface
@@ -342,12 +353,25 @@ impl SeekHole for RawFile {
     }
 }
 
+impl BlockBackend for RawFile {
+    fn size(&self) -> std::result::Result<u64, crate::Error> {
+        Ok(self.metadata().map_err(crate::Error::RawFileError)?.len())
+    }
+}
+
 impl Clone for RawFile {
     fn clone(&self) -> Self {
         RawFile {
             file: self.file.try_clone().expect("RawFile cloning failed"),
             alignment: self.alignment,
             position: self.position,
+            direct_io: self.direct_io,
         }
     }
 }
+
+impl AsRawFd for RawFile {
+    fn as_raw_fd(&self) -> RawFd {
+        self.file.as_raw_fd()
+    }
+}

block/src/qcow/refcount.rs

@@ -1,51 +1,38 @@
 // 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-BSD-3-Clause file.
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use std::fmt::{self, Display};
 use std::io;
 
 use libc::EINVAL;
+use thiserror::Error;
 
-use crate::qcow_raw_file::QcowRawFile;
-use crate::vec_cache::{CacheMap, Cacheable, VecCache};
+use crate::qcow::qcow_raw_file::QcowRawFile;
+use crate::qcow::vec_cache::{CacheMap, Cacheable, VecCache};
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum Error {
     /// `EvictingCache` - Error writing a refblock from the cache to disk.
-    EvictingRefCounts(io::Error),
+    #[error("Failed to write a refblock from the cache to disk")]
+    EvictingRefCounts(#[source] io::Error),
     /// `InvalidIndex` - Address requested isn't within the range of the disk.
+    #[error("Address requested is not within the range of the disk")]
     InvalidIndex,
     /// `NeedCluster` - Handle this error by reading the cluster and calling the function again.
+    #[error("Cluster with addr={0} needs to be read")]
     NeedCluster(u64),
     /// `NeedNewCluster` - Handle this error by allocating a cluster and calling the function again.
+    #[error("New cluster needs to be allocated for refcounts")]
     NeedNewCluster,
-    /// `ReadingRefCounts` - Error reading the file in to the refcount cache.
-    ReadingRefCounts(io::Error),
+    /// `ReadingRefCounts` - Error reading the file into the refcount cache.
+    #[error("Failed to read the file into the refcount cache")]
+    ReadingRefCounts(#[source] io::Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
 
-impl Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::Error::*;
-
-        match self {
-            EvictingRefCounts(e) => write!(
-                f,
-                "failed to write a refblock from the cache to disk: {}",
-                e
-            ),
-            InvalidIndex => write!(f, "address requested is not within the range of the disk"),
-            NeedCluster(addr) => write!(f, "cluster with addr={} needs to be read", addr),
-            NeedNewCluster => write!(f, "new cluster needs to be allocated for refcounts"),
-            ReadingRefCounts(e) => {
-                write!(f, "failed to read the file into the refcount cache: {}", e)
-            }
-        }
-    }
-}
-
 /// Represents the refcount entries for an open qcow file.
 #[derive(Clone, Debug)]
 pub struct RefCount {

block/src/qcow/vec_cache.rs

@@ -1,9 +1,11 @@
 // 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-BSD-3-Clause file.
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use std::collections::hash_map::IterMut;
 use std::collections::HashMap;
+use std::collections::hash_map::IterMut;
 use std::io;
 use std::ops::{Index, IndexMut};
 use std::slice::SliceIndex;
@@ -109,7 +111,7 @@ impl<T: Cacheable> CacheMap<T> {
         self.map.get_mut(&index)
     }
 
-    pub fn iter_mut(&mut self) -> IterMut<usize, T> {
+    pub fn iter_mut(&mut self) -> IterMut<'_, usize, T> {
         self.map.iter_mut()
     }
 
@@ -121,10 +123,10 @@ impl<T: Cacheable> CacheMap<T> {
         if self.map.len() == self.capacity {
             // TODO(dgreid) - smarter eviction strategy.
             let to_evict = *self.map.iter().next().unwrap().0;
-            if let Some(evicted) = self.map.remove(&to_evict) {
-                if evicted.dirty() {
-                    write_callback(to_evict, evicted)?;
-                }
+            if let Some(evicted) = self.map.remove(&to_evict)
+                && evicted.dirty()
+            {
+                write_callback(to_evict, evicted)?;
             }
         }
         self.map.insert(index, block);
@@ -136,7 +138,7 @@ impl<T: Cacheable> CacheMap<T> {
 mod tests {
     use super::*;
 
-    struct NumCache(pub u64);
+    struct NumCache(());
     impl Cacheable for NumCache {
         fn dirty(&self) -> bool {
             true
@@ -148,28 +150,28 @@ mod tests {
         let mut cache = CacheMap::<NumCache>::new(3);
         let mut evicted = None;
         cache
-            .insert(0, NumCache(5), |index, _| {
+            .insert(0, NumCache(()), |index, _| {
                 evicted = Some(index);
                 Ok(())
             })
             .unwrap();
         assert_eq!(evicted, None);
         cache
-            .insert(1, NumCache(6), |index, _| {
+            .insert(1, NumCache(()), |index, _| {
                 evicted = Some(index);
                 Ok(())
             })
             .unwrap();
         assert_eq!(evicted, None);
         cache
-            .insert(2, NumCache(7), |index, _| {
+            .insert(2, NumCache(()), |index, _| {
                 evicted = Some(index);
                 Ok(())
             })
             .unwrap();
         assert_eq!(evicted, None);
         cache
-            .insert(3, NumCache(8), |index, _| {
+            .insert(3, NumCache(()), |index, _| {
                 evicted = Some(index);
                 Ok(())
             })

block/src/qcow_sync.rs

@@ -2,60 +2,65 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-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};
+use std::os::fd::AsRawFd;
+
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::AsyncAdaptor;
+use crate::async_io::{
+    AsyncIo, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
+};
+use crate::qcow::{QcowFile, RawFile, Result as QcowResult};
+
 pub struct QcowDiskSync {
-    qcow_file: Arc<Mutex<QcowFile>>,
+    qcow_file: QcowFile,
 }
 
 impl QcowDiskSync {
     pub fn new(file: File, direct_io: bool) -> QcowResult<Self> {
         Ok(QcowDiskSync {
-            qcow_file: Arc::new(Mutex::new(QcowFile::from(RawFile::new(file, direct_io))?)),
+            qcow_file: QcowFile::from(RawFile::new(file, direct_io))?,
         })
     }
 }
 
 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)
+        self.qcow_file
+            .seek(SeekFrom::End(0))
+            .map_err(DiskFileError::Size)
     }
 
     fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
         Ok(Box::new(QcowSync::new(self.qcow_file.clone())) as Box<dyn AsyncIo>)
     }
+
+    fn fd(&mut self) -> BorrowedDiskFd<'_> {
+        BorrowedDiskFd::new(self.qcow_file.as_raw_fd())
+    }
 }
 
 pub struct QcowSync {
-    qcow_file: Arc<Mutex<QcowFile>>,
+    qcow_file: QcowFile,
     eventfd: EventFd,
-    completion_list: Vec<(u64, i32)>,
+    completion_list: VecDeque<(u64, i32)>,
 }
 
 impl QcowSync {
-    pub fn new(qcow_file: Arc<Mutex<QcowFile>>) -> Self {
+    pub fn new(qcow_file: QcowFile) -> Self {
         QcowSync {
             qcow_file,
             eventfd: EventFd::new(libc::EFD_NONBLOCK)
                 .expect("Failed creating EventFd for QcowSync"),
-            completion_list: Vec::new(),
+            completion_list: VecDeque::new(),
         }
     }
 }
 
-impl AsyncAdaptor<QcowFile> for Arc<Mutex<QcowFile>> {
-    fn file(&mut self) -> MutexGuard<QcowFile> {
-        self.lock().unwrap()
-    }
-}
+impl AsyncAdaptor for QcowFile {}
 
 impl AsyncIo for QcowSync {
     fn notifier(&self) -> &EventFd {
@@ -65,7 +70,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 +85,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 +102,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()
     }
 }

block/src/raw_async.rs

@@ -0,0 +1,244 @@
+// Copyright © 2021 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+
+use std::fs::File;
+use std::io::{Error, Seek, SeekFrom};
+use std::os::unix::io::{AsRawFd, RawFd};
+
+use io_uring::{IoUring, opcode, types};
+use vmm_sys_util::eventfd::EventFd;
+
+use crate::async_io::{
+    AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
+};
+use crate::{BatchRequest, DiskTopology, RequestType};
+
+pub struct RawFileDisk {
+    file: File,
+}
+
+impl RawFileDisk {
+    pub fn new(file: File) -> Self {
+        RawFileDisk { file }
+    }
+}
+
+impl DiskFile for RawFileDisk {
+    fn size(&mut self) -> DiskFileResult<u64> {
+        self.file
+            .seek(SeekFrom::End(0))
+            .map_err(DiskFileError::Size)
+    }
+
+    fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
+        Ok(Box::new(
+            RawFileAsync::new(self.file.as_raw_fd(), ring_depth)
+                .map_err(DiskFileError::NewAsyncIo)?,
+        ) as Box<dyn AsyncIo>)
+    }
+
+    fn topology(&mut self) -> DiskTopology {
+        if let Ok(topology) = DiskTopology::probe(&self.file) {
+            topology
+        } else {
+            warn!("Unable to get device topology. Using default topology");
+            DiskTopology::default()
+        }
+    }
+
+    fn fd(&mut self) -> BorrowedDiskFd<'_> {
+        BorrowedDiskFd::new(self.file.as_raw_fd())
+    }
+}
+
+pub struct RawFileAsync {
+    fd: RawFd,
+    io_uring: IoUring,
+    eventfd: EventFd,
+}
+
+impl RawFileAsync {
+    pub fn new(fd: RawFd, ring_depth: u32) -> std::io::Result<Self> {
+        let io_uring = IoUring::new(ring_depth)?;
+        let eventfd = EventFd::new(libc::EFD_NONBLOCK)?;
+
+        // Register the io_uring eventfd that will notify when something in
+        // the completion queue is ready.
+        io_uring.submitter().register_eventfd(eventfd.as_raw_fd())?;
+
+        Ok(RawFileAsync {
+            fd,
+            io_uring,
+            eventfd,
+        })
+    }
+}
+
+impl AsyncIo for RawFileAsync {
+    fn notifier(&self) -> &EventFd {
+        &self.eventfd
+    }
+
+    fn read_vectored(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+    ) -> AsyncIoResult<()> {
+        let (submitter, mut sq, _) = self.io_uring.split();
+
+        // SAFETY: we know the file descriptor is valid and we
+        // relied on vm-memory to provide the buffer address.
+        unsafe {
+            sq.push(
+                &opcode::Readv::new(types::Fd(self.fd), iovecs.as_ptr(), iovecs.len() as u32)
+                    .offset(offset.try_into().unwrap())
+                    .build()
+                    .user_data(user_data),
+            )
+            .map_err(|_| AsyncIoError::ReadVectored(Error::other("Submission queue is full")))?
+        };
+
+        // Update the submission queue and submit new operations to the
+        // io_uring instance.
+        sq.sync();
+        submitter.submit().map_err(AsyncIoError::ReadVectored)?;
+
+        Ok(())
+    }
+
+    fn write_vectored(
+        &mut self,
+        offset: libc::off_t,
+        iovecs: &[libc::iovec],
+        user_data: u64,
+    ) -> AsyncIoResult<()> {
+        let (submitter, mut sq, _) = self.io_uring.split();
+
+        // SAFETY: we know the file descriptor is valid and we
+        // relied on vm-memory to provide the buffer address.
+        unsafe {
+            sq.push(
+                &opcode::Writev::new(types::Fd(self.fd), iovecs.as_ptr(), iovecs.len() as u32)
+                    .offset(offset.try_into().unwrap())
+                    .build()
+                    .user_data(user_data),
+            )
+            .map_err(|_| AsyncIoError::WriteVectored(Error::other("Submission queue is full")))?
+        };
+
+        // Update the submission queue and submit new operations to the
+        // io_uring instance.
+        sq.sync();
+        submitter.submit().map_err(AsyncIoError::WriteVectored)?;
+
+        Ok(())
+    }
+
+    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
+        if let Some(user_data) = user_data {
+            let (submitter, mut sq, _) = self.io_uring.split();
+
+            // SAFETY: we know the file descriptor is valid.
+            unsafe {
+                sq.push(
+                    &opcode::Fsync::new(types::Fd(self.fd))
+                        .build()
+                        .user_data(user_data),
+                )
+                .map_err(|_| AsyncIoError::Fsync(Error::other("Submission queue is full")))?
+            };
+
+            // Update the submission queue and submit new operations to the
+            // io_uring instance.
+            sq.sync();
+            submitter.submit().map_err(AsyncIoError::Fsync)?;
+        } else {
+            // SAFETY: FFI call with a valid fd
+            unsafe { libc::fsync(self.fd) };
+        }
+
+        Ok(())
+    }
+
+    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
+        self.io_uring
+            .completion()
+            .next()
+            .map(|entry| (entry.user_data(), entry.result()))
+    }
+
+    fn batch_requests_enabled(&self) -> bool {
+        true
+    }
+
+    fn submit_batch_requests(&mut self, batch_request: &[BatchRequest]) -> AsyncIoResult<()> {
+        if !self.batch_requests_enabled() {
+            return Ok(());
+        }
+
+        let (submitter, mut sq, _) = self.io_uring.split();
+        let mut submitted = false;
+
+        for req in batch_request {
+            match req.request_type {
+                RequestType::In => {
+                    // SAFETY: we know the file descriptor is valid and we
+                    // relied on vm-memory to provide the buffer address.
+                    unsafe {
+                        sq.push(
+                            &opcode::Readv::new(
+                                types::Fd(self.fd),
+                                req.iovecs.as_ptr(),
+                                req.iovecs.len() as u32,
+                            )
+                            .offset(req.offset as u64)
+                            .build()
+                            .user_data(req.user_data),
+                        )
+                        .map_err(|_| {
+                            AsyncIoError::ReadVectored(Error::other("Submission queue is full"))
+                        })?
+                    };
+                    submitted = true;
+                }
+                RequestType::Out => {
+                    // SAFETY: we know the file descriptor is valid and we
+                    // relied on vm-memory to provide the buffer address.
+                    unsafe {
+                        sq.push(
+                            &opcode::Writev::new(
+                                types::Fd(self.fd),
+                                req.iovecs.as_ptr(),
+                                req.iovecs.len() as u32,
+                            )
+                            .offset(req.offset as u64)
+                            .build()
+                            .user_data(req.user_data),
+                        )
+                        .map_err(|_| {
+                            AsyncIoError::WriteVectored(Error::other("Submission queue is full"))
+                        })?
+                    };
+                    submitted = true;
+                }
+                _ => {
+                    unreachable!("Unexpected batch request type: {:?}", req.request_type)
+                }
+            }
+        }
+
+        // Only submit if we actually queued something
+        if submitted {
+            // Update the submission queue and submit new operations to the
+            // io_uring instance.
+            sq.sync();
+            submitter
+                .submit()
+                .map_err(AsyncIoError::SubmitBatchRequests)?;
+        }
+
+        Ok(())
+    }
+}

block/src/raw_async_aio.rs

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

block/src/raw_sync.rs

@@ -2,14 +2,18 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-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};
+
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::DiskTopology;
+use crate::async_io::{
+    AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
+};
+
 pub struct RawFileDiskSync {
     file: File,
 }
@@ -22,10 +26,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>> {
@@ -33,19 +36,23 @@ impl DiskFile for RawFileDiskSync {
     }
 
     fn topology(&mut self) -> DiskTopology {
-        if let Ok(topology) = DiskTopology::probe(&mut self.file) {
+        if let Ok(topology) = DiskTopology::probe(&self.file) {
             topology
         } else {
             warn!("Unable to get device topology. Using default topology");
             DiskTopology::default()
         }
     }
+
+    fn fd(&mut self) -> BorrowedDiskFd<'_> {
+        BorrowedDiskFd::new(self.file.as_raw_fd())
+    }
 }
 
 pub struct RawFileSync {
     fd: RawFd,
     eventfd: EventFd,
-    completion_list: Vec<(u64, i32)>,
+    completion_list: VecDeque<(u64, i32)>,
 }
 
 impl RawFileSync {
@@ -53,7 +60,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,13 +73,14 @@ 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,
-                iovecs.as_ptr() as *const libc::iovec,
+                iovecs.as_ptr(),
                 iovecs.len() as libc::c_int,
                 offset,
             )
@@ -81,7 +89,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,13 +98,14 @@ 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,
-                iovecs.as_ptr() as *const libc::iovec,
+                iovecs.as_ptr(),
                 iovecs.len() as libc::c_int,
                 offset,
             )
@@ -105,27 +114,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()
     }
 }

block/src/vhd.rs

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

block/src/vhdx/mod.rs

@@ -2,32 +2,43 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhdx_bat::{BatEntry, VhdxBatError};
-use crate::vhdx_header::{self, RegionInfo, RegionTableEntry, VhdxHeader, VhdxHeaderError};
-use crate::vhdx_io::{self, VhdxIoError};
-use crate::vhdx_metadata::{DiskSpec, VhdxMetadataError};
-use remain::sorted;
 use std::collections::btree_map::BTreeMap;
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom, Write};
+use std::os::fd::{AsRawFd, RawFd};
+
+use byteorder::{BigEndian, ByteOrder};
+use remain::sorted;
 use thiserror::Error;
+use uuid::Uuid;
+
+use crate::BlockBackend;
+use crate::vhdx::vhdx_bat::{BatEntry, VhdxBatError};
+use crate::vhdx::vhdx_header::{RegionInfo, RegionTableEntry, VhdxHeader, VhdxHeaderError};
+use crate::vhdx::vhdx_io::VhdxIoError;
+use crate::vhdx::vhdx_metadata::{DiskSpec, VhdxMetadataError};
+
+mod vhdx_bat;
+mod vhdx_header;
+mod vhdx_io;
+mod vhdx_metadata;
 
 #[sorted]
 #[derive(Error, Debug)]
 pub enum VhdxError {
-    #[error("Not a VHDx file {0}")]
+    #[error("Not a VHDx file")]
     NotVhdx(#[source] VhdxHeaderError),
-    #[error("Failed to parse VHDx header {0}")]
+    #[error("Failed to parse VHDx header")]
     ParseVhdxHeader(#[source] VhdxHeaderError),
-    #[error("Failed to parse VHDx metadata {0}")]
+    #[error("Failed to parse VHDx metadata")]
     ParseVhdxMetadata(#[source] VhdxMetadataError),
-    #[error("Failed to parse VHDx region entries {0}")]
+    #[error("Failed to parse VHDx region entries")]
     ParseVhdxRegionEntry(#[source] VhdxHeaderError),
-    #[error("Failed reading metadata {0}")]
+    #[error("Failed reading metadata")]
     ReadBatEntry(#[source] VhdxBatError),
-    #[error("Failed reading sector from disk {0}")]
+    #[error("Failed reading sector from disk")]
     ReadFailed(#[source] VhdxIoError),
-    #[error("Failed writing to sector on disk {0}")]
+    #[error("Failed writing to sector on disk")]
     WriteFailed(#[source] VhdxIoError),
 }
 
@@ -89,11 +100,10 @@ impl Read for Vhdx {
     /// Wrapper function to satisfy Read trait implementation for VHDx disk.
     /// Convert the offset to sector index and buffer length to sector count.
     fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io::Error> {
-        let sector_count =
-            div_round_up!(buf.len() as u64, self.disk_spec.logical_sector_size as u64);
+        let sector_count = (buf.len() as u64).div_ceil(self.disk_spec.logical_sector_size as u64);
         let sector_index = self.current_offset / self.disk_spec.logical_sector_size as u64;
 
-        vhdx_io::read(
+        let result = vhdx_io::read(
             &mut self.file,
             buf,
             &self.disk_spec,
@@ -102,14 +112,14 @@ impl Read for Vhdx {
             sector_count,
         )
         .map_err(|e| {
-            std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!(
-                    "Failed reading {} sectors from VHDx at index {}: {}",
-                    sector_count, sector_index, e
-                ),
-            )
-        })
+            std::io::Error::other(format!(
+                "Failed reading {sector_count} sectors from VHDx at index {sector_index}: {e}"
+            ))
+        })?;
+
+        self.current_offset = self.current_offset.checked_add(result as u64).unwrap();
+
+        Ok(result)
     }
 }
 
@@ -121,21 +131,17 @@ impl Write for Vhdx {
     /// Wrapper function to satisfy Write trait implementation for VHDx disk.
     /// Convert the offset to sector index and buffer length to sector count.
     fn write(&mut self, buf: &[u8]) -> std::result::Result<usize, std::io::Error> {
-        let sector_count =
-            div_round_up!(buf.len() as u64, self.disk_spec.logical_sector_size as u64);
+        let sector_count = (buf.len() as u64).div_ceil(self.disk_spec.logical_sector_size as u64);
         let sector_index = self.current_offset / self.disk_spec.logical_sector_size as u64;
 
         if self.first_write {
             self.first_write = false;
-            self.vhdx_header.update(&mut self.file).map_err(|e| {
-                std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    format!("Failed to update VHDx header: {}", e),
-                )
-            })?;
+            self.vhdx_header
+                .update(&mut self.file)
+                .map_err(|e| std::io::Error::other(format!("Failed to update VHDx header: {e}")))?;
         }
 
-        vhdx_io::write(
+        let result = vhdx_io::write(
             &mut self.file,
             buf,
             &mut self.disk_spec,
@@ -145,14 +151,14 @@ impl Write for Vhdx {
             sector_count,
         )
         .map_err(|e| {
-            std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!(
-                    "Failed writing {} sectors on VHDx at index {}: {}",
-                    sector_count, sector_index, e
-                ),
-            )
-        })
+            std::io::Error::other(format!(
+                "Failed writing {sector_count} sectors on VHDx at index {sector_index}: {e}"
+            ))
+        })?;
+
+        self.current_offset = self.current_offset.checked_add(result as u64).unwrap();
+
+        Ok(result)
     }
 }
 
@@ -181,11 +187,11 @@ impl Seek for Vhdx {
             }
         };
 
-        if let Some(o) = new_offset {
-            if o <= self.virtual_disk_size() {
-                self.current_offset = o;
-                return Ok(o);
-            }
+        if let Some(o) = new_offset
+            && o <= self.virtual_disk_size()
+        {
+            self.current_offset = o;
+            return Ok(o);
         }
 
         Err(std::io::Error::new(
@@ -195,6 +201,12 @@ impl Seek for Vhdx {
     }
 }
 
+impl BlockBackend for Vhdx {
+    fn size(&self) -> std::result::Result<u64, crate::Error> {
+        Ok(self.virtual_disk_size())
+    }
+}
+
 impl Clone for Vhdx {
     fn clone(&self) -> Self {
         Vhdx {
@@ -210,3 +222,21 @@ impl Clone for Vhdx {
         }
     }
 }
+
+impl AsRawFd for Vhdx {
+    fn as_raw_fd(&self) -> RawFd {
+        self.file.as_raw_fd()
+    }
+}
+
+pub(crate) fn uuid_from_guid(buf: &[u8]) -> Uuid {
+    // The first 3 fields of UUID are stored in Big Endian format, and
+    // the last 8 bytes are stored as byte array. Therefore, we read the
+    // first 3 fields in Big Endian format instead of Little Endian.
+    Uuid::from_fields_le(
+        BigEndian::read_u32(&buf[0..4]),
+        BigEndian::read_u16(&buf[4..6]),
+        BigEndian::read_u16(&buf[6..8]),
+        buf[8..16].try_into().unwrap(),
+    )
+}

block/src/vhdx/vhdx_bat.rs

@@ -2,15 +2,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhdx_header::RegionTableEntry;
-use crate::vhdx_metadata::DiskSpec;
-use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
-use remain::sorted;
 use std::fs::File;
 use std::io::{self, Seek, SeekFrom};
 use std::mem::size_of;
+
+use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+use remain::sorted;
 use thiserror::Error;
 
+use crate::vhdx::vhdx_header::RegionTableEntry;
+use crate::vhdx::vhdx_metadata::DiskSpec;
+
 // Payload BAT Entry States
 pub const PAYLOAD_BLOCK_NOT_PRESENT: u64 = 0;
 pub const PAYLOAD_BLOCK_UNDEFINED: u64 = 1;
@@ -31,9 +33,9 @@ pub enum VhdxBatError {
     InvalidBatEntry,
     #[error("Invalid BAT entry count")]
     InvalidEntryCount,
-    #[error("Failed to read BAT entry {0}")]
+    #[error("Failed to read BAT entry")]
     ReadBat(#[source] io::Error),
-    #[error("Failed to write BAT entry {0}")]
+    #[error("Failed to write BAT entry")]
     WriteBat(#[source] io::Error),
 }
 
@@ -76,7 +78,7 @@ impl BatEntry {
 
     // Calculate the number of entries in the BAT
     fn calculate_entries(block_size: u32, virtual_disk_size: u64, chunk_ratio: u64) -> u64 {
-        let data_blocks_count = div_round_up!(virtual_disk_size, block_size as u64);
+        let data_blocks_count = virtual_disk_size.div_ceil(block_size as u64);
         data_blocks_count + (data_blocks_count - 1) / chunk_ratio
     }
 

block/src/vhdx/vhdx_header.rs

@@ -4,13 +4,13 @@
 
 extern crate log;
 
-use byteorder::{ByteOrder, LittleEndian, ReadBytesExt};
-use remain::sorted;
 use std::collections::btree_map::BTreeMap;
-use std::convert::TryInto;
 use std::fs::File;
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::mem::size_of;
+
+use byteorder::{ByteOrder, LittleEndian, ReadBytesExt};
+use remain::sorted;
 use thiserror::Error;
 use uuid::Uuid;
 
@@ -81,7 +81,7 @@ pub enum VhdxHeaderError {
     SeekRegionTableEntries(#[source] io::Error),
     #[error("Failed to seek in region table header {0}")]
     SeekRegionTableHeader(#[source] io::Error),
-    #[error("We do not recongize this entry")]
+    #[error("We do not recognize this entry")]
     UnrecognizedRegionEntry,
     #[error("Failed to write header {0}")]
     WriteHeader(#[source] io::Error),
@@ -91,7 +91,7 @@ pub type Result<T> = std::result::Result<T, VhdxHeaderError>;
 
 #[derive(Clone, Debug)]
 pub struct FileTypeIdentifier {
-    pub signature: u64,
+    pub _signature: u64,
 }
 
 impl FileTypeIdentifier {
@@ -99,18 +99,18 @@ impl FileTypeIdentifier {
     pub fn new(f: &mut File) -> Result<FileTypeIdentifier> {
         f.seek(SeekFrom::Start(FILE_START))
             .map_err(VhdxHeaderError::SeekFileTypeIdentifier)?;
-        let signature = f
+        let _signature = f
             .read_u64::<LittleEndian>()
             .map_err(VhdxHeaderError::ReadFileTypeIdentifier)?;
-        if signature != VHDX_SIGN {
+        if _signature != VHDX_SIGN {
             return Err(VhdxHeaderError::InvalidVHDXSign);
         }
 
-        Ok(FileTypeIdentifier { signature })
+        Ok(FileTypeIdentifier { _signature })
     }
 }
 
-#[repr(packed)]
+#[repr(C, packed)]
 #[derive(Clone, Copy, Debug)]
 pub struct Header {
     pub signature: u32,
@@ -128,7 +128,7 @@ pub struct Header {
 impl Header {
     /// Reads the Header structure from a reference VHDx file
     pub fn new(f: &mut File, start: u64) -> Result<Header> {
-        // Read the whole header in to a buffer. We will need it for
+        // Read the whole header into a buffer. We will need it for
         // calculating checksum.
         let mut buffer = [0; HEADER_SIZE as usize];
         f.seek(SeekFrom::Start(start))
@@ -136,12 +136,13 @@ impl Header {
         f.read_exact(&mut buffer)
             .map_err(VhdxHeaderError::ReadHeader)?;
 
+        // SAFETY: buffer is of correct size and has been successfully filled.
         let header = unsafe { *(buffer.as_ptr() as *mut Header) };
         if header.signature != HEADER_SIGN {
             return Err(VhdxHeaderError::InvalidHeaderSign);
         }
 
-        let new_checksum = calculate_checksum(&mut buffer, size_of::<u32>())?;
+        let new_checksum = calculate_checksum(&mut buffer, size_of::<u32>());
         if header.checksum != new_checksum {
             return Err(VhdxHeaderError::InvalidChecksum(String::from("Header")));
         }
@@ -150,7 +151,8 @@ impl Header {
     }
 
     /// Converts the header structure into a buffer
-    fn get_header_as_buffer(&self, buffer: &mut [u8; HEADER_SIZE as usize]) {
+    fn write_to_buffer(&self, buffer: &mut [u8; HEADER_SIZE as usize]) {
+        // SAFETY: self is a valid header.
         let reference = unsafe {
             std::slice::from_raw_parts(self as *const Header as *const u8, HEADER_SIZE as usize)
         };
@@ -158,7 +160,7 @@ impl Header {
     }
 
     /// Creates and returns new updated header from the provided current header
-    pub fn update_header(
+    fn update_header(
         f: &mut File,
         current_header: &Header,
         change_data_guid: bool,
@@ -189,9 +191,9 @@ impl Header {
             log_offset: current_header.log_offset,
         };
 
-        new_header.get_header_as_buffer(&mut buffer);
-        new_header.checksum = crc32c::crc32c(&buffer);
-        new_header.get_header_as_buffer(&mut buffer);
+        new_header.write_to_buffer(&mut buffer);
+        new_header.checksum = calculate_checksum(&mut buffer, size_of::<u32>());
+        new_header.write_to_buffer(&mut buffer);
 
         f.seek(SeekFrom::Start(start))
             .map_err(VhdxHeaderError::SeekHeader)?;
@@ -201,7 +203,7 @@ impl Header {
     }
 }
 
-#[repr(packed)]
+#[repr(C, packed)]
 #[derive(Clone, Copy, Debug)]
 struct RegionTableHeader {
     pub signature: u32,
@@ -221,12 +223,13 @@ impl RegionTableHeader {
         f.read_exact(&mut buffer)
             .map_err(VhdxHeaderError::ReadRegionTableHeader)?;
 
+        // SAFETY: buffer is of correct size and has been successfully filled.
         let region_table_header = unsafe { *(buffer.as_ptr() as *mut RegionTableHeader) };
         if region_table_header.signature != REGION_SIGN {
             return Err(VhdxHeaderError::InvalidRegionSign);
         }
 
-        let new_checksum = calculate_checksum(&mut buffer, size_of::<u32>())?;
+        let new_checksum = calculate_checksum(&mut buffer, size_of::<u32>());
         if region_table_header.checksum != new_checksum {
             return Err(VhdxHeaderError::InvalidChecksum(String::from("Region")));
         }
@@ -302,7 +305,7 @@ impl RegionInfo {
 
             if (entry.required & REGION_ENTRY_REQUIRED) == 1 {
                 // This implementation doesn't recognize this field.
-                // Therefore, accoding to the spec, we are throwing an error.
+                // Therefore, according to the spec, we are throwing an error.
                 return Err(VhdxHeaderError::UnrecognizedRegionEntry);
             }
         }
@@ -325,7 +328,7 @@ impl RegionInfo {
     }
 }
 
-#[repr(packed)]
+#[repr(C, packed)]
 #[derive(Clone, Copy, Debug)]
 pub struct RegionTableEntry {
     pub guid: Uuid,
@@ -337,21 +340,17 @@ pub struct RegionTableEntry {
 impl RegionTableEntry {
     /// Reads one Region Entry from a Region Table index that starts from 0
     pub fn new(buffer: &[u8]) -> Result<RegionTableEntry> {
+        assert!(buffer.len() == std::mem::size_of::<RegionTableEntry>());
+        // SAFETY: the assertion above makes sure the buffer size is correct.
         let mut region_table_entry = unsafe { *(buffer.as_ptr() as *mut RegionTableEntry) };
 
-        let uuid = crate::uuid_from_guid(buffer).map_err(VhdxHeaderError::InvalidUuid)?;
+        let uuid = crate::vhdx::uuid_from_guid(buffer);
         region_table_entry.guid = uuid;
 
         Ok(region_table_entry)
     }
 }
 
-#[derive(Clone, Debug)]
-struct RegionEntry {
-    _start: u64,
-    _end: u64,
-}
-
 enum HeaderNo {
     First,
     Second,
@@ -370,22 +369,10 @@ pub struct VhdxHeader {
 impl VhdxHeader {
     /// Creates a VhdxHeader from a reference to a file
     pub fn new(f: &mut File) -> Result<VhdxHeader> {
-        let _file_type_identifier: FileTypeIdentifier = FileTypeIdentifier::new(f)?;
-        let header_1 = Header::new(f, HEADER_1_START);
-        let header_2 = Header::new(f, HEADER_2_START);
-
-        let mut file_write_guid: u128 = 0;
-        let metadata = f.metadata().map_err(VhdxHeaderError::ReadMetadata)?;
-        if !metadata.permissions().readonly() {
-            file_write_guid = Uuid::new_v4().as_u128();
-        }
-
-        let (header_1, header_2) =
-            VhdxHeader::update_headers(f, header_1, header_2, file_write_guid)?;
         Ok(VhdxHeader {
-            _file_type_identifier,
-            header_1,
-            header_2,
+            _file_type_identifier: FileTypeIdentifier::new(f)?,
+            header_1: Header::new(f, HEADER_1_START)?,
+            header_2: Header::new(f, HEADER_2_START)?,
             region_table_1: RegionTableHeader::new(f, REGION_TABLE_1_START)?,
             _region_table_2: RegionTableHeader::new(f, REGION_TABLE_2_START)?,
         })
@@ -397,26 +384,20 @@ impl VhdxHeader {
         header_1: Result<Header>,
         header_2: Result<Header>,
     ) -> Result<(HeaderNo, Header)> {
-        let mut header1_seq_num: u64 = 0;
-        let mut header2_seq_num: u64 = 0;
-        let mut valid_hdr_found: bool = false;
+        let header_1 = header_1.ok();
+        let header_2 = header_2.ok();
 
-        if let Ok(ref header_1) = header_1 {
-            valid_hdr_found = true;
-            header1_seq_num = header_1.sequence_number;
-        }
-
-        if let Ok(ref header_2) = header_2 {
-            valid_hdr_found = true;
-            header2_seq_num = header_2.sequence_number;
-        }
-
-        if !valid_hdr_found {
-            Err(VhdxHeaderError::NoValidHeader)
-        } else if header1_seq_num >= header2_seq_num {
-            Ok((HeaderNo::First, header_1.unwrap()))
-        } else {
-            Ok((HeaderNo::Second, header_2.unwrap()))
+        match (header_1, header_2) {
+            (None, None) => Err(VhdxHeaderError::NoValidHeader),
+            (Some(header_1), None) => Ok((HeaderNo::First, header_1)),
+            (None, Some(header_2)) => Ok((HeaderNo::Second, header_2)),
+            (Some(header_1), Some(header_2)) => {
+                if header_1.sequence_number >= header_2.sequence_number {
+                    Ok((HeaderNo::First, header_1))
+                } else {
+                    Ok((HeaderNo::Second, header_2))
+                }
+            }
         }
     }
 
@@ -445,7 +426,7 @@ impl VhdxHeader {
         }
     }
 
-    // Update the provided headers accoding to the spec
+    // Update the provided headers according to the spec
     fn update_headers(
         f: &mut File,
         header_1: Result<Header>,
@@ -469,21 +450,22 @@ impl VhdxHeader {
     }
 }
 
-/// Calculates the checksum of a buffer that itself containts its checksum
+/// Calculates the checksum of a buffer that itself contains its checksum
 /// Therefore, before calculating, the existing checksum is retrieved and the
 /// corresponding field is made zero. After the calculation, the existing checksum
 /// is put back to the buffer.
-pub fn calculate_checksum(buffer: &mut [u8], csum_offset: usize) -> Result<u32> {
-    // Read the checksum into a mutable slice
-    let csum_buf = &mut buffer[csum_offset..csum_offset + 4];
-    // Convert the checksum chunk in to a u32 integer
-    let orig_csum = LittleEndian::read_u32(csum_buf);
+fn calculate_checksum(buffer: &mut [u8], csum_offset: usize) -> u32 {
+    // Read the original checksum from the buffer
+    let orig_csum = LittleEndian::read_u32(&buffer[csum_offset..csum_offset + 4]);
     // Zero the checksum in the buffer
-    LittleEndian::write_u32(csum_buf, 0);
+    LittleEndian::write_u32(&mut buffer[csum_offset..csum_offset + 4], 0);
     // Calculate the checksum on the resulting buffer
-    let new_csum = crc32c::crc32c(buffer);
+    let mut crc = crc_any::CRC::crc32c();
+    crc.digest(&buffer);
+    let new_csum = crc.get_crc() as u32;
+
     // Put back the original checksum in the buffer
     LittleEndian::write_u32(&mut buffer[csum_offset..csum_offset + 4], orig_csum);
 
-    Ok(new_csum)
+    new_csum
 }

block/src/vhdx/vhdx_io.rs

@@ -0,0 +1,219 @@
+// Copyright © 2021 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
+use std::fs::File;
+use std::io::{self, Read, Seek, SeekFrom, Write};
+
+use remain::sorted;
+use thiserror::Error;
+
+use crate::vhdx::vhdx_bat::{self, BatEntry, VhdxBatError};
+use crate::vhdx::vhdx_metadata::{self, DiskSpec};
+
+const SECTOR_SIZE: u64 = 512;
+
+#[sorted]
+#[derive(Error, Debug)]
+pub enum VhdxIoError {
+    #[error("Invalid BAT entry state")]
+    InvalidBatEntryState,
+    #[error("Invalid BAT entry count")]
+    InvalidBatIndex,
+    #[error("Invalid disk size")]
+    InvalidDiskSize,
+    #[error("Failed reading sector blocks from file {0}")]
+    ReadSectorBlock(#[source] io::Error),
+    #[error("Failed changing file length {0}")]
+    ResizeFile(#[source] io::Error),
+    #[error("Differencing mode is not supported yet")]
+    UnsupportedMode,
+    #[error("Failed writing BAT to file {0}")]
+    WriteBat(#[source] VhdxBatError),
+}
+
+pub type Result<T> = std::result::Result<T, VhdxIoError>;
+
+macro_rules! align {
+    ($n:expr, $align:expr) => {{ $n.div_ceil($align) * $align }};
+}
+
+#[derive(Default)]
+struct Sector {
+    bat_index: u64,
+    free_sectors: u64,
+    free_bytes: u64,
+    file_offset: u64,
+    block_offset: u64,
+}
+
+impl Sector {
+    /// Translate sector index and count of data in file to actual offsets and
+    /// BAT index.
+    pub fn new(
+        disk_spec: &DiskSpec,
+        bat: &[BatEntry],
+        sector_index: u64,
+        sector_count: u64,
+    ) -> Result<Sector> {
+        let mut sector = Sector::default();
+
+        sector.bat_index = sector_index / disk_spec.sectors_per_block as u64;
+        sector.block_offset = sector_index % disk_spec.sectors_per_block as u64;
+        sector.free_sectors = disk_spec.sectors_per_block as u64 - sector.block_offset;
+        if sector.free_sectors > sector_count {
+            sector.free_sectors = sector_count;
+        }
+
+        sector.free_bytes = sector.free_sectors * disk_spec.logical_sector_size as u64;
+        sector.block_offset *= disk_spec.logical_sector_size as u64;
+
+        let bat_entry = match bat.get(sector.bat_index as usize) {
+            Some(entry) => entry.0,
+            None => {
+                return Err(VhdxIoError::InvalidBatIndex);
+            }
+        };
+        sector.file_offset = bat_entry & vhdx_bat::BAT_FILE_OFF_MASK;
+        if sector.file_offset != 0 {
+            sector.file_offset += sector.block_offset;
+        }
+
+        Ok(sector)
+    }
+}
+
+/// VHDx IO read routine: requires relative sector index and count for the
+/// requested data.
+pub fn read(
+    f: &mut File,
+    buf: &mut [u8],
+    disk_spec: &DiskSpec,
+    bat: &[BatEntry],
+    mut sector_index: u64,
+    mut sector_count: u64,
+) -> Result<usize> {
+    if disk_spec.has_parent {
+        return Err(VhdxIoError::UnsupportedMode);
+    }
+
+    let mut read_count: usize = 0;
+    while sector_count > 0 {
+        let sector = Sector::new(disk_spec, bat, sector_index, sector_count)?;
+
+        let bat_entry = match bat.get(sector.bat_index as usize) {
+            Some(entry) => entry.0,
+            None => {
+                return Err(VhdxIoError::InvalidBatIndex);
+            }
+        };
+
+        match bat_entry & vhdx_bat::BAT_STATE_BIT_MASK {
+            vhdx_bat::PAYLOAD_BLOCK_NOT_PRESENT
+            | vhdx_bat::PAYLOAD_BLOCK_UNDEFINED
+            | vhdx_bat::PAYLOAD_BLOCK_UNMAPPED
+            | vhdx_bat::PAYLOAD_BLOCK_ZERO => {}
+            vhdx_bat::PAYLOAD_BLOCK_FULLY_PRESENT => {
+                f.seek(SeekFrom::Start(sector.file_offset))
+                    .map_err(VhdxIoError::ReadSectorBlock)?;
+                f.read_exact(
+                    &mut buf
+                        [read_count..(read_count + (sector.free_sectors * SECTOR_SIZE) as usize)],
+                )
+                .map_err(VhdxIoError::ReadSectorBlock)?;
+            }
+            vhdx_bat::PAYLOAD_BLOCK_PARTIALLY_PRESENT => {
+                return Err(VhdxIoError::UnsupportedMode);
+            }
+            _ => {
+                return Err(VhdxIoError::InvalidBatEntryState);
+            }
+        };
+        sector_count -= sector.free_sectors;
+        sector_index += sector.free_sectors;
+        read_count += sector.free_bytes as usize;
+    }
+    Ok(read_count)
+}
+
+/// VHDx IO write routine: requires relative sector index and count for the
+/// requested data.
+pub fn write(
+    f: &mut File,
+    buf: &[u8],
+    disk_spec: &mut DiskSpec,
+    bat_offset: u64,
+    bat: &mut [BatEntry],
+    mut sector_index: u64,
+    mut sector_count: u64,
+) -> Result<usize> {
+    if disk_spec.has_parent {
+        return Err(VhdxIoError::UnsupportedMode);
+    }
+
+    let mut write_count: usize = 0;
+    while sector_count > 0 {
+        let sector = Sector::new(disk_spec, bat, sector_index, sector_count)?;
+
+        let bat_entry = match bat.get(sector.bat_index as usize) {
+            Some(entry) => entry.0,
+            None => {
+                return Err(VhdxIoError::InvalidBatIndex);
+            }
+        };
+
+        match bat_entry & vhdx_bat::BAT_STATE_BIT_MASK {
+            vhdx_bat::PAYLOAD_BLOCK_NOT_PRESENT
+            | vhdx_bat::PAYLOAD_BLOCK_UNDEFINED
+            | vhdx_bat::PAYLOAD_BLOCK_UNMAPPED
+            | vhdx_bat::PAYLOAD_BLOCK_ZERO => {
+                let file_offset =
+                    align!(disk_spec.image_size, vhdx_metadata::BLOCK_SIZE_MIN as u64);
+                let new_size = file_offset
+                    .checked_add(disk_spec.block_size as u64)
+                    .ok_or(VhdxIoError::InvalidDiskSize)?;
+
+                f.set_len(new_size).map_err(VhdxIoError::ResizeFile)?;
+                disk_spec.image_size = new_size;
+
+                let new_bat_entry = file_offset
+                    | (vhdx_bat::PAYLOAD_BLOCK_FULLY_PRESENT & vhdx_bat::BAT_STATE_BIT_MASK);
+                bat[sector.bat_index as usize] = BatEntry(new_bat_entry);
+                BatEntry::write_bat_entries(f, bat_offset, bat).map_err(VhdxIoError::WriteBat)?;
+
+                if file_offset < vhdx_metadata::BLOCK_SIZE_MIN as u64 {
+                    break;
+                }
+
+                f.seek(SeekFrom::Start(file_offset))
+                    .map_err(VhdxIoError::ReadSectorBlock)?;
+                f.write_all(
+                    &buf[write_count..(write_count + (sector.free_sectors * SECTOR_SIZE) as usize)],
+                )
+                .map_err(VhdxIoError::ReadSectorBlock)?;
+            }
+            vhdx_bat::PAYLOAD_BLOCK_FULLY_PRESENT => {
+                if sector.file_offset < vhdx_metadata::BLOCK_SIZE_MIN as u64 {
+                    break;
+                }
+
+                f.seek(SeekFrom::Start(sector.file_offset))
+                    .map_err(VhdxIoError::ReadSectorBlock)?;
+                f.write_all(
+                    &buf[write_count..(write_count + (sector.free_sectors * SECTOR_SIZE) as usize)],
+                )
+                .map_err(VhdxIoError::ReadSectorBlock)?;
+            }
+            vhdx_bat::PAYLOAD_BLOCK_PARTIALLY_PRESENT => {
+                return Err(VhdxIoError::UnsupportedMode);
+            }
+            _ => {
+                return Err(VhdxIoError::InvalidBatEntryState);
+            }
+        };
+        sector_count -= sector.free_sectors;
+        sector_index += sector.free_sectors;
+        write_count += sector.free_bytes as usize;
+    }
+    Ok(write_count)
+}

block/src/vhdx/vhdx_metadata.rs

@@ -2,15 +2,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhdx_header::RegionTableEntry;
-use byteorder::{LittleEndian, ReadBytesExt};
-use remain::sorted;
 use std::fs::File;
 use std::io::{self, Read, Seek, SeekFrom};
 use std::mem::size_of;
+
+use byteorder::{LittleEndian, ReadBytesExt};
+use remain::sorted;
 use thiserror::Error;
 use uuid::Uuid;
 
+use crate::vhdx::vhdx_header::RegionTableEntry;
+
 const METADATA_SIGN: u64 = 0x6174_6164_6174_656D;
 const METADATA_ENTRY_SIZE: usize = 32;
 const METADATA_MAX_ENTRIES: u16 = 2047;
@@ -53,6 +55,8 @@ const METADATA_LENGTH_MAX: u32 = 1 << 20; // 1 MiB
 pub enum VhdxMetadataError {
     #[error("Invalid block size count")]
     InvalidBlockSize,
+    #[error("Invalid disk size {0}")]
+    InvalidDiskSize(u64),
     #[error("Invalid metadata entry count")]
     InvalidEntryCount,
     #[error("Invalid logical sector size")]
@@ -96,7 +100,7 @@ pub struct DiskSpec {
 }
 
 impl DiskSpec {
-    /// Parse all meatadata from the provided file and store info in DiskSpec
+    /// Parse all metadata from the provided file and store info in DiskSpec
     /// structure.
     pub fn new(f: &mut File, metadata_region: &RegionTableEntry) -> Result<DiskSpec> {
         let mut disk_spec = DiskSpec::default();
@@ -133,7 +137,7 @@ impl DiskSpec {
                     .map_err(VhdxMetadataError::ReadMetadata)?;
 
                 // MUST be at least 1 MiB and not greater than 256 MiB
-                if disk_spec.block_size < BLOCK_SIZE_MIN && disk_spec.block_size > BLOCK_SIZE_MAX {
+                if disk_spec.block_size < BLOCK_SIZE_MIN || disk_spec.block_size > BLOCK_SIZE_MAX {
                     return Err(VhdxMetadataError::InvalidBlockSize);
                 }
 
@@ -145,11 +149,7 @@ impl DiskSpec {
                 let bits = f
                     .read_u32::<LittleEndian>()
                     .map_err(VhdxMetadataError::ReadMetadata)?;
-                if bits & BLOCK_HAS_PARENT != 0 {
-                    disk_spec.has_parent = true;
-                } else {
-                    disk_spec.has_parent = false;
-                }
+                disk_spec.has_parent = bits & BLOCK_HAS_PARENT != 0;
 
                 metadata_presence |= METADATA_FILE_PARAMETER_PRESENT;
             } else if metadata_entry.item_id
@@ -216,6 +216,14 @@ impl DiskSpec {
         if metadata_presence != METADATA_ALL_PRESENT {
             return Err(VhdxMetadataError::MissingMetadata);
         }
+        // Make sure virtual disk size is not zero
+        if (metadata_presence & METADATA_VIRTUAL_DISK_SIZE_PRESENT != 0)
+            && disk_spec.virtual_disk_size == 0
+        {
+            return Err(VhdxMetadataError::InvalidDiskSize(
+                disk_spec.virtual_disk_size,
+            ));
+        }
         // Check if the virtual disk size is a multiple of the logical sector
         // size.
         if ((metadata_presence & METADATA_LOGICAL_SECTOR_SIZE_PRESENT) != 0)
@@ -259,7 +267,7 @@ impl DiskSpec {
     }
 }
 
-#[repr(packed)]
+#[repr(C, packed)]
 #[derive(Default, Debug, Clone, Copy)]
 struct MetadataTableHeader {
     signature: u64,
@@ -270,6 +278,8 @@ struct MetadataTableHeader {
 
 impl MetadataTableHeader {
     pub fn new(buffer: &[u8]) -> Result<MetadataTableHeader> {
+        assert!(buffer.len() == std::mem::size_of::<MetadataTableHeader>());
+        // SAFETY: the assertion above makes sure the buffer size is correct.
         let metadata_table_header = unsafe { *(buffer.as_ptr() as *mut MetadataTableHeader) };
 
         if metadata_table_header.signature != METADATA_SIGN {
@@ -288,7 +298,7 @@ impl MetadataTableHeader {
     }
 }
 
-#[repr(packed)]
+#[repr(C, packed)]
 #[derive(Default, Debug, Clone, Copy)]
 pub struct MetadataTableEntry {
     item_id: Uuid,
@@ -301,9 +311,11 @@ pub struct MetadataTableEntry {
 impl MetadataTableEntry {
     /// Parse one metadata entry from the buffer
     fn new(buffer: &[u8]) -> Result<MetadataTableEntry> {
+        assert!(buffer.len() == std::mem::size_of::<MetadataTableEntry>());
+        // SAFETY: the assertion above makes sure the buffer size is correct.
         let mut metadata_table_entry = unsafe { *(buffer.as_ptr() as *mut MetadataTableEntry) };
 
-        let uuid = crate::uuid_from_guid(buffer).map_err(VhdxMetadataError::InvalidUuid)?;
+        let uuid = crate::vhdx::uuid_from_guid(buffer);
         metadata_table_entry.item_id = uuid;
 
         if metadata_table_entry.length > METADATA_LENGTH_MAX {

block/src/vhdx_sync.rs

@@ -2,28 +2,33 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-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};
+use std::os::fd::AsRawFd;
+
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::AsyncAdaptor;
+use crate::async_io::{
+    AsyncIo, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
+};
+use crate::vhdx::{Result as VhdxResult, Vhdx};
+
 pub struct VhdxDiskSync {
-    vhdx_file: Arc<Mutex<Vhdx>>,
+    vhdx_file: Vhdx,
 }
 
 impl VhdxDiskSync {
     pub fn new(f: File) -> VhdxResult<Self> {
         Ok(VhdxDiskSync {
-            vhdx_file: Arc::new(Mutex::new(Vhdx::new(f)?)),
+            vhdx_file: Vhdx::new(f)?,
         })
     }
 }
 
 impl DiskFile for VhdxDiskSync {
     fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self.vhdx_file.lock().unwrap().virtual_disk_size())
+        Ok(self.vhdx_file.virtual_disk_size())
     }
 
     fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
@@ -32,29 +37,29 @@ impl DiskFile for VhdxDiskSync {
                 as Box<dyn AsyncIo>,
         )
     }
+
+    fn fd(&mut self) -> BorrowedDiskFd<'_> {
+        BorrowedDiskFd::new(self.vhdx_file.as_raw_fd())
+    }
 }
 
 pub struct VhdxSync {
-    vhdx_file: Arc<Mutex<Vhdx>>,
+    vhdx_file: Vhdx,
     eventfd: EventFd,
-    completion_list: Vec<(u64, i32)>,
+    completion_list: VecDeque<(u64, i32)>,
 }
 
 impl VhdxSync {
-    pub fn new(vhdx_file: Arc<Mutex<Vhdx>>) -> std::io::Result<Self> {
+    pub fn new(vhdx_file: Vhdx) -> std::io::Result<Self> {
         Ok(VhdxSync {
             vhdx_file,
             eventfd: EventFd::new(libc::EFD_NONBLOCK)?,
-            completion_list: Vec::new(),
+            completion_list: VecDeque::new(),
         })
     }
 }
 
-impl AsyncAdaptor<Vhdx> for Arc<Mutex<Vhdx>> {
-    fn file(&mut self) -> MutexGuard<Vhdx> {
-        self.lock().unwrap()
-    }
-}
+impl AsyncAdaptor for Vhdx {}
 
 impl AsyncIo for VhdxSync {
     fn notifier(&self) -> &EventFd {
@@ -64,7 +69,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 +84,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 +101,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()
     }
 }

block_util/Cargo.toml

@@ -1,24 +0,0 @@
-[package]
-name = "block_util"
-version = "0.1.0"
-authors = ["The Cloud Hypervisor Authors"]
-edition = "2018"
-
-[features]
-default = []
-
-[dependencies]
-io-uring = "0.5.2"
-libc = "0.2.112"
-log = "0.4.14"
-qcow = { path = "../qcow" }
-thiserror = "1.0.30"
-versionize = "0.1.6"
-versionize_derive = "0.1.4"
-vhdx = { path = "../vhdx" }
-virtio-bindings = { version = "0.1.0", features = ["virtio-v5_0_0"] }
-virtio-queue = { path = "../virtio-queue" }
-vm-memory = { version = "0.7.0", features = ["backend-mmap", "backend-atomic", "backend-bitmap"] }
-vm-virtio = { path = "../vm-virtio" }
-vmm-sys-util = "0.9.0"
-

block_util/src/async_io.rs

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

block_util/src/lib.rs

@@ -1,686 +0,0 @@
-// Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-//
-// Portions Copyright 2017 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-BSD-3-Clause file.
-//
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-#[macro_use]
-extern crate log;
-
-pub mod async_io;
-pub mod fixed_vhd_async;
-pub mod fixed_vhd_sync;
-pub mod qcow_sync;
-pub mod raw_async;
-pub mod raw_sync;
-pub mod vhd;
-pub mod vhdx_sync;
-
-use crate::async_io::{AsyncIo, AsyncIoError, AsyncIoResult};
-use io_uring::{opcode, IoUring, Probe};
-use std::alloc::{alloc_zeroed, dealloc, Layout};
-use std::cmp;
-use std::convert::TryInto;
-use std::fs::File;
-use std::io::{self, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
-use std::os::linux::fs::MetadataExt;
-use std::path::Path;
-use std::result;
-use std::sync::MutexGuard;
-use versionize::{VersionMap, Versionize, VersionizeResult};
-use versionize_derive::Versionize;
-use virtio_bindings::bindings::virtio_blk::*;
-use virtio_queue::DescriptorChain;
-use vm_memory::{
-    bitmap::AtomicBitmap, bitmap::Bitmap, ByteValued, Bytes, GuestAddress, GuestMemory,
-    GuestMemoryError, GuestMemoryLoadGuard,
-};
-use vmm_sys_util::eventfd::EventFd;
-
-type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
-
-const SECTOR_SHIFT: u8 = 9;
-pub const SECTOR_SIZE: u64 = 0x01 << SECTOR_SHIFT;
-
-#[derive(Debug)]
-pub enum Error {
-    /// Guest gave us bad memory addresses.
-    GuestMemory(GuestMemoryError),
-    /// Guest gave us offsets that would have overflowed a usize.
-    CheckedOffset(GuestAddress, usize),
-    /// Guest gave us a write only descriptor that protocol says to read from.
-    UnexpectedWriteOnlyDescriptor,
-    /// Guest gave us a read only descriptor that protocol says to write to.
-    UnexpectedReadOnlyDescriptor,
-    /// Guest gave us too few descriptors in a descriptor chain.
-    DescriptorChainTooShort,
-    /// Guest gave us a descriptor that was too short to use.
-    DescriptorLengthTooSmall,
-    /// Getting a block's metadata fails for any reason.
-    GetFileMetadata,
-    /// The requested operation would cause a seek beyond disk end.
-    InvalidOffset,
-    /// The requested operation does not support multiple descriptors.
-    TooManyDescriptors,
-}
-
-fn build_device_id(disk_path: &Path) -> result::Result<String, Error> {
-    let blk_metadata = match disk_path.metadata() {
-        Err(_) => return Err(Error::GetFileMetadata),
-        Ok(m) => m,
-    };
-    // This is how kvmtool does it.
-    let device_id = format!(
-        "{}{}{}",
-        blk_metadata.st_dev(),
-        blk_metadata.st_rdev(),
-        blk_metadata.st_ino()
-    );
-    Ok(device_id)
-}
-
-pub fn build_disk_image_id(disk_path: &Path) -> Vec<u8> {
-    let mut default_disk_image_id = vec![0; VIRTIO_BLK_ID_BYTES as usize];
-    match build_device_id(disk_path) {
-        Err(_) => {
-            warn!("Could not generate device id. We'll use a default.");
-        }
-        Ok(m) => {
-            // The kernel only knows to read a maximum of VIRTIO_BLK_ID_BYTES.
-            // This will also zero out any leftover bytes.
-            let disk_id = m.as_bytes();
-            let bytes_to_copy = cmp::min(disk_id.len(), VIRTIO_BLK_ID_BYTES as usize);
-            default_disk_image_id[..bytes_to_copy].clone_from_slice(&disk_id[..bytes_to_copy])
-        }
-    }
-    default_disk_image_id
-}
-
-#[derive(Debug)]
-pub enum ExecuteError {
-    BadRequest(Error),
-    Flush(io::Error),
-    Read(GuestMemoryError),
-    Seek(io::Error),
-    Write(GuestMemoryError),
-    Unsupported(u32),
-    SubmitIoUring(io::Error),
-    GetHostAddress(GuestMemoryError),
-    AsyncRead(AsyncIoError),
-    AsyncWrite(AsyncIoError),
-    AsyncFlush(AsyncIoError),
-    /// Failed allocating a temporary buffer.
-    TemporaryBufferAllocation(io::Error),
-}
-
-impl ExecuteError {
-    pub fn status(&self) -> u32 {
-        match *self {
-            ExecuteError::BadRequest(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::Flush(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::Read(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::Seek(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::Write(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::Unsupported(_) => VIRTIO_BLK_S_UNSUPP,
-            ExecuteError::SubmitIoUring(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::GetHostAddress(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::AsyncRead(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::AsyncWrite(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::AsyncFlush(_) => VIRTIO_BLK_S_IOERR,
-            ExecuteError::TemporaryBufferAllocation(_) => VIRTIO_BLK_S_IOERR,
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum RequestType {
-    In,
-    Out,
-    Flush,
-    GetDeviceId,
-    Unsupported(u32),
-}
-
-pub fn request_type(
-    mem: &GuestMemoryMmap,
-    desc_addr: GuestAddress,
-) -> result::Result<RequestType, Error> {
-    let type_ = mem.read_obj(desc_addr).map_err(Error::GuestMemory)?;
-    match type_ {
-        VIRTIO_BLK_T_IN => Ok(RequestType::In),
-        VIRTIO_BLK_T_OUT => Ok(RequestType::Out),
-        VIRTIO_BLK_T_FLUSH => Ok(RequestType::Flush),
-        VIRTIO_BLK_T_GET_ID => Ok(RequestType::GetDeviceId),
-        t => Ok(RequestType::Unsupported(t)),
-    }
-}
-
-fn sector(mem: &GuestMemoryMmap, desc_addr: GuestAddress) -> result::Result<u64, Error> {
-    const SECTOR_OFFSET: usize = 8;
-    let addr = match mem.checked_offset(desc_addr, SECTOR_OFFSET) {
-        Some(v) => v,
-        None => return Err(Error::CheckedOffset(desc_addr, SECTOR_OFFSET)),
-    };
-
-    mem.read_obj(addr).map_err(Error::GuestMemory)
-}
-
-#[derive(Debug)]
-pub struct AlignedOperation {
-    origin_ptr: u64,
-    aligned_ptr: u64,
-    size: usize,
-    layout: Layout,
-}
-
-#[derive(Debug)]
-pub struct Request {
-    pub request_type: RequestType,
-    pub sector: u64,
-    pub data_descriptors: Vec<(GuestAddress, u32)>,
-    pub status_addr: GuestAddress,
-    pub writeback: bool,
-    pub aligned_operations: Vec<AlignedOperation>,
-}
-
-impl Request {
-    pub fn parse(
-        desc_chain: &mut DescriptorChain<GuestMemoryLoadGuard<GuestMemoryMmap>>,
-    ) -> result::Result<Request, Error> {
-        let hdr_desc = desc_chain
-            .next()
-            .ok_or(Error::DescriptorChainTooShort)
-            .map_err(|e| {
-                error!("Missing head descriptor");
-                e
-            })?;
-
-        // The head contains the request type which MUST be readable.
-        if hdr_desc.is_write_only() {
-            return Err(Error::UnexpectedWriteOnlyDescriptor);
-        }
-
-        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(),
-            status_addr: GuestAddress(0),
-            writeback: true,
-            aligned_operations: Vec::new(),
-        };
-
-        let status_desc;
-        let mut desc = desc_chain
-            .next()
-            .ok_or(Error::DescriptorChainTooShort)
-            .map_err(|e| {
-                error!("Only head descriptor present: request = {:?}", req);
-                e
-            })?;
-
-        if !desc.has_next() {
-            status_desc = desc;
-            // Only flush requests are allowed to skip the data descriptor.
-            if req.request_type != RequestType::Flush {
-                error!("Need a data descriptor: request = {:?}", req);
-                return Err(Error::DescriptorChainTooShort);
-            }
-        } else {
-            while desc.has_next() {
-                if desc.is_write_only() && req.request_type == RequestType::Out {
-                    return Err(Error::UnexpectedWriteOnlyDescriptor);
-                }
-                if !desc.is_write_only() && req.request_type == RequestType::In {
-                    return Err(Error::UnexpectedReadOnlyDescriptor);
-                }
-                if !desc.is_write_only() && req.request_type == RequestType::GetDeviceId {
-                    return Err(Error::UnexpectedReadOnlyDescriptor);
-                }
-                req.data_descriptors.push((desc.addr(), desc.len()));
-                desc = desc_chain
-                    .next()
-                    .ok_or(Error::DescriptorChainTooShort)
-                    .map_err(|e| {
-                        error!("DescriptorChain corrupted: request = {:?}", req);
-                        e
-                    })?;
-            }
-            status_desc = desc;
-        }
-
-        // The status MUST always be writable.
-        if !status_desc.is_write_only() {
-            return Err(Error::UnexpectedReadOnlyDescriptor);
-        }
-
-        if status_desc.len() < 1 {
-            return Err(Error::DescriptorLengthTooSmall);
-        }
-
-        req.status_addr = status_desc.addr();
-
-        Ok(req)
-    }
-
-    pub fn execute<T: Seek + Read + Write>(
-        &self,
-        disk: &mut T,
-        disk_nsectors: u64,
-        mem: &GuestMemoryMmap,
-        disk_id: &[u8],
-    ) -> result::Result<u32, ExecuteError> {
-        disk.seek(SeekFrom::Start(self.sector << SECTOR_SHIFT))
-            .map_err(ExecuteError::Seek)?;
-        let mut len = 0;
-        for (data_addr, data_len) in &self.data_descriptors {
-            let mut top: u64 = u64::from(*data_len) / SECTOR_SIZE;
-            if u64::from(*data_len) % SECTOR_SIZE != 0 {
-                top += 1;
-            }
-            top = top
-                .checked_add(self.sector)
-                .ok_or(ExecuteError::BadRequest(Error::InvalidOffset))?;
-            if top > disk_nsectors {
-                return Err(ExecuteError::BadRequest(Error::InvalidOffset));
-            }
-
-            match self.request_type {
-                RequestType::In => {
-                    mem.read_exact_from(*data_addr, disk, *data_len as usize)
-                        .map_err(ExecuteError::Read)?;
-                    len += data_len;
-                }
-                RequestType::Out => {
-                    mem.write_all_to(*data_addr, disk, *data_len as usize)
-                        .map_err(ExecuteError::Write)?;
-                    if !self.writeback {
-                        disk.flush().map_err(ExecuteError::Flush)?;
-                    }
-                }
-                RequestType::Flush => disk.flush().map_err(ExecuteError::Flush)?,
-                RequestType::GetDeviceId => {
-                    if (*data_len as usize) < disk_id.len() {
-                        return Err(ExecuteError::BadRequest(Error::InvalidOffset));
-                    }
-                    mem.write_slice(disk_id, *data_addr)
-                        .map_err(ExecuteError::Write)?;
-                }
-                RequestType::Unsupported(t) => return Err(ExecuteError::Unsupported(t)),
-            };
-        }
-        Ok(len)
-    }
-
-    pub fn execute_async(
-        &mut self,
-        mem: &GuestMemoryMmap,
-        disk_nsectors: u64,
-        disk_image: &mut dyn AsyncIo,
-        disk_id: &[u8],
-        user_data: u64,
-    ) -> result::Result<bool, ExecuteError> {
-        let sector = self.sector;
-        let request_type = self.request_type;
-        let offset = (sector << SECTOR_SHIFT) as libc::off_t;
-
-        let mut iovecs = Vec::new();
-        for (data_addr, data_len) in &self.data_descriptors {
-            if *data_len == 0 {
-                continue;
-            }
-            let mut top: u64 = u64::from(*data_len) / SECTOR_SIZE;
-            if u64::from(*data_len) % SECTOR_SIZE != 0 {
-                top += 1;
-            }
-            top = top
-                .checked_add(sector)
-                .ok_or(ExecuteError::BadRequest(Error::InvalidOffset))?;
-            if top > disk_nsectors {
-                return Err(ExecuteError::BadRequest(Error::InvalidOffset));
-            }
-
-            let origin_ptr = mem
-                .get_slice(*data_addr, *data_len as usize)
-                .map_err(ExecuteError::GetHostAddress)?
-                .as_ptr();
-
-            // Verify the buffer alignment.
-            // In case it's not properly aligned, an intermediate buffer is
-            // created with the correct alignment, and a copy from/to the
-            // origin buffer is performed, depending on the type of operation.
-            let iov_base = if (origin_ptr as u64) % SECTOR_SIZE != 0 {
-                let layout =
-                    Layout::from_size_align(*data_len as usize, SECTOR_SIZE as usize).unwrap();
-                // Safe because layout has non-zero size
-                let aligned_ptr = unsafe { alloc_zeroed(layout) };
-                if aligned_ptr.is_null() {
-                    return Err(ExecuteError::TemporaryBufferAllocation(
-                        io::Error::last_os_error(),
-                    ));
-                }
-
-                // 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
-                    // the proper size.
-                    unsafe {
-                        std::ptr::copy(origin_ptr as *const u8, aligned_ptr, *data_len as usize)
-                    };
-                }
-
-                // Store both origin and aligned pointers for complete_async()
-                // to process them.
-                self.aligned_operations.push(AlignedOperation {
-                    origin_ptr: origin_ptr as u64,
-                    aligned_ptr: aligned_ptr as u64,
-                    size: *data_len as usize,
-                    layout,
-                });
-
-                aligned_ptr as *mut libc::c_void
-            } else {
-                origin_ptr as *mut libc::c_void
-            };
-
-            let iovec = libc::iovec {
-                iov_base,
-                iov_len: *data_len as libc::size_t,
-            };
-            iovecs.push(iovec);
-        }
-
-        // Queue operations expected to be submitted.
-        match request_type {
-            RequestType::In => {
-                for (data_addr, data_len) in &self.data_descriptors {
-                    mem.get_slice(*data_addr, *data_len as usize)
-                        .map_err(ExecuteError::GetHostAddress)?
-                        .bitmap()
-                        .mark_dirty(0, *data_len as usize);
-                }
-                disk_image
-                    .read_vectored(offset, iovecs, user_data)
-                    .map_err(ExecuteError::AsyncRead)?;
-            }
-            RequestType::Out => {
-                disk_image
-                    .write_vectored(offset, iovecs, user_data)
-                    .map_err(ExecuteError::AsyncWrite)?;
-            }
-            RequestType::Flush => {
-                disk_image
-                    .fsync(Some(user_data))
-                    .map_err(ExecuteError::AsyncFlush)?;
-            }
-            RequestType::GetDeviceId => {
-                let (data_addr, data_len) = if self.data_descriptors.len() == 1 {
-                    (self.data_descriptors[0].0, self.data_descriptors[0].1)
-                } else {
-                    return Err(ExecuteError::BadRequest(Error::TooManyDescriptors));
-                };
-                if (data_len as usize) < disk_id.len() {
-                    return Err(ExecuteError::BadRequest(Error::InvalidOffset));
-                }
-                mem.write_slice(disk_id, data_addr)
-                    .map_err(ExecuteError::Write)?;
-                return Ok(false);
-            }
-            RequestType::Unsupported(t) => return Err(ExecuteError::Unsupported(t)),
-        }
-
-        Ok(true)
-    }
-
-    pub fn complete_async(&mut self) -> result::Result<(), Error> {
-        for aligned_operation in self.aligned_operations.drain(..) {
-            // 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
-                // proper size.
-                unsafe {
-                    std::ptr::copy(
-                        aligned_operation.aligned_ptr as *const u8,
-                        aligned_operation.origin_ptr as *mut u8,
-                        aligned_operation.size,
-                    )
-                };
-            }
-
-            // Free the temporary aligned buffer.
-            // Safe because aligned_ptr was allocated by alloc_zeroed with the same
-            // layout
-            unsafe {
-                dealloc(
-                    aligned_operation.aligned_ptr as *mut u8,
-                    aligned_operation.layout,
-                )
-            };
-        }
-
-        Ok(())
-    }
-
-    pub fn set_writeback(&mut self, writeback: bool) {
-        self.writeback = writeback
-    }
-}
-
-#[derive(Copy, Clone, Debug, Default, Versionize)]
-#[repr(C, packed)]
-pub struct VirtioBlockConfig {
-    pub capacity: u64,
-    pub size_max: u32,
-    pub seg_max: u32,
-    pub geometry: VirtioBlockGeometry,
-    pub blk_size: u32,
-    pub physical_block_exp: u8,
-    pub alignment_offset: u8,
-    pub min_io_size: u16,
-    pub opt_io_size: u32,
-    pub writeback: u8,
-    pub unused: u8,
-    pub num_queues: u16,
-    pub max_discard_sectors: u32,
-    pub max_discard_seg: u32,
-    pub discard_sector_alignment: u32,
-    pub max_write_zeroes_sectors: u32,
-    pub max_write_zeroes_seg: u32,
-    pub write_zeroes_may_unmap: u8,
-    pub unused1: [u8; 3],
-}
-#[derive(Copy, Clone, Debug, Default, Versionize)]
-#[repr(C, packed)]
-pub struct VirtioBlockGeometry {
-    pub cylinders: u16,
-    pub heads: u8,
-    pub sectors: u8,
-}
-
-// SAFETY: these data structures only contain a series of integers
-unsafe impl ByteValued for VirtioBlockConfig {}
-unsafe impl ByteValued for VirtioBlockGeometry {}
-
-/// Check if io_uring for block device can be used on the current system, as
-/// it correctly supports the expected io_uring features.
-pub fn block_io_uring_is_supported() -> bool {
-    let error_msg = "io_uring not supported:";
-
-    // Check we can create an io_uring instance, which effectively verifies
-    // that io_uring_setup() syscall is supported.
-    let io_uring = match IoUring::new(1) {
-        Ok(io_uring) => io_uring,
-        Err(e) => {
-            info!("{} failed to create io_uring instance: {}", error_msg, e);
-            return false;
-        }
-    };
-
-    let submitter = io_uring.submitter();
-
-    let mut probe = Probe::new();
-
-    // Check we can register a probe to validate supported operations.
-    match submitter.register_probe(&mut probe) {
-        Ok(_) => {}
-        Err(e) => {
-            info!("{} failed to register a probe: {}", error_msg, e);
-            return false;
-        }
-    }
-
-    // Check IORING_OP_FSYNC is supported
-    if !probe.is_supported(opcode::Fsync::CODE) {
-        info!("{} IORING_OP_FSYNC operation not supported", error_msg);
-        return false;
-    }
-
-    // Check IORING_OP_READ is supported
-    if !probe.is_supported(opcode::Read::CODE) {
-        info!("{} IORING_OP_READ 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);
-        return false;
-    }
-
-    true
-}
-
-pub trait AsyncAdaptor<F>
-where
-    F: Read + Write + Seek,
-{
-    fn read_vectored_sync(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-        eventfd: &EventFd,
-        completion_list: &mut Vec<(u64, i32)>,
-    ) -> AsyncIoResult<()> {
-        // Convert libc::iovec into IoSliceMut
-        let mut slices = Vec::new();
-        for iovec in iovecs.iter() {
-            slices.push(IoSliceMut::new(unsafe { std::mem::transmute(*iovec) }));
-        }
-
-        let result = {
-            let mut file = self.file();
-
-            // Move the cursor to the right offset
-            file.seek(SeekFrom::Start(offset as u64))
-                .map_err(AsyncIoError::ReadVectored)?;
-
-            // Read vectored
-            file.read_vectored(slices.as_mut_slice())
-                .map_err(AsyncIoError::ReadVectored)?
-        };
-
-        completion_list.push((user_data, result as i32));
-        eventfd.write(1).unwrap();
-
-        Ok(())
-    }
-
-    fn write_vectored_sync(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-        eventfd: &EventFd,
-        completion_list: &mut Vec<(u64, i32)>,
-    ) -> AsyncIoResult<()> {
-        // Convert libc::iovec into IoSlice
-        let mut slices = Vec::new();
-        for iovec in iovecs.iter() {
-            slices.push(IoSlice::new(unsafe { std::mem::transmute(*iovec) }));
-        }
-
-        let result = {
-            let mut file = self.file();
-
-            // Move the cursor to the right offset
-            file.seek(SeekFrom::Start(offset as u64))
-                .map_err(AsyncIoError::WriteVectored)?;
-
-            // Write vectored
-            file.write_vectored(slices.as_slice())
-                .map_err(AsyncIoError::WriteVectored)?
-        };
-
-        completion_list.push((user_data, result as i32));
-        eventfd.write(1).unwrap();
-
-        Ok(())
-    }
-
-    fn fsync_sync(
-        &mut self,
-        user_data: Option<u64>,
-        eventfd: &EventFd,
-        completion_list: &mut Vec<(u64, i32)>,
-    ) -> AsyncIoResult<()> {
-        let result: i32 = {
-            let mut file = self.file();
-
-            // Flush
-            file.flush().map_err(AsyncIoError::Fsync)?;
-
-            0
-        };
-
-        if let Some(user_data) = user_data {
-            completion_list.push((user_data, result));
-            eventfd.write(1).unwrap();
-        }
-
-        Ok(())
-    }
-
-    fn file(&mut self) -> MutexGuard<F>;
-}
-
-pub enum ImageType {
-    FixedVhd,
-    Qcow2,
-    Raw,
-    Vhdx,
-}
-
-const QCOW_MAGIC: u32 = 0x5146_49fb;
-const VHDX_SIGN: u64 = 0x656C_6966_7864_6876;
-
-/// Determine image type through file parsing.
-pub fn detect_image_type(f: &mut File) -> std::io::Result<ImageType> {
-    // We must create a buffer aligned on 512 bytes with a size being a
-    // multiple of 512 bytes as the file might be opened with O_DIRECT flag.
-    #[repr(align(512))]
-    struct Sector {
-        data: [u8; 512],
-    }
-    let mut s = Sector { data: [0; 512] };
-
-    f.read_exact(&mut s.data)?;
-
-    // Check 4 first bytes to get the header value and determine the image type
-    let image_type = if u32::from_be_bytes(s.data[0..4].try_into().unwrap()) == QCOW_MAGIC {
-        ImageType::Qcow2
-    } else if vhd::is_fixed_vhd(f)? {
-        ImageType::FixedVhd
-    } else if u64::from_le_bytes(s.data[0..8].try_into().unwrap()) == VHDX_SIGN {
-        ImageType::Vhdx
-    } else {
-        ImageType::Raw
-    };
-
-    Ok(image_type)
-}

block_util/src/raw_async.rs

@@ -1,168 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use crate::async_io::{
-    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult, DiskTopology,
-};
-use io_uring::{opcode, squeue, types, IoUring};
-use std::fs::File;
-use std::io::{Seek, SeekFrom};
-use std::os::unix::io::{AsRawFd, RawFd};
-use vmm_sys_util::eventfd::EventFd;
-
-pub struct RawFileDisk {
-    file: File,
-}
-
-impl RawFileDisk {
-    pub fn new(file: File) -> Self {
-        RawFileDisk { file }
-    }
-}
-
-impl DiskFile for RawFileDisk {
-    fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self
-            .file
-            .seek(SeekFrom::End(0))
-            .map_err(DiskFileError::Size)? as u64)
-    }
-
-    fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
-        Ok(Box::new(
-            RawFileAsync::new(self.file.as_raw_fd(), ring_depth)
-                .map_err(DiskFileError::NewAsyncIo)?,
-        ) as Box<dyn AsyncIo>)
-    }
-
-    fn topology(&mut self) -> DiskTopology {
-        if let Ok(topology) = DiskTopology::probe(&mut self.file) {
-            topology
-        } else {
-            warn!("Unable to get device topology. Using default topology");
-            DiskTopology::default()
-        }
-    }
-}
-
-pub struct RawFileAsync {
-    fd: RawFd,
-    io_uring: IoUring,
-    eventfd: EventFd,
-}
-
-impl RawFileAsync {
-    pub fn new(fd: RawFd, ring_depth: u32) -> std::io::Result<Self> {
-        let io_uring = IoUring::new(ring_depth)?;
-        let eventfd = EventFd::new(libc::EFD_NONBLOCK)?;
-
-        // Register the io_uring eventfd that will notify when something in
-        // the completion queue is ready.
-        io_uring.submitter().register_eventfd(eventfd.as_raw_fd())?;
-
-        Ok(RawFileAsync {
-            fd,
-            io_uring,
-            eventfd,
-        })
-    }
-}
-
-impl AsyncIo for RawFileAsync {
-    fn notifier(&self) -> &EventFd {
-        &self.eventfd
-    }
-
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<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
-        // relied on vm-memory to provide the buffer address.
-        let _ = unsafe {
-            sq.push(
-                &opcode::Readv::new(types::Fd(self.fd), iovecs.as_ptr(), iovecs.len() as u32)
-                    .offset(offset)
-                    .build()
-                    .flags(squeue::Flags::ASYNC)
-                    .user_data(user_data),
-            )
-        };
-
-        // Update the submission queue and submit new operations to the
-        // io_uring instance.
-        sq.sync();
-        submitter.submit().map_err(AsyncIoError::ReadVectored)?;
-
-        Ok(())
-    }
-
-    fn write_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<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
-        // relied on vm-memory to provide the buffer address.
-        let _ = unsafe {
-            sq.push(
-                &opcode::Writev::new(types::Fd(self.fd), iovecs.as_ptr(), iovecs.len() as u32)
-                    .offset(offset)
-                    .build()
-                    .flags(squeue::Flags::ASYNC)
-                    .user_data(user_data),
-            )
-        };
-
-        // Update the submission queue and submit new operations to the
-        // io_uring instance.
-        sq.sync();
-        submitter.submit().map_err(AsyncIoError::WriteVectored)?;
-
-        Ok(())
-    }
-
-    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
-        if let Some(user_data) = user_data {
-            let (submitter, mut sq, _) = self.io_uring.split();
-
-            // Safe because we know the file descriptor is valid.
-            let _ = unsafe {
-                sq.push(
-                    &opcode::Fsync::new(types::Fd(self.fd))
-                        .build()
-                        .flags(squeue::Flags::ASYNC)
-                        .user_data(user_data),
-                )
-            };
-
-            // Update the submission queue and submit new operations to the
-            // io_uring instance.
-            sq.sync();
-            submitter.submit().map_err(AsyncIoError::Fsync)?;
-        } else {
-            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
-    }
-}

build.rs

@@ -3,25 +3,30 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#[macro_use(crate_version)]
-extern crate clap;
-
+use std::env;
 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() {
-            if let Ok(git_out_str) = String::from_utf8(git_out.stdout) {
-                version = git_out_str;
-            }
-        }
+    if let Ok(git_out) = Command::new("git").args(["describe", "--dirty"]).output()
+        && git_out.status.success()
+        && let Ok(git_out_str) = String::from_utf8(git_out.stdout)
+    {
+        version = git_out_str;
+        // Pop the trailing newline.
+        version.pop();
+    }
+
+    // Append CH_EXTRA_VERSION to version if it is set.
+    if let Ok(extra_version) = env::var("CH_EXTRA_VERSION") {
+        println!("cargo:rerun-if-env-changed=CH_EXTRA_VERSION");
+        version.push_str(&format!("-{extra_version}"));
     }
 
     // This println!() has a special behavior, as it will set the environment
-    // variable BUILT_VERSION, so that it can be reused from the binary.
+    // variable BUILD_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=BUILD_VERSION={version}");
 }