build: Bump version to 0.5.1

Signed-off-by: Rob Bradford <robert.bradford@intel.com>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,34 +0,0 @@
----
-name: Bug report
-about: File a bug report
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behaviour:
-
-**Version**
-
-Output of `cloud-hypervisor --version`:
-
-Did you build from source, if so build command line (e.g. features):
-
-**VM configuration**
-
-What command line did you run (or JSON config data):
-
-Guest OS version details:
-
-Host OS version details:
-
-**Logs**
-
-Output of `cloud-hypervisor -v` from either standard error or via `--log-file`:
-
-Linux kernel output:

.github/workflows/audit.yaml

@@ -1,15 +0,0 @@
-name: Cloud Hypervisor Dependency Audit
-on:
-  pull_request:
-    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
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build.yaml

@@ -1,44 +0,0 @@
-name: Cloud Hypervisor Build
-on: [pull_request, create]
-
-jobs:
-  build:
-    if: github.event_name == 'pull_request'
-    name: Build
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        rust:
-          - stable
-          - beta
-          - nightly
-        target:
-          - x86_64-unknown-linux-gnu
-          - x86_64-unknown-linux-musl
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-
-      - name: Install Rust toolchain (${{ matrix.rust }})
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ matrix.rust }}
-            target: ${{ matrix.target }}
-            override: true
-
-      - name: Debug Check (default features)
-        run: |
-          git rev-list origin/master..$GITHUB_SHA | xargs -t -I % sh -c 'git checkout %; cargo check --all --target=${{ matrix.target }}'
-          git checkout $GITHUB_SHA
-
-      - name: Build (acpi,kvm)
-        run: cargo rustc --bin cloud-hypervisor --no-default-features --features "acpi,kvm"  -- -D warnings
-
-      - name: Build (kvm)
-        run: cargo rustc --bin cloud-hypervisor --no-default-features --features "kvm"  -- -D warnings
-        
-      - name: Release Build (default features)
-        run: cargo build --all --release --target=${{ matrix.target }}

.github/workflows/docker-image.yaml

@@ -1,36 +0,0 @@
-name: Cloud-Hypervisor's Docker image update
-
-on:
-  push:
-    branches: master
-    paths: resources/Dockerfile
-
-jobs:
-  main:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@v2
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v1 
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Build and push
-        uses: docker/build-push-action@v2
-        with:
-          file: ./resources/Dockerfile
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: cloudhypervisor/dev:latest
-
-      - name: Image digest
-        run: echo ${{ steps.docker_build.outputs.digest }}

.github/workflows/fuzz-build.yaml

@@ -1,27 +0,0 @@
-name: Cloud Hypervisor Cargo Fuzz Build
-on: [pull_request, create]
-
-jobs:
-  build:
-    if: github.event_name == 'pull_request'
-    name: Cargo Fuzz Build
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        rust:
-          - nightly
-        target:
-          - x86_64-unknown-linux-gnu
-    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
-      - name: Install Cargo fuzz
-        run: cargo install -f cargo-fuzz
-      - name: Cargo Fuzz Build
-        run: cargo fuzz build

.github/workflows/quality-aarch64.yaml

@@ -1,41 +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: Install arm64 libfdt
-        run: wget http://ftp.us.debian.org/debian/pool/main/d/device-tree-compiler/libfdt-dev_1.6.0-1_arm64.deb && dpkg-deb -xv libfdt-dev_1.6.0-1_arm64.deb ./tlibfdtdev && mkdir -p target/debug/deps && sudo cp ./tlibfdtdev/usr/lib/aarch64-linux-gnu/libfdt.a target/debug/deps/libfdt.a && echo "libfdt installed"
-      - 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 }} --no-default-features --features "kvm" -- -D warnings

.github/workflows/quality.yaml

@@ -1,58 +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:
-          - x86_64-unknown-linux-gnu
-        experimental: [false]
-        include:
-          - rust: beta
-            target: x86_64-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 (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: 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
-
-      - name: Clippy (mshv)
-        run: cargo clippy --all --all-targets --no-default-features --tests --features "mshv" -- -D warnings
-
-      - name: Clippy (integration tests)
-        run: cargo clippy --all --all-targets --tests --features "integration_tests" -- -D warnings

.github/workflows/release.yaml

@@ -1,67 +0,0 @@
-name: Cloud Hypervisor Release
-on: [create]
-
-jobs:
-  release:
-    if: github.event_name == 'create' && github.event.ref_type == 'tag'
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@v2
-      - name: Install Rust toolchain (x86_64-unknown-linux-gnu)
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: stable
-            target: x86_64-unknown-linux-gnu
-      - name: Install Rust toolchain (x86_64-unknown-linux-musl)
-        uses: actions-rs/toolchain@v1
-        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: 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: Upload cloud-hypervisor
-        id: upload-release-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-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

.gitignore

@@ -1,4 +1,3 @@
-/build
 /target
 **/*.rs.bk
 **/Cargo.lock

.rustfmt.toml

@@ -1 +0,0 @@
-edition = "2018"

.travis.yml

@@ -0,0 +1,16 @@
+language: rust
+
+rust:
+  - stable
+
+script:
+  - cargo build --release
+  
+deploy:
+  provider: releases
+  api_key: $GITHUB_OAUTH_TOKEN
+  file: target/release/cloud-hypervisor
+  skip_cleanup: true
+  draft: true
+  on:
+    tags: true

CONTRIBUTING.md

@@ -88,5 +88,5 @@ 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 correspoding PR is merged, Github will automatically close that issue when parsing the
 [commit message](https://help.github.com/articles/closing-issues-via-commit-messages/).

Cargo.toml

@@ -1,90 +1,68 @@
 [package]
 name = "cloud-hypervisor"
-version = "15.0.0"
+version = "0.5.1"
 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"
-homepage = "https://github.com/cloud-hypervisor/cloud-hypervisor"
-
-[profile.release]
-lto = true
 
 [dependencies]
-anyhow = "1.0.40"
-api_client = { path = "api_client" }
-clap = { version = "2.33.3", features = ["wrap_help"] }
-epoll = "4.3.1"
-event_monitor = { path = "event_monitor" }
-hypervisor = { path = "hypervisor" }
-libc = "0.2.94"
-log = { version = "0.4.14", features = ["std"] }
-option_parser = { path = "option_parser" }
-seccomp = { git = "https://github.com/firecracker-microvm/firecracker", tag = "v0.24.2" }
-serde_json = "1.0.64"
-signal-hook = "0.3.8"
-thiserror = "1.0.24"
+arc-swap = "0.4.4"
+clap = "2.33.0"
+epoll = "4.1.0"
+lazy_static = "1.4.0"
+libc = "0.2.66"
+log = { version = "0.4.8", features = ["std"] }
+vhost_user_backend = { path = "vhost_user_backend"}
+vhost_user_block = { path = "vhost_user_block"}
+vhost_user_fs = { path = "vhost_user_fs"}
+vhost_user_net = { path = "vhost_user_net"}
+virtio-bindings = "0.1.0"
 vmm = { path = "vmm" }
-vmm-sys-util = "0.8.0"
-vm-memory = "0.5.0"
+vm-device = { path = "vm-device" }
+vm-memory = { git = "https://github.com/rust-vmm/vm-memory" }
+vmm-sys-util = "0.4.0"
+vm-virtio = { path = "vm-virtio" }
 
-[build-dependencies]
-clap = { version = "2.33.3", features = ["wrap_help"] }
-
-# List of patched crates
-[patch.crates-io]
-kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.4.0", features = ["with-serde", "fam-wrappers"] }
+[dependencies.vhost_rs]
+path = "vhost_rs"
+features = ["vhost-user-slave"]
 
 [dev-dependencies]
+ssh2 = "0.7.1"
+dirs = "2.0.2"
 credibility = "0.1.3"
-dirs = "3.0.2"
+tempdir= "0.3.7"
 lazy_static= "1.4.0"
-net_util = { path = "net_util" }
-serde_json = "1.0.64"
-test_infra = { path = "test_infra" }
-wait-timeout = "0.2.0"
+serde_json = "1.0.48"
 
 [features]
-default = ["acpi", "cmos", "io_uring", "kvm"]
-# Common features for all hypervisors
-common = ["acpi", "cmos", "fwdebug", "io_uring"]
+default = ["acpi", "pci", "cmos"]
 acpi = ["vmm/acpi"]
+pci = ["vmm/pci_support"]
+mmio = ["vmm/mmio_support"]
 cmos = ["vmm/cmos"]
-fwdebug = ["vmm/fwdebug"]
-kvm = ["vmm/kvm"]
-mshv = ["vmm/mshv"]
-io_uring = ["vmm/io_uring"]
-tdx = ["vmm/tdx"]
 
 # Integration tests require a special environment to run in
 integration_tests = []
 
 [workspace]
 members = [
-    "acpi_tables",
-    "api_client",
     "arch",
-    "arch_gen",
-    "block_util",
     "devices",
-    "event_monitor",
-    "hypervisor",
-    "net_gen",
-    "net_util",
-    "option_parser",
-    "pci",
+    "vhost_rs",
     "qcow",
-    "rate_limiter",
-    "vhost_user_backend",
-    "vhost_user_block",
-    "vhost_user_net",
-    "virtio-devices",
+    "pci",
     "vmm",
-    "vm-allocator",
+    "vm-virtio",
     "vm-device",
-    "vm-migration",
-    "vm-virtio"
+    "vhost_user_block",
+    "vhost_user_backend",
+    "vhost_user_fs",
+    "vhost_user_net",
+    "vfio",
+    "net_util",
+    "acpi_tables",
+    "arch_gen",
+    "net_gen",
+    "vm-allocator",
 ]
-exclude = ["test_infra"]

Jenkinsfile

@@ -1,7 +1,7 @@
 pipeline{
 	agent none
 	stages {
-		stage ('Early checks') {
+		stage ('Master build') {
 			agent { node { label 'master' } }
 			stages {
 				stage ('Check for RFC/WIP builds') {
@@ -14,217 +14,55 @@ pipeline{
 					}
 				}
 				stage ('Cancel older builds') {
-					when { not { branch 'master' } }
 					steps {
 						cancelPreviousBuilds()
 					}
 				}
 			}
 		}
-		stage ('Build') {
-            		parallel {
-				stage ('Worker build') {
-					agent { node { label 'groovy' } }
-					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 "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 "scripts/dev_cli.sh tests --integration"
-							}
-						}
-					}
-					post {
-						always {
-							sh "sudo chown -R jenkins.jenkins ${WORKSPACE}"
-							deleteDir()
-						}
-					}
-				}
-				stage ('Worker build (musl)') {
-					agent { node { label 'groovy' } }
-					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 "scripts/dev_cli.sh tests --integration --libc musl"
-							}
-						}
-					}
-				}
-				stage ('Worker build SGX') {
-					agent { node { label 'bionic-sgx' } }
-					when { branch 'master' }
-					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 { branch 'master' }
-					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 'groovy-win' } }
-					stages {
-						stage ('Checkout') {
-							steps {
-								checkout scm
-							}
-						}
-						stage ('Download assets') {
-							steps {
-								sh "mkdir ${env.HOME}/workloads"
-								azureDownload(storageCredentialId: 'ch-image-store',
-											  containerName: 'private-images',
-											  includeFilesPattern: 'OVMF-4b47d0c6c8.fd',
-											  downloadType: 'container',
-											  downloadDirLoc: "${env.HOME}/workloads")
-								azureDownload(storageCredentialId: 'ch-image-store',
-											  containerName: 'private-images',
-											  includeFilesPattern: 'windows-server-2019.raw',
-											  downloadType: 'container',
-											  downloadDirLoc: "${env.HOME}/workloads")
-							}
-						}
-						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') {
+			agent { node { label 'bionic' } }
+			options {
+				timeout(time: 1, unit: 'HOURS')
 			}
-		}
-	}
-	post {
-		regression {
-			script {
-				if (env.BRANCH_NAME == 'master') {
-					slackSend (color: '#ff0000', message: '"master" branch build is now failing')
+			stages {
+				stage ('Checkout') {
+					steps {
+						checkout scm
+					}
 				}
-			}
-		}
-		fixed {
-			script {
-				if (env.BRANCH_NAME == 'master') {
-					slackSend (color: '#00ff00', message: '"master" branch build is now fixed')
+				stage ('Install system packages') {
+					steps {
+						sh "sudo DEBIAN_FRONTEND=noninteractive apt-get install -yq build-essential mtools libssl-dev pkg-config"
+							sh "sudo apt-get install -yq flex bison libelf-dev qemu-utils qemu-system libglib2.0-dev libpixman-1-dev libseccomp-dev libcap-ng-dev socat"
+							sh "sudo snap install docker"
+					}
+				}
+				stage ('Install Rust') {
+					steps {
+						sh "nohup curl https://sh.rustup.rs -sSf | sh -s -- -y"
+					}
+				}
+				stage ('Run Cargo tests') {
+					steps {
+						sh "scripts/run_cargo_tests.sh"
+					}
+				}
+				stage ('Run OpenAPI tests') {
+					steps {
+						sh "scripts/run_openapi_tests.sh"
+					}
+				}
+				stage ('Run unit tests') {
+					steps {
+						sh "scripts/run_unit_tests.sh"
+					}
+				}
+				stage ('Run integration tests') {
+					steps {
+						sh "sudo mount -t tmpfs tmpfs /tmp"
+							sh "scripts/run_integration_tests.sh"
+					}
 				}
 			}
 		}

README.md

@@ -1,35 +1,35 @@
 [![Build Status](https://travis-ci.com/cloud-hypervisor/cloud-hypervisor.svg?branch=master)](https://travis-ci.com/cloud-hypervisor/cloud-hypervisor)
 
-- [1. What is Cloud Hypervisor?](#1-what-is-cloud-hypervisor)
-  - [Objectives](#objectives)
-    - [High Level](#high-level)
-    - [Architectures](#architectures)
-    - [Guest OS](#guest-os)
-- [2. Getting Started](#2-getting-started)
-  - [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)
-      - [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)
-- [5. Community](#5-community)
-  - [Contribute](#contribute)
-  - [Join us](#join-us)
+1. [What is Cloud Hypervisor?](#1-what-is-cloud-hypervisor)
+   * [Requirements](#requirements)
+	 + [High Level](#high-level)
+     + [Architectures](#architectures)
+	 + [Guest OS](#guest-os)
+2. [Getting Started](#2-getting-started)
+   * [Clone and build](#clone-and-build)
+   * [Run](#run)
+	 + [Cloud image](#cloud-image)
+	 + [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](#2-status)
+	* [Device Model](#device-model)
+	* [TODO](#todo)
+4. [rust-vmm dependency](#4-rust-vmm-dependency)
+	* [Firecracker and crosvm](#firecracker-and-crosvm)
+5. [Community](#5-community)
+	* [Join us](#join-us)
+6. [Security](#6-security)
 
 # 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 .
+**This project is an experiment and should not be used with production workloads.**
 
+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).
 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.
+Cloud workloads refers to those that are usually run by customers inside a cloud provider. For our purposes this means modern
+Linux* distributions with most I/O handled by paravirtualised devices (i.e. virtio), no requirement for legacy devices and recent CPUs and KVM.
 
 Cloud Hypervisor is implemented in [Rust](https://www.rust-lang.org/) and is based on the [rust-vmm](https://github.com/rust-vmm) crates.
 
@@ -37,24 +37,27 @@ Cloud Hypervisor is implemented in [Rust](https://www.rust-lang.org/) and is bas
 
 ### High Level
 
-- Runs on KVM or MSHV
-- Minimal emulation
-- Low latency
-- Low memory footprint
-- Low complexity
-- High performance
-- Small attack surface
-- 64-bit support only
-- CPU, memory, PCI hotplug
-- Machine to machine migration
+* KVM and KVM only based
+* Minimal emulation
+* Low latency
+* Low memory footprint
+* Low complexity
+* High performance
+* Small attack surface
+* 64-bit support only
+* Build time configurable CPU, memory, PCI and NVDIMM hotplug
+* Machine to machine migration
 
 ### 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` only supports the `x86-64` CPU architecture for now.
+
+We're planning to add support for the `AArch64` architecture in the future.
 
 ### Guest OS
+* `64-bit Linux`
 
-Cloud Hypervisor supports `64-bit Linux` and Windows 10/Windows Server 2019.
+Support for *modern* 64-bit Windows guest is being evaluated.
 
 # 2. Getting Started
 
@@ -65,23 +68,6 @@ $ 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:
@@ -95,8 +81,6 @@ $ 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
 ```
 
@@ -136,20 +120,20 @@ You can run a guest VM by either using an existing cloud image or booting into y
 
 ### 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
+`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:
+We need to get the latest `rust-hypervisor-firmware` release and also a working cloud image. Here we will use a Clear Linux 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.1/hypervisor-fw
+$ wget https://download.clearlinux.org/releases/31890/clear/clear-31890-kvm.img.xz
+$ unxz clear-31890-kvm.img.xz
+$ wget https://github.com/cloud-hypervisor/rust-hypervisor-firmware/releases/download/0.2.6/hypervisor-fw
 $ popd
 ```
 
@@ -158,7 +142,7 @@ $ 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 \
+	--disk path=clear-31890-kvm.img \
 	--cpus boot=4 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask=" \
@@ -172,7 +156,8 @@ Multiple arguments can be given to the `--disk` parameter.
 
 #### Building your 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.
+`cloud-hypervisor` also supports direct kernel boot into a `vmlinux` ELF kernel
+image. In order to support virtio-fs and 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.
 
 To build the kernel:
 
@@ -180,11 +165,11 @@ To build the kernel:
 
 # Clone the Cloud Hypervisor Linux branch
 $ pushd $CLOUDH
-$ git clone --depth 1 https://github.com/cloud-hypervisor/linux.git -b ch-5.12 linux-cloud-hypervisor
+$ git clone --depth 1 https://github.com/cloud-hypervisor/linux.git -b virtio-fs-virtio-iommu-5.5-rc1 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
+$ cp $CLOUDH/cloud-hypervisor/resources/linux-virtio-fs-virtio-iommu-config .config
 $ make bzImage -j `nproc`
 $ popd
 ```
@@ -193,18 +178,18 @@ The `vmlinux` kernel image will then be located at `linux-cloud-hypervisor/arch/
 
 #### Disk image
 
-For the disk image, we will use a Ubuntu cloud image that contains a root partition:
+For the disk image, we will use a Clear Linux cloud image that contains a root partition:
 
 ```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://download.clearlinux.org/releases/31890/clear/clear-31890-kvm.img.xz
+$ unxz clear-31890-kvm.img.xz
 $ popd
 ```
 
 #### Booting the guest VM
 
-Now we can directly boot into our custom kernel and make it use the Ubuntu root partition.
+Now we can directly boot into our custom kernel and make it use the Clear Linux root partition.
 If we want to have 4 vCPUs and 512 MBytes of memory:
 
 ```shell
@@ -212,8 +197,8 @@ $ pushd $CLOUDH
 $ sudo setcap cap_net_admin+ep ./cloud-hypervisor/target/release/cloud-hypervisor
 $ ./cloud-hypervisor/target/release/cloud-hypervisor \
 	--kernel ./linux-cloud-hypervisor/arch/x86/boot/compressed/vmlinux.bin \
-	--disk path=focal-server-cloudimg-amd64.raw \
-	--cmdline "console=hvc0 root=/dev/vda1 rw" \
+	--disk path=clear-31890-kvm.img \
+	--cmdline "console=hvc0 reboot=k panic=1 nomodules i8042.noaux i8042.nomux i8042.nopnp i8042.dumbkbd root=/dev/vda3" \
 	--cpus boot=4 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask=" \
@@ -232,8 +217,8 @@ $ ./cloud-hypervisor/target/release/cloud-hypervisor \
 	--kernel ./linux-cloud-hypervisor/arch/x86/boot/compressed/vmlinux.bin \
 	--console off \
 	--serial tty \
-	--disk path=focal-server-cloudimg-amd64.raw \
-	--cmdline "console=ttyS0 root=/dev/vda1 rw" \
+	--disk path=clear-31890-kvm.img \
+	--cmdline "console=ttyS0 reboot=k panic=1 nomodules i8042.noaux i8042.nomux i8042.nopnp i8042.dumbkbd root=/dev/vda3" \
 	--cpus boot=4 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask=" \
@@ -242,69 +227,52 @@ $ ./cloud-hypervisor/target/release/cloud-hypervisor \
 
 # 3. Status
 
-Cloud Hypervisor is under active development. The following stability guarantees are currently made:
+`cloud-hypervisor` is in a very early, pre-alpha stage. Use at your own risk!
 
-* 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.
-* Point releases will be made between individual releases where there are
-  substantial bug fixes or security issues that need to be fixed.
+As of 2019-12-12, the following cloud images are supported:
+* [Clear Linux](https://download.clearlinux.org/current/) (cloudguest and kvm)
+* [Ubuntu Bionic](https://cloud-images.ubuntu.com/bionic/current/) (cloudimg)
+* [Ubuntu Eoan](https://cloud-images.ubuntu.com/eoan/current/) (cloudimg)
 
-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.
-
-
-As of 2021-04-29, 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)
-
-Direct kernel boot to userspace should work with a rootfs from most distributions.
+Direct kernel boot to userspace should work with most rootfs.
 
 ## 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.
+This [document](https://github.com/cloud-hypervisor/cloud-hypervisor/blob/master/docs/hotplug.md) details how to add devices to
+a running VM. Currently only CPU hot plug is supported.
 
 ## Device Model
 
-Details of the device model can be found in this [documentation](docs/device_model.md).
+Follow this [documentation](https://github.com/cloud-hypervisor/cloud-hypervisor/blob/master/docs/device_model.md).
 
 ## TODO
 
-We are not tracking the Cloud Hypervisor TODO list from a specific git tracked file but through
+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.
 
 # 4. `rust-vmm` project dependency
 
 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.
+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)
+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
+`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:
 
 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
+2. As it is likely that the rust-vmm project will lack some of the features that `cloud-hypervisor` needs (e.g. ACPI,
+   VFIO, vhost-user, etc), we will be using the `cloud-hypervisor` VMM to implement and test them, and contribute them
    back to the rust-vmm project.
 
 ## Firecracker and crosvm
 
-A large part of the Cloud Hypervisor code is based on either the Firecracker or the crosvm projects implementations.
+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.
 
 However we want to emphasize that the Cloud Hypervisor project is neither a fork nor a reimplementation of any of those
@@ -319,11 +287,6 @@ crates as possible.
 
 # 5. Community
 
-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.
 
@@ -336,6 +299,26 @@ etc, are all equal and welcome means of contribution. See the [CONTRIBUTING](CON
 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/).
 
-## Security issues
+# 6. Security
 
-Please use the GitHub security advisories feature for reporting issues: https://github.com/cloud-hypervisor/cloud-hypervisor/security/advisories/new
+**Reporting a Potential Security Vulnerability**: If you have discovered
+potential security vulnerability in this project, please send an e-mail to
+secure@intel.com. For issues related to Intel Products, please visit
+https://security-center.intel.com.
+
+It is important to include the following details:
+  - The projects and versions affected
+  - Detailed description of the vulnerability
+  - Information on known exploits
+
+Vulnerability information is extremely sensitive. Please encrypt all security
+vulnerability reports using our *PGP key*
+
+A member of the Intel Product Security Team will review your e-mail and
+contact you to to collaborate on resolving the issue. For more information on
+how Intel works to resolve security issues, see: *Vulnerability Handling
+Guidelines*
+
+PGP Key: https://www.intel.com/content/www/us/en/security-center/pgp-public-key.html
+
+Vulnerability Handling Guidelines: https://www.intel.com/content/www/us/en/security-center/vulnerability-handling-guidelines.html

acpi_tables/Cargo.toml

@@ -5,5 +5,5 @@ authors = ["The Cloud Hypervisor Authors"]
 edition = "2018"
 
 [dependencies]
-vm-memory = "0.5.0"
+vm-memory = { git = "https://github.com/rust-vmm/vm-memory" }
 

acpi_tables/src/aml.rs

@@ -95,7 +95,8 @@ pub type Byte = u8;
 
 impl Aml for Byte {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x0a]; /* BytePrefix */
+        let mut bytes = Vec::new();
+        bytes.push(0x0a); /* BytePrefix */
         bytes.push(*self);
         bytes
     }
@@ -105,7 +106,8 @@ pub type Word = u16;
 
 impl Aml for Word {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x0bu8]; /* WordPrefix */
+        let mut bytes = Vec::new();
+        bytes.push(0x0bu8); /* WordPrefix */
         bytes.append(&mut self.to_le_bytes().to_vec());
         bytes
     }
@@ -115,7 +117,8 @@ pub type DWord = u32;
 
 impl Aml for DWord {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x0c]; /* DWordPrefix */
+        let mut bytes = Vec::new();
+        bytes.push(0x0c); /* DWordPrefix */
         bytes.append(&mut self.to_le_bytes().to_vec());
         bytes
     }
@@ -125,7 +128,8 @@ pub type QWord = u64;
 
 impl Aml for QWord {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x0e]; /* QWordPrefix */
+        let mut bytes = Vec::new();
+        bytes.push(0x0e); /* QWordPrefix */
         bytes.append(&mut self.to_le_bytes().to_vec());
         bytes
     }
@@ -143,7 +147,8 @@ impl Aml for Name {
 
 impl Name {
     pub fn new(path: Path, inner: &dyn Aml) -> Self {
-        let mut bytes = vec![0x08]; /* NameOp */
+        let mut bytes = Vec::new();
+        bytes.push(0x08); /* NameOp */
         bytes.append(&mut path.to_aml_bytes());
         bytes.append(&mut inner.to_aml_bytes());
         Name { bytes }
@@ -156,7 +161,8 @@ pub struct Package<'a> {
 
 impl<'a> Aml for Package<'a> {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![self.children.len() as u8];
+        let mut bytes = Vec::new();
+        bytes.push(self.children.len() as u8);
         for child in &self.children {
             bytes.append(&mut child.to_aml_bytes());
         }
@@ -233,11 +239,11 @@ fn create_pkg_length(data: &[u8], include_self: bool) -> Vec<u8> {
     result
 }
 
-pub struct EisaName {
+pub struct EISAName {
     value: DWord,
 }
 
-impl EisaName {
+impl EISAName {
     pub fn new(name: &str) -> Self {
         assert_eq!(name.len(), 7);
 
@@ -252,11 +258,11 @@ impl EisaName {
             | name.chars().nth(6).unwrap().to_digit(16).unwrap())
         .swap_bytes();
 
-        EisaName { value }
+        EISAName { value }
     }
 }
 
-impl Aml for EisaName {
+impl Aml for EISAName {
     fn to_aml_bytes(&self) -> Vec<u8> {
         self.value.to_aml_bytes()
     }
@@ -283,7 +289,8 @@ impl Aml for Usize {
 }
 
 fn create_aml_string(v: &str) -> Vec<u8> {
-    let mut data = vec![0x0D]; /* String Op */
+    let mut data = Vec::new();
+    data.push(0x0D); /* String Op */
     data.extend_from_slice(v.as_bytes());
     data.push(0x0); /* NullChar */
     data
@@ -367,7 +374,9 @@ impl Memory32Fixed {
 
 impl Aml for Memory32Fixed {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x86]; /* Memory32Fixed */
+        let mut bytes = Vec::new();
+
+        bytes.push(0x86); /* Memory32Fixed */
         bytes.append(&mut 9u16.to_le_bytes().to_vec());
 
         // 9 bytes of payload
@@ -381,7 +390,7 @@ impl Aml for Memory32Fixed {
 #[derive(Copy, Clone)]
 enum AddressSpaceType {
     Memory,
-    Io,
+    IO,
     BusNumber,
 }
 
@@ -412,7 +421,7 @@ impl<T> AddressSpace<T> {
 
     pub fn new_io(min: T, max: T) -> Self {
         AddressSpace {
-            r#type: AddressSpaceType::Io,
+            r#type: AddressSpaceType::IO,
             min,
             max,
             type_flags: 3, /* EntireRange */
@@ -501,16 +510,16 @@ impl Aml for AddressSpace<u64> {
     }
 }
 
-pub struct Io {
+pub struct IO {
     min: u16,
     max: u16,
     alignment: u8,
     length: u8,
 }
 
-impl Io {
+impl IO {
     pub fn new(min: u16, max: u16, alignment: u8, length: u8) -> Self {
-        Io {
+        IO {
             min,
             max,
             alignment,
@@ -519,10 +528,11 @@ impl Io {
     }
 }
 
-impl Aml for Io {
+impl Aml for IO {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x47]; /* Io Port Descriptor */
+        let mut bytes = Vec::new();
 
+        bytes.push(0x47); /* IO Port Descriptor */
         bytes.push(1); /* IODecode16 */
         bytes.append(&mut self.min.to_le_bytes().to_vec());
         bytes.append(&mut self.max.to_le_bytes().to_vec());
@@ -561,7 +571,9 @@ impl Interrupt {
 
 impl Aml for Interrupt {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x89]; /* Extended IRQ Descriptor */
+        let mut bytes = Vec::new();
+
+        bytes.push(0x89); /* Extended IRQ Descriptor */
         bytes.append(&mut 6u16.to_le_bytes().to_vec());
         let flags = (self.shared as u8) << 3
             | (self.active_low as u8) << 2
@@ -687,7 +699,8 @@ impl<'a> Return<'a> {
 
 impl<'a> Aml for Return<'a> {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0xa4]; /* ReturnOp */
+        let mut bytes = Vec::new();
+        bytes.push(0xa4); /* ReturnOp */
         bytes.append(&mut self.value.to_aml_bytes());
         bytes
     }
@@ -732,9 +745,9 @@ impl Field {
     ) -> Self {
         Field {
             path,
-            fields,
             access_type,
             update_rule,
+            fields,
         }
     }
 }
@@ -775,14 +788,14 @@ impl Aml for Field {
 #[derive(Clone, Copy)]
 pub enum OpRegionSpace {
     SystemMemory,
-    SystemIo,
-    PConfig,
+    SystemIO,
+    PCIConfig,
     EmbeddedControl,
-    Smbus,
-    SystemCmos,
+    SMBus,
+    SystemCMOS,
     PciBarTarget,
-    Ipmi,
-    GeneralPurposeIo,
+    IPMI,
+    GeneralPurposeIO,
     GenericSerialBus,
 }
 
@@ -851,8 +864,8 @@ impl<'a> Aml for If<'a> {
 }
 
 pub struct Equal<'a> {
-    left: &'a dyn Aml,
     right: &'a dyn Aml,
+    left: &'a dyn Aml,
 }
 
 impl<'a> Equal<'a> {
@@ -863,7 +876,8 @@ impl<'a> Equal<'a> {
 
 impl<'a> Aml for Equal<'a> {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x93]; /* LEqualOp */
+        let mut bytes = Vec::new();
+        bytes.push(0x93); /* LEqualOp */
         bytes.extend_from_slice(&self.left.to_aml_bytes());
         bytes.extend_from_slice(&self.right.to_aml_bytes());
         bytes
@@ -871,8 +885,8 @@ impl<'a> Aml for Equal<'a> {
 }
 
 pub struct LessThan<'a> {
-    left: &'a dyn Aml,
     right: &'a dyn Aml,
+    left: &'a dyn Aml,
 }
 
 impl<'a> LessThan<'a> {
@@ -883,7 +897,8 @@ impl<'a> LessThan<'a> {
 
 impl<'a> Aml for LessThan<'a> {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x95]; /* LLessOp */
+        let mut bytes = Vec::new();
+        bytes.push(0x95); /* LLessOp */
         bytes.extend_from_slice(&self.left.to_aml_bytes());
         bytes.extend_from_slice(&self.right.to_aml_bytes());
         bytes
@@ -925,7 +940,8 @@ impl<'a> Store<'a> {
 
 impl<'a> Aml for Store<'a> {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x70]; /* StoreOp */
+        let mut bytes = Vec::new();
+        bytes.push(0x70); /* StoreOp */
         bytes.extend_from_slice(&self.value.to_aml_bytes());
         bytes.extend_from_slice(&self.name.to_aml_bytes());
         bytes
@@ -945,7 +961,8 @@ impl Mutex {
 
 impl Aml for Mutex {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x5b]; /* ExtOpPrefix */
+        let mut bytes = Vec::new();
+        bytes.push(0x5b); /* ExtOpPrefix */
         bytes.push(0x01); /* MutexOp */
         bytes.extend_from_slice(&self.path.to_aml_bytes());
         bytes.push(self.sync_level);
@@ -966,7 +983,8 @@ impl Acquire {
 
 impl Aml for Acquire {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x5b]; /* ExtOpPrefix */
+        let mut bytes = Vec::new();
+        bytes.push(0x5b); /* ExtOpPrefix */
         bytes.push(0x23); /* AcquireOp */
         bytes.extend_from_slice(&self.mutex.to_aml_bytes());
         bytes.extend_from_slice(&self.timeout.to_le_bytes());
@@ -986,7 +1004,8 @@ impl Release {
 
 impl Aml for Release {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x5b]; /* ExtOpPrefix */
+        let mut bytes = Vec::new();
+        bytes.push(0x5b); /* ExtOpPrefix */
         bytes.push(0x27); /* ReleaseOp */
         bytes.extend_from_slice(&self.mutex.to_aml_bytes());
         bytes
@@ -1006,7 +1025,8 @@ impl<'a> Notify<'a> {
 
 impl<'a> Aml for Notify<'a> {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x86]; /* NotifyOp */
+        let mut bytes = Vec::new();
+        bytes.push(0x86); /* NotifyOp */
         bytes.extend_from_slice(&self.object.to_aml_bytes());
         bytes.extend_from_slice(&self.value.to_aml_bytes());
         bytes
@@ -1056,13 +1076,14 @@ macro_rules! binary_op {
 
         impl<'a> $name<'a> {
             pub fn new(target: &'a dyn Aml, a: &'a dyn Aml, b: &'a dyn Aml) -> Self {
-                $name { a, b, target }
+                $name { target, a, b }
             }
         }
 
         impl<'a> Aml for $name<'a> {
             fn to_aml_bytes(&self) -> Vec<u8> {
-                let mut bytes = vec![$opcode]; /* Op for the binary operator */
+                let mut bytes = Vec::new();
+                bytes.push($opcode); /* Op for the binary operator */
                 bytes.extend_from_slice(&self.a.to_aml_bytes());
                 bytes.extend_from_slice(&self.b.to_aml_bytes());
                 bytes.extend_from_slice(&self.target.to_aml_bytes());
@@ -1159,7 +1180,8 @@ impl<'a, T> CreateField<'a, T> {
 
 impl<'a> Aml for CreateField<'a, u64> {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x8f]; /* CreateQWordFieldOp */
+        let mut bytes = Vec::new();
+        bytes.push(0x8f); /* CreateQWordFieldOp */
         bytes.extend_from_slice(&self.buffer.to_aml_bytes());
         bytes.extend_from_slice(&self.offset.to_aml_bytes());
         bytes.extend_from_slice(&self.field.to_aml_bytes());
@@ -1169,7 +1191,8 @@ impl<'a> Aml for CreateField<'a, u64> {
 
 impl<'a> Aml for CreateField<'a, u32> {
     fn to_aml_bytes(&self) -> Vec<u8> {
-        let mut bytes = vec![0x8a]; /* CreateDWordFieldOp */
+        let mut bytes = Vec::new();
+        bytes.push(0x8a); /* CreateDWordFieldOp */
         bytes.extend_from_slice(&self.buffer.to_aml_bytes());
         bytes.extend_from_slice(&self.offset.to_aml_bytes());
         bytes.extend_from_slice(&self.field.to_aml_bytes());
@@ -1212,12 +1235,12 @@ mod tests {
             Device::new(
                 "_SB_.COM1".into(),
                 vec![
-                    &Name::new("_HID".into(), &EisaName::new("PNP0501")),
+                    &Name::new("_HID".into(), &EISAName::new("PNP0501")),
                     &Name::new(
                         "_CRS".into(),
                         &ResourceTemplate::new(vec![
                             &Interrupt::new(true, true, false, false, 4),
-                            &Io::new(0x3f8, 0x3f8, 0, 0x8)
+                            &IO::new(0x3f8, 0x3f8, 0, 0x8)
                         ])
                     )
                 ]
@@ -1453,7 +1476,7 @@ mod tests {
                 "_CRS".into(),
                 &ResourceTemplate::new(vec![
                     &Interrupt::new(true, true, false, false, 4),
-                    &Io::new(0x3f8, 0x3f8, 0, 0x8)
+                    &IO::new(0x3f8, 0x3f8, 0, 0x8)
                 ])
             )
             .to_aml_bytes(),
@@ -1496,7 +1519,7 @@ mod tests {
     #[test]
     fn test_eisa_name() {
         assert_eq!(
-            Name::new("_HID".into(), &EisaName::new("PNP0501")).to_aml_bytes(),
+            Name::new("_HID".into(), &EISAName::new("PNP0501")).to_aml_bytes(),
             [0x08, 0x5F, 0x48, 0x49, 0x44, 0x0C, 0x41, 0xD0, 0x05, 0x01],
         )
     }
@@ -1642,14 +1665,14 @@ mod tests {
     #[test]
     fn test_op_region() {
         /*
-            OperationRegion (PRST, SystemIo, 0x0CD8, 0x0C)
+            OperationRegion (PRST, SystemIO, 0x0CD8, 0x0C)
         */
         let op_region_data = [
             0x5Bu8, 0x80, 0x50, 0x52, 0x53, 0x54, 0x01, 0x0B, 0xD8, 0x0C, 0x0A, 0x0C,
         ];
 
         assert_eq!(
-            OpRegion::new("PRST".into(), OpRegionSpace::SystemIo, 0xcd8, 0xc).to_aml_bytes(),
+            OpRegion::new("PRST".into(), OpRegionSpace::SystemIO, 0xcd8, 0xc).to_aml_bytes(),
             &op_region_data[..]
         );
     }
@@ -1743,7 +1766,7 @@ mod tests {
             Device::new(
                 "_SB_.MHPC".into(),
                 vec![
-                    &Name::new("_HID".into(), &EisaName::new("PNP0A06")),
+                    &Name::new("_HID".into(), &EISAName::new("PNP0A06")),
                     &mutex,
                     &Method::new(
                         "TEST".into(),
@@ -1784,7 +1807,7 @@ mod tests {
             Device::new(
                 "_SB_.MHPC".into(),
                 vec![
-                    &Name::new("_HID".into(), &EisaName::new("PNP0A06")),
+                    &Name::new("_HID".into(), &EISAName::new("PNP0A06")),
                     &Method::new(
                         "TEST".into(),
                         0,
@@ -1825,7 +1848,7 @@ mod tests {
             Device::new(
                 "_SB_.MHPC".into(),
                 vec![
-                    &Name::new("_HID".into(), &EisaName::new("PNP0A06")),
+                    &Name::new("_HID".into(), &EISAName::new("PNP0A06")),
                     &Method::new(
                         "TEST".into(),
                         0,

acpi_tables/src/rsdp.rs

@@ -7,7 +7,7 @@ use vm_memory::ByteValued;
 
 #[repr(packed)]
 #[derive(Clone, Copy, Default)]
-pub struct Rsdp {
+pub struct RSDP {
     pub signature: [u8; 8],
     pub checksum: u8,
     pub oem_id: [u8; 6],
@@ -19,17 +19,17 @@ pub struct Rsdp {
     _reserved: [u8; 3],
 }
 
-unsafe impl ByteValued for Rsdp {}
+unsafe impl ByteValued for RSDP {}
 
-impl Rsdp {
+impl RSDP {
     pub fn new(oem_id: [u8; 6], xsdt_addr: u64) -> Self {
-        let mut rsdp = Rsdp {
+        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,
+            length: std::mem::size_of::<RSDP>() as u32,
             xsdt_addr,
             extended_checksum: 0,
             _reserved: [0; 3],
@@ -41,18 +41,18 @@ impl Rsdp {
     }
 
     pub fn len() -> usize {
-        std::mem::size_of::<Rsdp>()
+        std::mem::size_of::<RSDP>()
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::Rsdp;
+    use super::RSDP;
     use vm_memory::bytes::ByteValued;
 
     #[test]
     fn test_rsdp() {
-        let rsdp = Rsdp::new(*b"CHYPER", 0xdead_beef);
+        let rsdp = RSDP::new(*b"CHYPER", 0xdead_beef);
         let sum = rsdp
             .as_slice()
             .iter()

acpi_tables/src/sdt.rs

@@ -13,23 +13,23 @@ pub struct GenericAddress {
 }
 
 impl GenericAddress {
-    pub fn io_port_address<T>(address: u16) -> Self {
+    pub fn io_port_address(address: u16) -> Self {
         GenericAddress {
             address_space_id: 1,
-            register_bit_width: 8 * std::mem::size_of::<T>() as u8,
+            register_bit_width: 8,
             register_bit_offset: 0,
-            access_size: std::mem::size_of::<T>() as u8,
+            access_size: 1,
             address: u64::from(address),
         }
     }
 }
 
-pub struct Sdt {
+pub struct SDT {
     data: Vec<u8>,
 }
 
 #[allow(clippy::len_without_is_empty)]
-impl Sdt {
+impl SDT {
     pub fn new(
         signature: [u8; 4],
         length: u32,
@@ -53,7 +53,7 @@ impl Sdt {
         assert_eq!(data.len(), 36);
 
         data.resize(length as usize, 0);
-        let mut sdt = Sdt { data };
+        let mut sdt = SDT { data };
 
         sdt.update_checksum();
         sdt
@@ -117,11 +117,11 @@ impl Sdt {
 
 #[cfg(test)]
 mod tests {
-    use super::Sdt;
+    use super::SDT;
 
     #[test]
     fn test_sdt() {
-        let mut sdt = Sdt::new(*b"TEST", 40, 1, *b"CLOUDH", *b"TESTTEST", 1);
+        let mut sdt = SDT::new(*b"TEST", 40, 1, *b"CLOUDH", *b"TESTTEST", 1);
         let sum: u8 = sdt
             .as_slice()
             .iter()

api_client/Cargo.toml

@@ -1,5 +0,0 @@
-[package]
-name = "api_client"
-version = "0.1.0"
-authors = ["The Cloud Hypervisor Authors"]
-edition = "2018"

api_client/src/lib.rs

@@ -1,172 +0,0 @@
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-use std::fmt;
-use std::io::{Read, Write};
-
-#[derive(Debug)]
-pub enum Error {
-    Socket(std::io::Error),
-    StatusCodeParsing(std::num::ParseIntError),
-    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),
-            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)
-                }
-            }
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-pub enum StatusCode {
-    Continue,
-    Ok,
-    NoContent,
-    BadRequest,
-    NotFound,
-    InternalServerError,
-    NotImplemented,
-    Unknown,
-}
-
-impl StatusCode {
-    fn from_raw(code: usize) -> StatusCode {
-        match code {
-            100 => StatusCode::Continue,
-            200 => StatusCode::Ok,
-            204 => StatusCode::NoContent,
-            400 => StatusCode::BadRequest,
-            404 => StatusCode::NotFound,
-            500 => StatusCode::InternalServerError,
-            501 => StatusCode::NotImplemented,
-            _ => StatusCode::Unknown,
-        }
-    }
-
-    fn parse(code: &str) -> Result<StatusCode, Error> {
-        Ok(StatusCode::from_raw(
-            code.trim().parse().map_err(Error::StatusCodeParsing)?,
-        ))
-    }
-
-    fn is_server_error(self) -> bool {
-        !matches!(
-            self,
-            StatusCode::Ok | StatusCode::Continue | StatusCode::NoContent
-        )
-    }
-}
-
-fn get_header<'a>(res: &'a str, header: &'a str) -> Option<&'a str> {
-    let header_str = format!("{}: ", header);
-    res.find(&header_str)
-        .map(|o| &res[o + header_str.len()..o + res[o..].find('\r').unwrap()])
-}
-
-fn get_status_code(res: &str) -> Result<StatusCode, Error> {
-    if let Some(o) = res.find("HTTP/1.1") {
-        Ok(StatusCode::parse(
-            &res[o + "HTTP/1.1 ".len()..res[o..].find('\r').unwrap()],
-        )?)
-    } else {
-        Err(Error::MissingProtocol)
-    }
-}
-
-fn parse_http_response(socket: &mut dyn Read) -> Result<Option<String>, Error> {
-    let mut res = String::new();
-    let mut body_offset = None;
-    let mut content_length: Option<usize> = None;
-    loop {
-        let mut bytes = vec![0; 256];
-        let count = socket.read(&mut bytes).map_err(Error::Socket)?;
-        res.push_str(std::str::from_utf8(&bytes[0..count]).unwrap());
-
-        // End of headers
-        if let Some(o) = res.find("\r\n\r\n") {
-            body_offset = Some(o + "\r\n\r\n".len());
-
-            // With all headers available we can see if there is any body
-            content_length = if let Some(length) = get_header(&res, "Content-Length") {
-                Some(length.trim().parse().map_err(Error::ContentLengthParsing)?)
-            } else {
-                None
-            };
-
-            if content_length.is_none() {
-                break;
-            }
-        }
-
-        if let Some(body_offset) = body_offset {
-            if let Some(content_length) = content_length {
-                if res.len() >= content_length + body_offset {
-                    break;
-                }
-            }
-        }
-    }
-    let body_string = content_length.and(Some(String::from(&res[body_offset.unwrap()..])));
-    let status_code = get_status_code(&res)?;
-
-    if status_code.is_server_error() {
-        Err(Error::ServerResponse(status_code, body_string))
-    } else {
-        Ok(body_string)
-    }
-}
-
-pub fn simple_api_command<T: Read + Write>(
-    socket: &mut T,
-    method: &str,
-    c: &str,
-    request_body: Option<&str>,
-) -> Result<(), Error> {
-    socket
-        .write_all(
-            format!(
-                "{} /api/v1/vm.{} HTTP/1.1\r\nHost: localhost\r\nAccept: */*\r\n",
-                method, c
-            )
-            .as_bytes(),
-        )
-        .map_err(Error::Socket)?;
-
-    if let Some(request_body) = request_body {
-        socket
-            .write_all(format!("Content-Length: {}\r\n", request_body.len()).as_bytes())
-            .map_err(Error::Socket)?;
-    }
-
-    socket.write_all(b"\r\n").map_err(Error::Socket)?;
-
-    if let Some(request_body) = request_body {
-        socket
-            .write_all(request_body.as_bytes())
-            .map_err(Error::Socket)?;
-    }
-
-    socket.flush().map_err(Error::Socket)?;
-
-    if let Some(body) = parse_http_response(socket)? {
-        println!("{}", body);
-    }
-    Ok(())
-}

arch/Cargo.toml

@@ -5,22 +5,23 @@ authors = ["The Chromium OS Authors"]
 
 [features]
 default = []
-acpi = ["acpi_tables"]
-tdx = []
 
 [dependencies]
-acpi_tables = { path = "../acpi_tables", optional = true }
-anyhow = "1.0"
-arch_gen = { path = "../arch_gen" }
-byteorder = "1.4.3"
-hypervisor = { path = "../hypervisor" }
-libc = "0.2.94"
-linux-loader = { version = "0.3.0", features = ["elf", "bzimage", "pe"] }
-log = "0.4.14"
-serde = {version = ">=1.0.27", features = ["rc"] }
-serde_derive = ">=1.0.27"
-serde_json = ">=1.0.9"
-thiserror = "1.0"
-vm-memory = { version = "0.5.0", features = ["backend-mmap"] }
-vm-migration = { path = "../vm-migration" }
+byteorder = "1.3.4"
+kvm-bindings = "0.2.0"
+kvm-ioctls = "0.5.0"
+libc = "0.2.66"
 
+acpi_tables = { path = "../acpi_tables", optional = true }
+arch_gen = { path = "../arch_gen" }
+
+[dependencies.vm-memory]
+git = "https://github.com/rust-vmm/vm-memory"
+features = ["backend-mmap"]
+
+[dependencies.linux-loader]
+git = "https://github.com/rust-vmm/linux-loader"
+features = ["elf", "bzimage"]
+
+[dev-dependencies]
+rand = "0.7.3"

arch/src/aarch64/fdt.rs

@@ -1,636 +0,0 @@
-// 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 libc::{c_char, c_int, c_void};
-use std::collections::HashMap;
-use std::ffi::{CStr, CString, NulError};
-use std::fmt::Debug;
-use std::ptr::null;
-use std::{io, result};
-
-use super::super::DeviceType;
-use super::super::InitramfsConfig;
-use super::get_fdt_addr;
-use super::gic::GicDevice;
-use super::layout::{
-    FDT_MAX_SIZE, MEM_32BIT_DEVICES_SIZE, MEM_32BIT_DEVICES_START, PCI_MMCONFIG_SIZE,
-    PCI_MMCONFIG_START,
-};
-use crate::aarch64::fdt::Error::CstringFdtTransform;
-use vm_memory::{Address, Bytes, GuestAddress, GuestMemory, GuestMemoryError, GuestMemoryMmap};
-
-// This is a value for uniquely identifying the FDT node declaring the interrupt controller.
-const GIC_PHANDLE: u32 = 1;
-// This is a value for uniquely identifying the FDT node declaring the MSI controller.
-const MSI_PHANDLE: u32 = 2;
-// This is a value for uniquely identifying the FDT node containing the clock definition.
-const CLOCK_PHANDLE: u32 = 3;
-// This is a value for uniquely identifying the FDT node containing the gpio controller.
-const GPIO_PHANDLE: u32 = 4;
-
-// Read the documentation specified when appending the root node to the FDT.
-const ADDRESS_CELLS: u32 = 0x2;
-const SIZE_CELLS: u32 = 0x2;
-
-// As per kvm tool and
-// https://www.kernel.org/doc/Documentation/devicetree/bindings/interrupt-controller/arm%2Cgic.txt
-// Look for "The 1st cell..."
-const GIC_FDT_IRQ_TYPE_SPI: u32 = 0;
-const GIC_FDT_IRQ_TYPE_PPI: u32 = 1;
-
-// From https://elixir.bootlin.com/linux/v4.9.62/source/include/dt-bindings/interrupt-controller/irq.h#L17
-const IRQ_TYPE_EDGE_RISING: u32 = 1;
-const IRQ_TYPE_LEVEL_HI: u32 = 4;
-
-// Keys and Buttons
-// System Power Down
-const KEY_POWER: u32 = 116;
-
-// This links to libfdt which handles the creation of the binary blob
-// flattened device tree (fdt) that is passed to the kernel and indicates
-// the hardware configuration of the machine.
-#[link(name = "fdt")]
-extern "C" {
-    fn fdt_create(buf: *mut c_void, bufsize: c_int) -> c_int;
-    fn fdt_finish_reservemap(fdt: *mut c_void) -> c_int;
-    fn fdt_begin_node(fdt: *mut c_void, name: *const c_char) -> c_int;
-    fn fdt_property(fdt: *mut c_void, name: *const c_char, val: *const c_void, len: c_int)
-        -> c_int;
-    fn fdt_end_node(fdt: *mut c_void) -> c_int;
-    fn fdt_open_into(fdt: *const c_void, buf: *mut c_void, bufsize: c_int) -> c_int;
-    fn fdt_finish(fdt: *const c_void) -> c_int;
-    fn fdt_pack(fdt: *mut c_void) -> c_int;
-}
-
-/// 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 aarch64.
-#[derive(Debug)]
-pub enum Error {
-    /// Failed to append node to the FDT.
-    AppendFdtNode(io::Error),
-    /// Failed to append a property to the FDT.
-    AppendFdtProperty(io::Error),
-    /// Syscall for creating FDT failed.
-    CreateFdt(io::Error),
-    /// Failed to obtain a C style string.
-    CstringFdtTransform(NulError),
-    /// Failure in calling syscall for terminating this FDT.
-    FinishFdtReserveMap(io::Error),
-    /// Failure in writing FDT in memory.
-    WriteFdtToMemory(GuestMemoryError),
-}
-type Result<T> = result::Result<T, Error>;
-
-/// Creates the flattened device tree for this aarch64 VM.
-pub fn create_fdt<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
-    guest_mem: &GuestMemoryMmap,
-    cmdline: &CStr,
-    vcpu_mpidr: Vec<u64>,
-    device_info: &HashMap<(DeviceType, String), T, S>,
-    gic_device: &dyn GicDevice,
-    initrd: &Option<InitramfsConfig>,
-    pci_space_address: &(u64, u64),
-) -> Result<Vec<u8>> {
-    // Allocate stuff necessary for the holding the blob.
-    let mut fdt = vec![0; FDT_MAX_SIZE];
-
-    allocate_fdt(&mut fdt)?;
-
-    // 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".
-
-    // Header or the root node as per above mentioned documentation.
-    append_begin_node(&mut fdt, "")?;
-    append_property_string(&mut fdt, "compatible", "linux,dummy-virt")?;
-    // For info on #address-cells and size-cells read "Note about cells and address representation"
-    // from the above mentioned txt file.
-    append_property_u32(&mut fdt, "#address-cells", ADDRESS_CELLS)?;
-    append_property_u32(&mut fdt, "#size-cells", SIZE_CELLS)?;
-    // This is not mandatory but we use it to point the root node to the node
-    // containing description of the interrupt controller for this VM.
-    append_property_u32(&mut fdt, "interrupt-parent", GIC_PHANDLE)?;
-    create_cpu_nodes(&mut fdt, &vcpu_mpidr)?;
-    create_memory_node(&mut fdt, guest_mem)?;
-    create_chosen_node(&mut fdt, cmdline, initrd)?;
-    create_gic_node(&mut fdt, gic_device)?;
-    create_timer_node(&mut fdt)?;
-    create_clock_node(&mut fdt)?;
-    create_psci_node(&mut fdt)?;
-    create_devices_node(&mut fdt, device_info)?;
-    create_pci_nodes(&mut fdt, pci_space_address.0, pci_space_address.1)?;
-
-    // End Header node.
-    append_end_node(&mut fdt)?;
-
-    // Allocate another buffer so we can format and then write fdt to guest.
-    let mut fdt_final = vec![0; FDT_MAX_SIZE];
-    finish_fdt(&mut fdt, &mut fdt_final)?;
-
-    // Write FDT to memory.
-    let fdt_address = GuestAddress(get_fdt_addr(&guest_mem));
-    guest_mem
-        .write_slice(fdt_final.as_slice(), fdt_address)
-        .map_err(Error::WriteFdtToMemory)?;
-    Ok(fdt_final)
-}
-
-// Following are auxiliary functions for allocating and finishing the FDT.
-fn allocate_fdt(fdt: &mut Vec<u8>) -> Result<()> {
-    // Safe since we allocated this array with FDT_MAX_SIZE.
-    let mut fdt_ret = unsafe { fdt_create(fdt.as_mut_ptr() as *mut c_void, FDT_MAX_SIZE as c_int) };
-
-    if fdt_ret != 0 {
-        return Err(Error::CreateFdt(io::Error::last_os_error()));
-    }
-
-    // The flattened device trees created with fdt_create() contains a list of
-    // reserved memory areas. We need to call `fdt_finish_reservemap` so as to make sure that there is a
-    // terminator in the reservemap list and whatever happened to be at the
-    // start of the FDT data section would end up being interpreted as
-    // reservemap entries.
-    // Safe since we previously allocated this array.
-    fdt_ret = unsafe { fdt_finish_reservemap(fdt.as_mut_ptr() as *mut c_void) };
-    if fdt_ret != 0 {
-        return Err(Error::FinishFdtReserveMap(io::Error::last_os_error()));
-    }
-    Ok(())
-}
-
-fn finish_fdt(from_fdt: &mut Vec<u8>, to_fdt: &mut Vec<u8>) -> Result<()> {
-    // Safe since we allocated `fdt_final` and previously passed in its size.
-    let mut fdt_ret = unsafe { fdt_finish(from_fdt.as_mut_ptr() as *mut c_void) };
-    if fdt_ret != 0 {
-        return Err(Error::FinishFdtReserveMap(io::Error::last_os_error()));
-    }
-
-    // Safe because we allocated both arrays with the correct size.
-    fdt_ret = unsafe {
-        fdt_open_into(
-            from_fdt.as_mut_ptr() as *mut c_void,
-            to_fdt.as_mut_ptr() as *mut c_void,
-            FDT_MAX_SIZE as i32,
-        )
-    };
-    if fdt_ret != 0 {
-        return Err(Error::FinishFdtReserveMap(io::Error::last_os_error()));
-    }
-
-    // Safe since we allocated `to_fdt`.
-    fdt_ret = unsafe { fdt_pack(to_fdt.as_mut_ptr() as *mut c_void) };
-    if fdt_ret != 0 {
-        return Err(Error::FinishFdtReserveMap(io::Error::last_os_error()));
-    }
-    Ok(())
-}
-
-// Following are auxiliary functions for appending nodes to FDT.
-fn append_begin_node(fdt: &mut Vec<u8>, name: &str) -> Result<()> {
-    let cstr_name = CString::new(name).map_err(CstringFdtTransform)?;
-
-    // Safe because we allocated fdt and converted name to a CString
-    let fdt_ret = unsafe { fdt_begin_node(fdt.as_mut_ptr() as *mut c_void, cstr_name.as_ptr()) };
-    if fdt_ret != 0 {
-        return Err(Error::AppendFdtNode(io::Error::last_os_error()));
-    }
-    Ok(())
-}
-
-fn append_end_node(fdt: &mut Vec<u8>) -> Result<()> {
-    // Safe because we allocated fdt.
-    let fdt_ret = unsafe { fdt_end_node(fdt.as_mut_ptr() as *mut c_void) };
-    if fdt_ret != 0 {
-        return Err(Error::AppendFdtNode(io::Error::last_os_error()));
-    }
-    Ok(())
-}
-
-// Following are auxiliary functions for appending property nodes to the nodes of the FDT.
-fn append_property_u32(fdt: &mut Vec<u8>, name: &str, val: u32) -> Result<()> {
-    append_property(fdt, name, &to_be32(val))
-}
-
-fn append_property_u64(fdt: &mut Vec<u8>, name: &str, val: u64) -> Result<()> {
-    append_property(fdt, name, &to_be64(val))
-}
-
-fn append_property_string(fdt: &mut Vec<u8>, name: &str, value: &str) -> Result<()> {
-    let cstr_value = CString::new(value).map_err(CstringFdtTransform)?;
-    append_property_cstring(fdt, name, &cstr_value)
-}
-
-fn append_property_cstring(fdt: &mut Vec<u8>, name: &str, cstr_value: &CStr) -> Result<()> {
-    let value_bytes = cstr_value.to_bytes_with_nul();
-    let cstr_name = CString::new(name).map_err(CstringFdtTransform)?;
-    // Safe because we allocated fdt, converted name and value to CStrings
-    let fdt_ret = unsafe {
-        fdt_property(
-            fdt.as_mut_ptr() as *mut c_void,
-            cstr_name.as_ptr(),
-            value_bytes.as_ptr() as *mut c_void,
-            value_bytes.len() as i32,
-        )
-    };
-    if fdt_ret != 0 {
-        return Err(Error::AppendFdtProperty(io::Error::last_os_error()));
-    }
-    Ok(())
-}
-
-fn append_property_null(fdt: &mut Vec<u8>, name: &str) -> Result<()> {
-    let cstr_name = CString::new(name).map_err(CstringFdtTransform)?;
-
-    // Safe because we allocated fdt, converted name to a CString
-    let fdt_ret = unsafe {
-        fdt_property(
-            fdt.as_mut_ptr() as *mut c_void,
-            cstr_name.as_ptr(),
-            null(),
-            0,
-        )
-    };
-    if fdt_ret != 0 {
-        return Err(Error::AppendFdtProperty(io::Error::last_os_error()));
-    }
-    Ok(())
-}
-
-fn append_property(fdt: &mut Vec<u8>, name: &str, val: &[u8]) -> Result<()> {
-    let cstr_name = CString::new(name).map_err(CstringFdtTransform)?;
-    let val_ptr = val.as_ptr() as *const c_void;
-
-    // Safe because we allocated fdt and converted name to a CString
-    let fdt_ret = unsafe {
-        fdt_property(
-            fdt.as_mut_ptr() as *mut c_void,
-            cstr_name.as_ptr(),
-            val_ptr,
-            val.len() as i32,
-        )
-    };
-    if fdt_ret != 0 {
-        return Err(Error::AppendFdtProperty(io::Error::last_os_error()));
-    }
-    Ok(())
-}
-
-// Auxiliary functions for writing u32/u64 numbers in big endian order.
-fn to_be32(input: u32) -> [u8; 4] {
-    u32::to_be_bytes(input)
-}
-
-fn to_be64(input: u64) -> [u8; 8] {
-    u64::to_be_bytes(input)
-}
-
-// Helper functions for generating a properly formatted byte vector using 32-bit/64-bit cells.
-fn generate_prop32(cells: &[u32]) -> Vec<u8> {
-    let mut ret: Vec<u8> = Vec::new();
-    for &e in cells {
-        ret.extend(to_be32(e).iter());
-    }
-    ret
-}
-
-fn generate_prop64(cells: &[u64]) -> Vec<u8> {
-    let mut ret: Vec<u8> = Vec::new();
-    for &e in cells {
-        ret.extend(to_be64(e).iter());
-    }
-    ret
-}
-
-// Following are the auxiliary function for creating the different nodes that we append to our FDT.
-fn create_cpu_nodes(fdt: &mut Vec<u8>, vcpu_mpidr: &[u64]) -> Result<()> {
-    // See https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/arm/cpus.yaml.
-    append_begin_node(fdt, "cpus")?;
-    // As per documentation, on ARM v8 64-bit systems value should be set to 2.
-    append_property_u32(fdt, "#address-cells", 0x02)?;
-    append_property_u32(fdt, "#size-cells", 0x0)?;
-    let num_cpus = vcpu_mpidr.len();
-
-    for (cpu_index, mpidr) in vcpu_mpidr.iter().enumerate().take(num_cpus) {
-        let cpu_name = format!("cpu@{:x}", cpu_index);
-        append_begin_node(fdt, &cpu_name)?;
-        append_property_string(fdt, "device_type", "cpu")?;
-        append_property_string(fdt, "compatible", "arm,arm-v8")?;
-        if num_cpus > 1 {
-            // This is required on armv8 64-bit. See aforementioned documentation.
-            append_property_string(fdt, "enable-method", "psci")?;
-        }
-        // Set the field to first 24 bits of the MPIDR - Multiprocessor Affinity Register.
-        // See http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0488c/BABHBJCI.html.
-        append_property_u64(fdt, "reg", mpidr & 0x7FFFFF)?;
-        append_end_node(fdt)?;
-    }
-    append_end_node(fdt)?;
-    Ok(())
-}
-
-fn create_memory_node(fdt: &mut Vec<u8>, guest_mem: &GuestMemoryMmap) -> Result<()> {
-    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 = generate_prop64(&[super::layout::RAM_64BIT_START as u64, mem_size as u64]);
-
-    append_begin_node(fdt, "memory")?;
-    append_property_string(fdt, "device_type", "memory")?;
-    append_property(fdt, "reg", &mem_reg_prop)?;
-    append_end_node(fdt)?;
-    Ok(())
-}
-
-fn create_chosen_node(
-    fdt: &mut Vec<u8>,
-    cmdline: &CStr,
-    initrd: &Option<InitramfsConfig>,
-) -> Result<()> {
-    append_begin_node(fdt, "chosen")?;
-    append_property_cstring(fdt, "bootargs", cmdline)?;
-
-    if let Some(initrd_config) = initrd {
-        append_property_u64(
-            fdt,
-            "linux,initrd-start",
-            initrd_config.address.raw_value() as u64,
-        )?;
-        append_property_u64(
-            fdt,
-            "linux,initrd-end",
-            initrd_config.address.raw_value() + initrd_config.size as u64,
-        )?;
-    }
-
-    append_end_node(fdt)?;
-
-    Ok(())
-}
-
-fn create_gic_node(fdt: &mut Vec<u8>, gic_device: &dyn GicDevice) -> Result<()> {
-    let gic_reg_prop = generate_prop64(gic_device.device_properties());
-
-    append_begin_node(fdt, "intc")?;
-    append_property_string(fdt, "compatible", gic_device.fdt_compatibility())?;
-    append_property_null(fdt, "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.
-    append_property_u32(fdt, "#interrupt-cells", 3)?;
-    append_property(fdt, "reg", &gic_reg_prop)?;
-    append_property_u32(fdt, "phandle", GIC_PHANDLE)?;
-    append_property_u32(fdt, "#address-cells", 2)?;
-    append_property_u32(fdt, "#size-cells", 2)?;
-    append_property_null(fdt, "ranges")?;
-    let gic_intr = [
-        GIC_FDT_IRQ_TYPE_PPI,
-        gic_device.fdt_maint_irq(),
-        IRQ_TYPE_LEVEL_HI,
-    ];
-    let gic_intr_prop = generate_prop32(&gic_intr);
-
-    append_property(fdt, "interrupts", &gic_intr_prop)?;
-
-    if gic_device.msi_compatible() {
-        append_begin_node(fdt, "msic")?;
-        append_property_string(fdt, "compatible", gic_device.msi_compatibility())?;
-        append_property_null(fdt, "msi-controller")?;
-        append_property_u32(fdt, "phandle", MSI_PHANDLE)?;
-        let msi_reg_prop = generate_prop64(gic_device.msi_properties());
-        append_property(fdt, "reg", &msi_reg_prop)?;
-        append_end_node(fdt)?;
-    }
-
-    append_end_node(fdt)?;
-
-    Ok(())
-}
-
-fn create_clock_node(fdt: &mut Vec<u8>) -> Result<()> {
-    // The Advanced Peripheral Bus (APB) is part of the Advanced Microcontroller Bus Architecture
-    // (AMBA) protocol family. It defines a low-cost interface that is optimized for minimal power
-    // consumption and reduced interface complexity.
-    // PCLK is the clock source and this node defines exactly the clock for the APB.
-    append_begin_node(fdt, "apb-pclk")?;
-    append_property_string(fdt, "compatible", "fixed-clock")?;
-    append_property_u32(fdt, "#clock-cells", 0x0)?;
-    append_property_u32(fdt, "clock-frequency", 24000000)?;
-    append_property_string(fdt, "clock-output-names", "clk24mhz")?;
-    append_property_u32(fdt, "phandle", CLOCK_PHANDLE)?;
-    append_end_node(fdt)?;
-
-    Ok(())
-}
-
-fn create_timer_node(fdt: &mut Vec<u8>) -> Result<()> {
-    // See
-    // https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/interrupt-controller/arch_timer.txt
-    // These are fixed interrupt numbers for the timer device.
-    let irqs = [13, 14, 11, 10];
-    let compatible = "arm,armv8-timer";
-
-    let mut timer_reg_cells: Vec<u32> = Vec::new();
-    for &irq in irqs.iter() {
-        timer_reg_cells.push(GIC_FDT_IRQ_TYPE_PPI);
-        timer_reg_cells.push(irq);
-        timer_reg_cells.push(IRQ_TYPE_LEVEL_HI);
-    }
-    let timer_reg_prop = generate_prop32(timer_reg_cells.as_slice());
-
-    append_begin_node(fdt, "timer")?;
-    append_property_string(fdt, "compatible", compatible)?;
-    append_property_null(fdt, "always-on")?;
-    append_property(fdt, "interrupts", &timer_reg_prop)?;
-    append_end_node(fdt)?;
-
-    Ok(())
-}
-
-fn create_psci_node(fdt: &mut Vec<u8>) -> Result<()> {
-    let compatible = "arm,psci-0.2";
-    append_begin_node(fdt, "psci")?;
-    append_property_string(fdt, "compatible", compatible)?;
-    // Two methods available: hvc and smc.
-    // As per documentation, PSCI calls between a guest and hypervisor may use the HVC conduit instead of SMC.
-    // So, since we are using kvm, we need to use hvc.
-    append_property_string(fdt, "method", "hvc")?;
-    append_end_node(fdt)?;
-
-    Ok(())
-}
-
-fn create_virtio_node<T: DeviceInfoForFdt + Clone + Debug>(
-    fdt: &mut Vec<u8>,
-    dev_info: &T,
-) -> Result<()> {
-    let device_reg_prop = generate_prop64(&[dev_info.addr(), dev_info.length()]);
-    let irq = generate_prop32(&[GIC_FDT_IRQ_TYPE_SPI, dev_info.irq(), IRQ_TYPE_EDGE_RISING]);
-
-    append_begin_node(fdt, &format!("virtio_mmio@{:x}", dev_info.addr()))?;
-    append_property_string(fdt, "compatible", "virtio,mmio")?;
-    append_property(fdt, "reg", &device_reg_prop)?;
-    append_property(fdt, "interrupts", &irq)?;
-    append_property_u32(fdt, "interrupt-parent", GIC_PHANDLE)?;
-    append_end_node(fdt)?;
-
-    Ok(())
-}
-
-fn create_serial_node<T: DeviceInfoForFdt + Clone + Debug>(
-    fdt: &mut Vec<u8>,
-    dev_info: &T,
-) -> Result<()> {
-    let compatible = b"arm,pl011\0arm,primecell\0";
-    let serial_reg_prop = generate_prop64(&[dev_info.addr(), dev_info.length()]);
-    let irq = generate_prop32(&[GIC_FDT_IRQ_TYPE_SPI, dev_info.irq(), IRQ_TYPE_EDGE_RISING]);
-
-    append_begin_node(fdt, &format!("pl011@{:x}", dev_info.addr()))?;
-    append_property(fdt, "compatible", compatible)?;
-    append_property(fdt, "reg", &serial_reg_prop)?;
-    append_property_u32(fdt, "clocks", CLOCK_PHANDLE)?;
-    append_property_string(fdt, "clock-names", "apb_pclk")?;
-    append_property(fdt, "interrupts", &irq)?;
-    append_end_node(fdt)?;
-
-    Ok(())
-}
-
-fn create_rtc_node<T: DeviceInfoForFdt + Clone + Debug>(
-    fdt: &mut Vec<u8>,
-    dev_info: &T,
-) -> Result<()> {
-    let compatible = b"arm,pl031\0arm,primecell\0";
-    let rtc_reg_prop = generate_prop64(&[dev_info.addr(), dev_info.length()]);
-    let irq = generate_prop32(&[GIC_FDT_IRQ_TYPE_SPI, dev_info.irq(), IRQ_TYPE_LEVEL_HI]);
-    append_begin_node(fdt, &format!("rtc@{:x}", dev_info.addr()))?;
-    append_property(fdt, "compatible", compatible)?;
-    append_property(fdt, "reg", &rtc_reg_prop)?;
-    append_property(fdt, "interrupts", &irq)?;
-    append_property_u32(fdt, "clocks", CLOCK_PHANDLE)?;
-    append_property_string(fdt, "clock-names", "apb_pclk")?;
-    append_end_node(fdt)?;
-
-    Ok(())
-}
-
-fn create_gpio_node<T: DeviceInfoForFdt + Clone + Debug>(
-    fdt: &mut Vec<u8>,
-    dev_info: &T,
-) -> Result<()> {
-    // PL061 GPIO controller node
-    let compatible = b"arm,pl061\0arm,primecell\0";
-    let gpio_reg_prop = generate_prop64(&[dev_info.addr(), dev_info.length()]);
-    let irq = generate_prop32(&[GIC_FDT_IRQ_TYPE_SPI, dev_info.irq(), IRQ_TYPE_EDGE_RISING]);
-    append_begin_node(fdt, &format!("pl061@{:x}", dev_info.addr()))?;
-    append_property(fdt, "compatible", compatible)?;
-    append_property(fdt, "reg", &gpio_reg_prop)?;
-    append_property(fdt, "interrupts", &irq)?;
-    append_property_null(fdt, "gpio-controller")?;
-    append_property_u32(fdt, "#gpio-cells", 2)?;
-    append_property_u32(fdt, "clocks", CLOCK_PHANDLE)?;
-    append_property_string(fdt, "clock-names", "apb_pclk")?;
-    append_property_u32(fdt, "phandle", GPIO_PHANDLE)?;
-    append_end_node(fdt)?;
-
-    // gpio-keys node
-    append_begin_node(fdt, "/gpio-keys")?;
-    append_property_string(fdt, "compatible", "gpio-keys")?;
-    append_property_u32(fdt, "#size-cells", 0)?;
-    append_property_u32(fdt, "#address-cells", 1)?;
-    append_begin_node(fdt, "/gpio-keys/poweroff")?;
-    append_property_string(fdt, "label", "GPIO Key Poweroff")?;
-    append_property_u32(fdt, "linux,code", KEY_POWER)?;
-    let gpios = generate_prop32(&[GPIO_PHANDLE, 3, 0]);
-    append_property(fdt, "gpios", &gpios)?;
-    append_end_node(fdt)?;
-    append_end_node(fdt)?;
-
-    Ok(())
-}
-
-fn create_devices_node<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
-    fdt: &mut Vec<u8>,
-    dev_info: &HashMap<(DeviceType, String), T, S>,
-) -> Result<()> {
-    // Create one temp Vec to store all virtio devices
-    let mut ordered_virtio_device: Vec<&T> = Vec::new();
-
-    for ((device_type, _device_id), info) in dev_info {
-        match device_type {
-            DeviceType::Gpio => create_gpio_node(fdt, info)?,
-            DeviceType::Rtc => create_rtc_node(fdt, info)?,
-            DeviceType::Serial => create_serial_node(fdt, info)?,
-            DeviceType::Virtio(_) => {
-                ordered_virtio_device.push(info);
-            }
-        }
-    }
-
-    // Sort out virtio devices by address from low to high and insert them into fdt table.
-    ordered_virtio_device.sort_by_key(|&a| a.addr());
-    // Current address allocation strategy in cloud-hypervisor is: the first created device
-    // will be allocated to higher address. Here we reverse the vector to make sure that
-    // the older created device will appear in front of the newer created device in FDT.
-    ordered_virtio_device.reverse();
-    for ordered_device_info in ordered_virtio_device.drain(..) {
-        create_virtio_node(fdt, ordered_device_info)?;
-    }
-
-    Ok(())
-}
-
-fn create_pci_nodes(fdt: &mut Vec<u8>, pci_device_base: u64, pci_device_size: u64) -> Result<()> {
-    // Add node for PCIe controller.
-    // See Documentation/devicetree/bindings/pci/host-generic-pci.txt in the kernel
-    // and https://elinux.org/Device_Tree_Usage.
-    let ranges = generate_prop32(&[
-        // mmio addresses
-        0x2000000,                                // (ss = 10: 32-bit memory space)
-        (MEM_32BIT_DEVICES_START.0 >> 32) as u32, // PCI address
-        MEM_32BIT_DEVICES_START.0 as u32,
-        (MEM_32BIT_DEVICES_START.0 >> 32) as u32, // CPU address
-        MEM_32BIT_DEVICES_START.0 as u32,
-        (MEM_32BIT_DEVICES_SIZE >> 32) as u32, // size
-        MEM_32BIT_DEVICES_SIZE as u32,
-        // device addresses
-        0x3000000,                      // (ss = 11: 64-bit memory space)
-        (pci_device_base >> 32) as u32, // PCI address
-        pci_device_base as u32,
-        (pci_device_base >> 32) as u32, // CPU address
-        pci_device_base as u32,
-        (pci_device_size >> 32) as u32, // size
-        pci_device_size as u32,
-    ]);
-    let bus_range = generate_prop32(&[0, 0]); // Only bus 0
-    let reg = generate_prop64(&[PCI_MMCONFIG_START.0, PCI_MMCONFIG_SIZE]);
-
-    append_begin_node(fdt, "pci")?;
-    append_property_string(fdt, "compatible", "pci-host-ecam-generic")?;
-    append_property_string(fdt, "device_type", "pci")?;
-    append_property(fdt, "ranges", &ranges)?;
-    append_property(fdt, "bus-range", &bus_range)?;
-    append_property_u32(fdt, "#address-cells", 3)?;
-    append_property_u32(fdt, "#size-cells", 2)?;
-    append_property(fdt, "reg", &reg)?;
-    append_property_u32(fdt, "#interrupt-cells", 1)?;
-    append_property_null(fdt, "interrupt-map")?;
-    append_property_null(fdt, "interrupt-map-mask")?;
-    append_property_null(fdt, "dma-coherent")?;
-    append_property_u32(fdt, "msi-parent", MSI_PHANDLE)?;
-    append_end_node(fdt)?;
-
-    Ok(())
-}

arch/src/aarch64/gic/dist_regs.rs

@@ -1,182 +0,0 @@
-// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-use super::{Error, Result};
-use crate::layout::IRQ_BASE;
-use hypervisor::kvm::kvm_bindings::{
-    kvm_device_attr, KVM_DEV_ARM_VGIC_GRP_DIST_REGS, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
-};
-use std::sync::Arc;
-
-/*
- Distributor registers as detailed at page 456 from
- https://static.docs.arm.com/ihi0069/c/IHI0069C_gic_architecture_specification.pdf.
- Address offsets are relative to the Distributor base address defined
-by the system memory map. Unless otherwise stated in the register description,
-all GIC registers are 32-bits wide.
- */
-const GICD_CTLR: u32 = 0x0;
-const GICD_STATUSR: u32 = 0x0010;
-const GICD_IGROUPR: u32 = 0x0080;
-const GICD_ISENABLER: u32 = 0x0100;
-const GICD_ICENABLER: u32 = 0x0180;
-const GICD_ISPENDR: u32 = 0x0200;
-const GICD_ICPENDR: u32 = 0x0280;
-const GICD_ISACTIVER: u32 = 0x0300;
-const GICD_ICACTIVER: u32 = 0x0380;
-const GICD_IPRIORITYR: u32 = 0x0400;
-const GICD_ICFGR: u32 = 0x0C00;
-const GICD_IROUTER: u32 = 0x6000;
-
-/// This is how we represent the registers of the vgic's distributor.
-/// Some of the distributor register )(i.e GICD_STATUSR) are simple
-/// registers (i.e they are associated to a 32 bit value).
-/// However, there are other registers that have variable lengths since
-/// they dedicate some of the 32 bits to some specific interrupt. So, their length
-/// depends on the number of interrupts (i.e the ones that are represented as GICD_REG<n>)
-/// in the documentation mentioned above.
-struct DistReg {
-    /// Offset from distributor address.
-    base: u32,
-    /// Bits per interrupt.
-    /// Relevant for registers that DO share IRQs.
-    bpi: u8,
-    /// Length of the register.
-    /// Relevant for registers that DO NOT share IRQs.
-    length: u16,
-}
-
-// All or at least the registers we are interested in are 32 bit, so
-// we use a constant for size(u32).
-const REG_SIZE: u8 = 4;
-
-// Creates a vgic distributor register.
-macro_rules! VGIC_DIST_REG {
-    ($base:expr, $bpi:expr, $length:expr) => {
-        DistReg {
-            base: $base,
-            bpi: $bpi,
-            length: $length,
-        }
-    };
-}
-
-// List with relevant distributor registers that we will be restoring.
-// Order is taken from qemu.
-static VGIC_DIST_REGS: &'static [DistReg] = &[
-    VGIC_DIST_REG!(GICD_STATUSR, 0, 4),
-    VGIC_DIST_REG!(GICD_ICENABLER, 1, 0),
-    VGIC_DIST_REG!(GICD_ISENABLER, 1, 0),
-    VGIC_DIST_REG!(GICD_IGROUPR, 1, 0),
-    VGIC_DIST_REG!(GICD_IROUTER, 64, 0),
-    VGIC_DIST_REG!(GICD_ICFGR, 2, 0),
-    VGIC_DIST_REG!(GICD_ICPENDR, 1, 0),
-    VGIC_DIST_REG!(GICD_ISPENDR, 1, 0),
-    VGIC_DIST_REG!(GICD_ICACTIVER, 1, 0),
-    VGIC_DIST_REG!(GICD_ISACTIVER, 1, 0),
-    VGIC_DIST_REG!(GICD_IPRIORITYR, 8, 0),
-];
-
-fn dist_attr_access(
-    gic: &Arc<dyn hypervisor::Device>,
-    offset: u32,
-    val: &u32,
-    set: bool,
-) -> Result<()> {
-    let mut gic_dist_attr = kvm_device_attr {
-        group: KVM_DEV_ARM_VGIC_GRP_DIST_REGS,
-        attr: offset as u64,
-        addr: val as *const u32 as u64,
-        flags: 0,
-    };
-    if set {
-        gic.set_device_attr(&gic_dist_attr)
-            .map_err(Error::SetDeviceAttribute)?;
-    } else {
-        gic.get_device_attr(&mut gic_dist_attr)
-            .map_err(Error::GetDeviceAttribute)?;
-    }
-    Ok(())
-}
-
-/// Get the distributor control register.
-pub fn read_ctlr(gic: &Arc<dyn hypervisor::Device>) -> Result<u32> {
-    let val: u32 = 0;
-    dist_attr_access(gic, GICD_CTLR, &val, false)?;
-    Ok(val)
-}
-
-/// Set the distributor control register.
-pub fn write_ctlr(gic: &Arc<dyn hypervisor::Device>, val: u32) -> Result<()> {
-    dist_attr_access(gic, GICD_CTLR, &val, true)
-}
-
-fn get_interrupts_num(gic: &Arc<dyn hypervisor::Device>) -> Result<u32> {
-    let num_irq = 0;
-
-    let mut nr_irqs_attr = kvm_device_attr {
-        group: KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
-        attr: 0,
-        addr: &num_irq as *const u32 as u64,
-        flags: 0,
-    };
-    gic.get_device_attr(&mut nr_irqs_attr)
-        .map_err(Error::GetDeviceAttribute)?;
-    Ok(num_irq)
-}
-
-fn compute_reg_len(gic: &Arc<dyn hypervisor::Device>, reg: &DistReg, base: u32) -> Result<u32> {
-    let mut end = base;
-    let num_irq = get_interrupts_num(gic)?;
-    if reg.length > 0 {
-        // This is the single type register (i.e one that is not DIST_X<n>) and for which
-        // the bpi is 0.
-        // Look in the kernel for REGISTER_DESC_WITH_LENGTH.
-        end = base + reg.length as u32;
-    }
-    if reg.bpi > 0 {
-        // This is the type of register that takes into account the number of interrupts
-        // that the model has. It is also the type of register where
-        // a register relates to multiple interrupts.
-        end = base + (reg.bpi as u32 * (num_irq - IRQ_BASE) / 8);
-        if reg.bpi as u32 * (num_irq - IRQ_BASE) % 8 > 0 {
-            end += REG_SIZE as u32;
-        }
-    }
-    Ok(end)
-}
-
-/// Set distributor registers of the GIC.
-pub fn set_dist_regs(gic: &Arc<dyn hypervisor::Device>, state: &[u32]) -> Result<()> {
-    let mut idx = 0;
-
-    for dreg in VGIC_DIST_REGS {
-        let mut base = dreg.base + REG_SIZE as u32 * dreg.bpi as u32;
-        let end = compute_reg_len(gic, &dreg, base)?;
-
-        while base < end {
-            let val = state[idx];
-            dist_attr_access(gic, base, &val, true)?;
-            idx += 1;
-            base += REG_SIZE as u32;
-        }
-    }
-    Ok(())
-}
-/// Get distributor registers of the GIC.
-pub fn get_dist_regs(gic: &Arc<dyn hypervisor::Device>) -> Result<Vec<u32>> {
-    let mut state = Vec::new();
-
-    for dreg in VGIC_DIST_REGS {
-        let mut base = dreg.base + REG_SIZE as u32 * dreg.bpi as u32;
-        let end = compute_reg_len(gic, &dreg, base)?;
-
-        while base < end {
-            let val: u32 = 0;
-            dist_attr_access(gic, base, &val, false)?;
-            state.push(val);
-            base += REG_SIZE as u32;
-        }
-    }
-    Ok(state)
-}

arch/src/aarch64/gic/gicv3.rs

@@ -1,247 +0,0 @@
-// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-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::{get_redist_regs, set_redist_regs};
-    use crate::aarch64::gic::GicDevice;
-    use crate::layout;
-    use anyhow::anyhow;
-    use hypervisor::kvm::kvm_bindings;
-    use std::any::Any;
-    use std::convert::TryInto;
-    use std::sync::Arc;
-    use std::{boxed::Box, result};
-    use vm_migration::{
-        Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable,
-    };
-
-    /// 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
-        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(Serialize, Deserialize)]
-    pub struct Gicv3State {
-        dist: Vec<u32>,
-        rdist: Vec<u32>,
-        icc: Vec<u32>,
-        // special register that enables interrupts and affinity routing
-        gicd_ctlr: u32,
-    }
-
-    impl KvmGicV3 {
-        // Unfortunately bindgen omits defines that are based on other defines.
-        // See arch/arm64/include/uapi/asm/kvm.h file from the linux kernel.
-        pub const SZ_64K: u64 = 0x0001_0000;
-        const KVM_VGIC_V3_DIST_SIZE: u64 = KvmGicV3::SZ_64K;
-        const KVM_VGIC_V3_REDIST_SIZE: u64 = (2 * KvmGicV3::SZ_64K);
-
-        // 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::MAPPED_IO_START - KvmGicV3::KVM_VGIC_V3_DIST_SIZE
-        }
-
-        /// Get the size of the GIC distributor.
-        pub fn get_dist_size() -> u64 {
-            KvmGicV3::KVM_VGIC_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 * KvmGicV3::KVM_VGIC_V3_REDIST_SIZE
-        }
-
-        /// Save the state of GIC.
-        fn state(&self, gicr_typers: &[u64]) -> Result<Gicv3State> {
-            // Flush redistributors pending tables to guest RAM.
-            save_pending_tables(&self.device()).map_err(Error::SavePendingTables)?;
-
-            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_gicr_typers(&mut self, gicr_typers: Vec<u64>) {
-            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: &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_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_state(&self.id())?)
-                .map_err(|e| {
-                    MigratableError::Restore(anyhow!("Could not restore GICv3 state {:?}", e))
-                })
-        }
-    }
-
-    impl Pausable for KvmGicV3 {}
-    impl Transportable for KvmGicV3 {}
-    impl Migratable for KvmGicV3 {}
-}

arch/src/aarch64/gic/gicv3_its.rs

@@ -1,140 +0,0 @@
-// Copyright 2020 ARM Limited
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod kvm {
-    use std::any::Any;
-    use std::sync::Arc;
-    use std::{boxed::Box, result};
-    type Result<T> = result::Result<T, Error>;
-    use crate::aarch64::gic::gicv3::kvm::KvmGicV3;
-    use crate::aarch64::gic::kvm::KvmGicDevice;
-    use crate::aarch64::gic::{Error, GicDevice};
-    use hypervisor::kvm::kvm_bindings;
-
-    pub struct KvmGicV3Its {
-        /// The hypervisor agnostic device
-        device: Arc<dyn hypervisor::Device>,
-
-        /// 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,
-    }
-
-    impl KvmGicV3Its {
-        const KVM_VGIC_V3_ITS_SIZE: u64 = (2 * KvmGicV3::SZ_64K);
-
-        fn get_msi_size() -> u64 {
-            KvmGicV3Its::KVM_VGIC_V3_ITS_SIZE
-        }
-
-        fn get_msi_addr(vcpu_count: u64) -> u64 {
-            KvmGicV3::get_redists_addr(vcpu_count) - KvmGicV3Its::get_msi_size()
-        }
-    }
-
-    impl GicDevice for KvmGicV3Its {
-        fn device(&self) -> &Arc<dyn hypervisor::Device> {
-            &self.device
-        }
-
-        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_gicr_typers(&mut self, _gicr_typers: Vec<u64>) {}
-
-        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,
-                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: &dyn GicDevice,
-        ) -> 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(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,
-            )?;
-
-            Ok(())
-        }
-    }
-}

arch/src/aarch64/gic/icc_regs.rs

@@ -1,196 +0,0 @@
-// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-use super::{Error, Result};
-use hypervisor::kvm::kvm_bindings::{
-    kvm_device_attr, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS, KVM_REG_ARM64_SYSREG_CRM_MASK,
-    KVM_REG_ARM64_SYSREG_CRM_SHIFT, KVM_REG_ARM64_SYSREG_CRN_MASK, KVM_REG_ARM64_SYSREG_CRN_SHIFT,
-    KVM_REG_ARM64_SYSREG_OP0_MASK, KVM_REG_ARM64_SYSREG_OP0_SHIFT, KVM_REG_ARM64_SYSREG_OP1_MASK,
-    KVM_REG_ARM64_SYSREG_OP1_SHIFT, KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_ARM64_SYSREG_OP2_SHIFT,
-};
-use std::sync::Arc;
-
-const KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT: u32 = 32;
-const KVM_DEV_ARM_VGIC_V3_MPIDR_MASK: u64 = 0xffffffff << KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT as u64;
-
-const ICC_CTLR_EL1_PRIBITS_SHIFT: u32 = 8;
-const ICC_CTLR_EL1_PRIBITS_MASK: u32 = 7 << ICC_CTLR_EL1_PRIBITS_SHIFT;
-
-macro_rules! arm64_vgic_sys_reg {
-    ($name: tt, $op0: tt, $op1: tt, $crn: tt, $crm: tt, $op2: expr) => {
-        const $name: u64 = ((($op0 as u64) << KVM_REG_ARM64_SYSREG_OP0_SHIFT)
-            & KVM_REG_ARM64_SYSREG_OP0_MASK as u64)
-            | ((($op1 as u64) << KVM_REG_ARM64_SYSREG_OP1_SHIFT)
-                & KVM_REG_ARM64_SYSREG_OP1_MASK as u64)
-            | ((($crn as u64) << KVM_REG_ARM64_SYSREG_CRN_SHIFT)
-                & KVM_REG_ARM64_SYSREG_CRN_MASK as u64)
-            | ((($crm as u64) << KVM_REG_ARM64_SYSREG_CRM_SHIFT)
-                & KVM_REG_ARM64_SYSREG_CRM_MASK as u64)
-            | ((($op2 as u64) << KVM_REG_ARM64_SYSREG_OP2_SHIFT)
-                & KVM_REG_ARM64_SYSREG_OP2_MASK as u64);
-    };
-}
-
-macro_rules! SYS_ICC_AP0Rn_EL1 {
-    ($name: tt, $n: tt) => {
-        arm64_vgic_sys_reg!($name, 3, 0, 12, 8, (4 | $n));
-    };
-}
-
-macro_rules! SYS_ICC_AP1Rn_EL1 {
-    ($name: tt, $n: tt) => {
-        arm64_vgic_sys_reg!($name, 3, 0, 12, 9, $n);
-    };
-}
-
-arm64_vgic_sys_reg!(SYS_ICC_SRE_EL1, 3, 0, 12, 12, 5);
-arm64_vgic_sys_reg!(SYS_ICC_CTLR_EL1, 3, 0, 12, 12, 4);
-arm64_vgic_sys_reg!(SYS_ICC_IGRPEN0_EL1, 3, 0, 12, 12, 6);
-arm64_vgic_sys_reg!(SYS_ICC_IGRPEN1_EL1, 3, 0, 12, 12, 7);
-arm64_vgic_sys_reg!(SYS_ICC_PMR_EL1, 3, 0, 4, 6, 0);
-arm64_vgic_sys_reg!(SYS_ICC_BPR0_EL1, 3, 0, 12, 8, 3);
-arm64_vgic_sys_reg!(SYS_ICC_BPR1_EL1, 3, 0, 12, 12, 3);
-SYS_ICC_AP0Rn_EL1!(SYS_ICC_AP0R0_EL1, 0);
-SYS_ICC_AP0Rn_EL1!(SYS_ICC_AP0R1_EL1, 1);
-SYS_ICC_AP0Rn_EL1!(SYS_ICC_AP0R2_EL1, 2);
-SYS_ICC_AP0Rn_EL1!(SYS_ICC_AP0R3_EL1, 3);
-SYS_ICC_AP1Rn_EL1!(SYS_ICC_AP1R0_EL1, 0);
-SYS_ICC_AP1Rn_EL1!(SYS_ICC_AP1R1_EL1, 1);
-SYS_ICC_AP1Rn_EL1!(SYS_ICC_AP1R2_EL1, 2);
-SYS_ICC_AP1Rn_EL1!(SYS_ICC_AP1R3_EL1, 3);
-
-static VGIC_ICC_REGS: &'static [u64] = &[
-    SYS_ICC_SRE_EL1,
-    SYS_ICC_CTLR_EL1,
-    SYS_ICC_IGRPEN0_EL1,
-    SYS_ICC_IGRPEN1_EL1,
-    SYS_ICC_PMR_EL1,
-    SYS_ICC_BPR0_EL1,
-    SYS_ICC_BPR1_EL1,
-    SYS_ICC_AP0R0_EL1,
-    SYS_ICC_AP0R1_EL1,
-    SYS_ICC_AP0R2_EL1,
-    SYS_ICC_AP0R3_EL1,
-    SYS_ICC_AP1R0_EL1,
-    SYS_ICC_AP1R1_EL1,
-    SYS_ICC_AP1R2_EL1,
-    SYS_ICC_AP1R3_EL1,
-];
-
-fn icc_attr_access(
-    gic: &Arc<dyn hypervisor::Device>,
-    offset: u64,
-    typer: u64,
-    val: &u32,
-    set: bool,
-) -> Result<()> {
-    let mut gic_icc_attr = kvm_device_attr {
-        group: KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
-        attr: ((typer & KVM_DEV_ARM_VGIC_V3_MPIDR_MASK) | offset), // this needs the mpidr
-        addr: val as *const u32 as u64,
-        flags: 0,
-    };
-    if set {
-        #[allow(clippy::unnecessary_mut_passed)]
-        gic.set_device_attr(&mut gic_icc_attr)
-            .map_err(Error::SetDeviceAttribute)?;
-    } else {
-        gic.get_device_attr(&mut gic_icc_attr)
-            .map_err(Error::GetDeviceAttribute)?;
-    }
-    Ok(())
-}
-
-/// Get ICC registers.
-pub fn get_icc_regs(gic: &Arc<dyn hypervisor::Device>, gicr_typer: &[u64]) -> Result<Vec<u32>> {
-    let mut state: Vec<u32> = Vec::new();
-    // We need this for the ICC_AP<m>R<n>_EL1 registers.
-    let mut num_priority_bits = 0;
-
-    for ix in gicr_typer {
-        let i = *ix;
-        for icc_offset in VGIC_ICC_REGS {
-            let val = 0;
-            if *icc_offset == SYS_ICC_CTLR_EL1 {
-                // calculate priority bits by reading the ctrl_el1 register.
-                icc_attr_access(gic, *icc_offset, i, &val, false)?;
-                // The priority bits are found in the ICC_CTLR_EL1 register (bits from  10:8).
-                // See page 194 from https://static.docs.arm.com/ihi0069/c/IHI0069C_gic_
-                // architecture_specification.pdf.
-                // Citation:
-                // "Priority bits. Read-only and writes are ignored. The number of priority bits
-                // implemented, minus one."
-                num_priority_bits =
-                    ((val & ICC_CTLR_EL1_PRIBITS_MASK) >> ICC_CTLR_EL1_PRIBITS_SHIFT) + 1;
-                state.push(val);
-            }
-            // As per ARMv8 documentation: https://static.docs.arm.com/ihi0069/c/IHI0069C_
-            // gic_architecture_specification.pdf
-            // page 178,
-            // ICC_AP0R1_EL1 is only implemented in implementations that support 6 or more bits of
-            // priority.
-            // ICC_AP0R2_EL1 and ICC_AP0R3_EL1 are only implemented in implementations that support
-            // 7 bits of priority.
-            else if *icc_offset == SYS_ICC_AP0R1_EL1 || *icc_offset == SYS_ICC_AP1R1_EL1 {
-                if num_priority_bits >= 6 {
-                    icc_attr_access(gic, *icc_offset, i, &val, false)?;
-                    state.push(val);
-                }
-            } else if *icc_offset == SYS_ICC_AP0R2_EL1
-                || *icc_offset == SYS_ICC_AP0R3_EL1
-                || *icc_offset == SYS_ICC_AP1R2_EL1
-                || *icc_offset == SYS_ICC_AP1R3_EL1
-            {
-                if num_priority_bits == 7 {
-                    icc_attr_access(gic, *icc_offset, i, &val, false)?;
-                    state.push(val);
-                }
-            } else {
-                icc_attr_access(gic, *icc_offset, i, &val, false)?;
-                state.push(val);
-            }
-        }
-    }
-    Ok(state)
-}
-
-/// Set ICC registers.
-pub fn set_icc_regs(
-    gic: &Arc<dyn hypervisor::Device>,
-    gicr_typer: &[u64],
-    state: &[u32],
-) -> Result<()> {
-    let mut num_priority_bits = 0;
-    let mut idx = 0;
-    for ix in gicr_typer {
-        let i = *ix;
-        for icc_offset in VGIC_ICC_REGS {
-            if *icc_offset == SYS_ICC_CTLR_EL1 {
-                let ctrl_el1 = state[idx];
-                num_priority_bits =
-                    ((ctrl_el1 & ICC_CTLR_EL1_PRIBITS_MASK) >> ICC_CTLR_EL1_PRIBITS_SHIFT) + 1;
-            }
-            if *icc_offset == SYS_ICC_AP0R1_EL1 || *icc_offset == SYS_ICC_AP1R1_EL1 {
-                if num_priority_bits >= 6 {
-                    icc_attr_access(gic, *icc_offset, i, &state[idx], true)?;
-                    idx += 1;
-                }
-                continue;
-            }
-            if *icc_offset == SYS_ICC_AP0R2_EL1
-                || *icc_offset == SYS_ICC_AP0R3_EL1
-                || *icc_offset == SYS_ICC_AP1R2_EL1
-                || *icc_offset == SYS_ICC_AP1R3_EL1
-            {
-                if num_priority_bits == 7 {
-                    icc_attr_access(gic, *icc_offset, i, &state[idx], true)?;
-                    idx += 1;
-                }
-                continue;
-            }
-            icc_attr_access(gic, *icc_offset, i, &state[idx], true)?;
-            idx += 1;
-        }
-    }
-    Ok(())
-}

arch/src/aarch64/gic/mod.rs

@@ -1,211 +0,0 @@
-// 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 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 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] {
-        &[]
-    }
-
-    /// Get the values of GICR_TYPER for each vCPU.
-    fn set_gicr_typers(&mut self, gicr_typers: Vec<u64>);
-
-    /// 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: &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_MAX - layout::IRQ_BASE + 1;
-            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 device = Self::create_device(vgic_fd, vcpu_count);
-
-            Self::init_device_attributes(vm, &*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/gic/redist_regs.rs

@@ -1,179 +0,0 @@
-// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-use super::{Error, Result};
-use hypervisor::kvm::kvm_bindings::{kvm_device_attr, KVM_DEV_ARM_VGIC_GRP_REDIST_REGS};
-use std::sync::Arc;
-
-// Relevant redistributor registers that we want to save/restore.
-const GICR_CTLR: u32 = 0x0000;
-const GICR_STATUSR: u32 = 0x0010;
-const GICR_WAKER: u32 = 0x0014;
-const GICR_PROPBASER: u32 = 0x0070;
-const GICR_PENDBASER: u32 = 0x0078;
-
-/* SGI and PPI Redistributor registers, offsets from RD_base */
-/*
- * Redistributor frame offsets from RD_base which is actually SZ_
- */
-const GICR_SGI_OFFSET: u32 = 0x0001_0000;
-const GICR_IGROUPR0: u32 = GICR_SGI_OFFSET + 0x0080;
-const GICR_ICENABLER0: u32 = GICR_SGI_OFFSET + 0x0180;
-const GICR_ISENABLER0: u32 = GICR_SGI_OFFSET + 0x0100;
-const GICR_ISPENDR0: u32 = GICR_SGI_OFFSET + 0x0200;
-const GICR_ICPENDR0: u32 = GICR_SGI_OFFSET + 0x0280;
-const GICR_ISACTIVER0: u32 = GICR_SGI_OFFSET + 0x0300;
-const GICR_ICACTIVER0: u32 = GICR_SGI_OFFSET + 0x0380;
-const GICR_IPRIORITYR0: u32 = GICR_SGI_OFFSET + 0x0400;
-const GICR_ICFGR0: u32 = GICR_SGI_OFFSET + 0x0C00;
-
-const KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT: u32 = 32;
-const KVM_DEV_ARM_VGIC_V3_MPIDR_MASK: u64 = 0xffffffff << KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT as u64;
-
-/// This is how we represent the registers of a distributor.
-/// It is relrvant their offset from the base address of the
-/// distributor.
-/// Each register has a different number
-/// of bits_per_irq and is therefore variable length.
-/// First 32 interrupts (0-32) are private to each CPU (SGIs and PPIs).
-/// and so we save the first irq to identify between the type of the interrupt
-/// that the respective register deals with.
-struct RdistReg {
-    /// Offset from distributor address.
-    base: u32,
-    /// Length of the register.
-    length: u8,
-}
-
-// All or at least the registers we are interested in are 32 bit, so
-// we use a constant for size(u32).
-const REG_SIZE: u8 = 4;
-
-// Creates a vgic redistributor register.
-macro_rules! VGIC_RDIST_REG {
-    ($base:expr, $len:expr) => {
-        RdistReg {
-            base: $base,
-            length: $len,
-        }
-    };
-}
-
-// List with relevant distributor registers that we will be restoring.
-static VGIC_RDIST_REGS: &'static [RdistReg] = &[
-    VGIC_RDIST_REG!(GICR_CTLR, 4),
-    VGIC_RDIST_REG!(GICR_STATUSR, 4),
-    VGIC_RDIST_REG!(GICR_WAKER, 4),
-    VGIC_RDIST_REG!(GICR_PROPBASER, 8),
-    VGIC_RDIST_REG!(GICR_PENDBASER, 8),
-];
-
-// List with relevant distributor registers that we will be restoring.
-static VGIC_SGI_REGS: &'static [RdistReg] = &[
-    VGIC_RDIST_REG!(GICR_IGROUPR0, 4),
-    VGIC_RDIST_REG!(GICR_ICENABLER0, 4),
-    VGIC_RDIST_REG!(GICR_ISENABLER0, 4),
-    VGIC_RDIST_REG!(GICR_ICFGR0, 8),
-    VGIC_RDIST_REG!(GICR_ICPENDR0, 4),
-    VGIC_RDIST_REG!(GICR_ISPENDR0, 4),
-    VGIC_RDIST_REG!(GICR_ICACTIVER0, 4),
-    VGIC_RDIST_REG!(GICR_ISACTIVER0, 4),
-    VGIC_RDIST_REG!(GICR_IPRIORITYR0, 32),
-];
-
-fn redist_attr_access(
-    gic: &Arc<dyn hypervisor::Device>,
-    offset: u32,
-    typer: u64,
-    val: &u32,
-    set: bool,
-) -> Result<()> {
-    let mut gic_dist_attr = kvm_device_attr {
-        group: KVM_DEV_ARM_VGIC_GRP_REDIST_REGS,
-        attr: (typer & KVM_DEV_ARM_VGIC_V3_MPIDR_MASK) | (offset as u64), // this needs the mpidr
-        addr: val as *const u32 as u64,
-        flags: 0,
-    };
-    if set {
-        #[allow(clippy::unnecessary_mut_passed)]
-        gic.set_device_attr(&mut gic_dist_attr)
-            .map_err(Error::SetDeviceAttribute)?;
-    } else {
-        gic.get_device_attr(&mut gic_dist_attr)
-            .map_err(Error::GetDeviceAttribute)?;
-    }
-    Ok(())
-}
-
-fn access_redists_aux(
-    gic: &Arc<dyn hypervisor::Device>,
-    gicr_typer: &[u64],
-    state: &mut Vec<u32>,
-    reg_list: &'static [RdistReg],
-    idx: &mut usize,
-    set: bool,
-) -> Result<()> {
-    for i in gicr_typer {
-        for rdreg in reg_list {
-            let mut base = rdreg.base;
-            let end = base + rdreg.length as u32;
-
-            while base < end {
-                let mut val = 0;
-                if set {
-                    val = state[*idx];
-                    redist_attr_access(gic, base, *i, &val, true)?;
-                    *idx += 1;
-                } else {
-                    redist_attr_access(gic, base, *i, &val, false)?;
-                    state.push(val);
-                }
-                base += REG_SIZE as u32;
-            }
-        }
-    }
-    Ok(())
-}
-
-/// Get redistributor registers.
-pub fn get_redist_regs(gic: &Arc<dyn hypervisor::Device>, gicr_typer: &[u64]) -> Result<Vec<u32>> {
-    let mut state = Vec::new();
-    let mut idx: usize = 0;
-    access_redists_aux(
-        gic,
-        &gicr_typer,
-        &mut state,
-        VGIC_RDIST_REGS,
-        &mut idx,
-        false,
-    )?;
-
-    access_redists_aux(gic, &gicr_typer, &mut state, VGIC_SGI_REGS, &mut idx, false)?;
-    Ok(state)
-}
-
-/// Set redistributor registers.
-pub fn set_redist_regs(
-    gic: &Arc<dyn hypervisor::Device>,
-    gicr_typer: &[u64],
-    state: &[u32],
-) -> Result<()> {
-    let mut idx: usize = 0;
-    let mut mut_state = state.to_owned();
-    access_redists_aux(
-        gic,
-        gicr_typer,
-        &mut mut_state,
-        VGIC_RDIST_REGS,
-        &mut idx,
-        true,
-    )?;
-    access_redists_aux(
-        gic,
-        gicr_typer,
-        &mut mut_state,
-        VGIC_SGI_REGS,
-        &mut idx,
-        true,
-    )
-}

arch/src/aarch64/layout.rs

@@ -1,101 +1,7 @@
-// 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 Aarch64 guest:
-//
-// Physical  +---------------------------------------------------------------+
-// address   |                                                               |
-// end       |                                                               |
-//           ~                   ~                       ~                   ~
-//           |                                                               |
-//           |                      Highmem PCI MMIO space                   |
-//           |                                                               |
-// RAM end   +---------------------------------------------------------------+
-// (dynamic, |                                                               |
-// including |                                                               |
-// hotplug   ~                   ~                       ~                   ~
-// memory)   |                                                               |
-//           |                            DRAM                               |
-//           |                                                               |
-//           |                                                               |
-//           |                                                               |
-// 1GB       +---------------------------------------------------------------+
-//           |                                                               |
-//           |                        PCI MMCONFIG space                     |
-//           |                                                               |
-// 768 M     +---------------------------------------------------------------+
-//           |                                                               |
-//           |                                                               |
-//           |                           PCI MMIO space                      |
-//           |                                                               |
-// 256 M     +---------------------------------------------------------------|
-//           |                                                               |
-//           |                        Legacy devices space                   |
-//           |                                                               |
-// 144 M     +---------------------------------------------------------------|
-//           |                    Reserved (now GIC is here)                 |
-// 128 M     +---------------------------------------------------------------+
-//           |                                                               |
-//           |                          UEFI space                           |
-//           |                                                               |
-// 0GB       +---------------------------------------------------------------+
-//
-//
-
-use vm_memory::GuestAddress;
-
-/// 0x0 ~ 0x800_0000 is reserved to uefi
-pub const UEFI_START: u64 = 0x0;
-pub const MEM_UEFI_START: GuestAddress = GuestAddress(0);
-pub const UEFI_SIZE: u64 = 0x0800_0000;
-
-/// Below this address will reside the GIC, above this address will reside the MMIO devices.
-pub const MAPPED_IO_START: u64 = 0x0900_0000;
-
-/// Space 0x0900_0000 ~ 0x1000_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;
-
-/// Space 0x0902_0000 ~ 0x903_0000 is reserved for pcie io address
-pub const MEM_PCI_IO_START: GuestAddress = GuestAddress(0x0902_0000);
-pub const MEM_PCI_IO_SIZE: u64 = 0x10000;
-
-/// Legacy space will be allocated at once whiling setting up legacy devices.
-pub const LEGACY_DEVICES_MAPPED_IO_SIZE: u64 = 0x0700_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 1 GiB, length: 256MiB)
-pub const PCI_MMCONFIG_START: GuestAddress = GuestAddress(0x3000_0000);
-pub const PCI_MMCONFIG_SIZE: u64 = 256 << 20;
-
-/// Start of RAM on 64 bit ARM.
-pub const RAM_64BIT_START: u64 = 0x4000_0000;
-
-/// Kernel command line maximum size.
-/// As per `arch/arm64/include/uapi/asm/setup.h`.
-pub const CMDLINE_MAX_SIZE: usize = 2048;
-
-/// Maximum size of the device tree blob as specified in https://www.kernel.org/doc/Documentation/arm64/booting.txt.
-pub const FDT_MAX_SIZE: usize = 0x20_0000;
-
-/// Put ACPI table above dtb
-pub const ACPI_START: u64 = RAM_64BIT_START + FDT_MAX_SIZE as u64;
-pub const RSDP_POINTER: GuestAddress = GuestAddress(ACPI_START);
-
-// As per virt/kvm/arm/vgic/vgic-kvm-device.c we need
-// the number of interrupts our GIC will support to be:
-// * bigger than 32
-// * less than 1023 and
-// * a multiple of 32.
-// We are setting up our interrupt controller to support a maximum of 256 interrupts.
-/// First usable interrupt on aarch64.
-pub const IRQ_BASE: u32 = 0;
-
-/// Last usable interrupt on aarch64.
-pub const IRQ_MAX: u32 = 255;
+/// Kernel command line start address.
+pub const CMDLINE_START: usize = 0x0;
+/// Kernel command line start address maximum size.
+pub const CMDLINE_MAX_SIZE: usize = 0x0;

arch/src/aarch64/mod.rs

@@ -1,242 +1,27 @@
-// 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;
-/// 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;
 
-pub use self::fdt::DeviceInfoForFdt;
-use crate::DeviceType;
-use crate::RegionType;
-use aarch64::gic::GicDevice;
-use std::collections::HashMap;
-use std::ffi::CStr;
-use std::fmt::Debug;
-use std::sync::Arc;
-use vm_memory::{
-    Address, GuestAddress, GuestAddressSpace, GuestMemory, GuestMemoryAtomic, GuestMemoryMmap,
-    GuestUsize,
-};
+use memory_model::{GuestAddress, GuestMemory};
 
-/// Errors thrown while configuring aarch64 system.
-#[derive(Debug)]
-pub enum Error {
-    /// Failed to create a FDT.
-    SetupFdt(fdt::Error),
-
-    /// Failed to create a GIC.
-    SetupGic(gic::Error),
-
-    /// Failed to compute the initramfs address.
-    InitramfsAddress,
-
-    /// Error configuring the general purpose registers
-    RegsConfiguration(regs::Error),
-
-    /// Error configuring the MPIDR register
-    VcpuRegMpidr(hypervisor::HypervisorCpuError),
+/// Stub function that needs to be implemented when aarch64 functionality is added.
+pub fn arch_memory_regions(size: usize) -> Vec<(GuestAddress, usize, RegionType)> {
+    vec![(GuestAddress(0), size, RegionType::Ram)]
 }
 
-impl From<Error> for super::Error {
-    fn from(e: Error) -> super::Error {
-        super::Error::AArch64Setup(e)
-    }
+/// Stub function that needs to be implemented when aarch64 functionality is added.
+pub fn configure_system(
+    _guest_mem: &GuestMemory,
+    _cmdline_addr: GuestAddress,
+    _cmdline_size: usize,
+    _num_cpus: u8,
+    _rsdp_addr: Option<GuestAddress>,
+) -> super::Result<()> {
+    Ok(())
 }
 
-#[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(
-    fd: &Arc<dyn hypervisor::Vcpu>,
-    id: u8,
-    kernel_entry_point: Option<EntryPoint>,
-    vm_memory: &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(),
-            &vm_memory.memory(),
-        )
-        .map_err(Error::RegsConfiguration)?;
-    }
-
-    let mpidr = fd.read_mpidr().map_err(Error::VcpuRegMpidr)?;
-    Ok(mpidr)
-}
-
-pub fn arch_memory_regions(size: GuestUsize) -> Vec<(GuestAddress, usize, RegionType)> {
-    vec![
-        // 0 ~ 256 MiB: Reserved
-        (
-            GuestAddress(0),
-            layout::MEM_32BIT_DEVICES_START.0 as usize,
-            RegionType::Reserved,
-        ),
-        // 256 MiB ~ 1 G: MMIO space
-        (
-            layout::MEM_32BIT_DEVICES_START,
-            layout::MEM_32BIT_DEVICES_SIZE as usize,
-            RegionType::SubRegion,
-        ),
-        // 1G  ~ 2G: reserved. The leading 256M for PCIe MMCONFIG space
-        (
-            layout::PCI_MMCONFIG_START,
-            (layout::RAM_64BIT_START - layout::PCI_MMCONFIG_START.0) as usize,
-            RegionType::Reserved,
-        ),
-        (
-            GuestAddress(layout::RAM_64BIT_START),
-            size as usize,
-            RegionType::Ram,
-        ),
-    ]
-}
-
-/// Configures the system and should be called once per vm before starting vcpu threads.
-///
-/// # Arguments
-///
-/// * `guest_mem` - The memory to be used by the guest.
-/// * `num_cpus` - Number of virtual CPUs the guest will have.
-#[allow(clippy::too_many_arguments)]
-pub fn configure_system<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
-    vm: &Arc<dyn hypervisor::Vm>,
-    guest_mem: &GuestMemoryMmap,
-    cmdline_cstring: &CStr,
-    vcpu_count: u64,
-    vcpu_mpidr: Vec<u64>,
-    device_info: &HashMap<(DeviceType, String), T, S>,
-    initrd: &Option<super::InitramfsConfig>,
-    pci_space_address: &(u64, u64),
-) -> super::Result<Box<dyn GicDevice>> {
-    let gic_device = gic::kvm::create_gic(vm, vcpu_count).map_err(Error::SetupGic)?;
-
-    fdt::create_fdt(
-        guest_mem,
-        cmdline_cstring,
-        vcpu_mpidr,
-        device_info,
-        &*gic_device,
-        initrd,
-        pci_space_address,
-    )
-    .map_err(Error::SetupFdt)?;
-
-    Ok(gic_device)
-}
-
-/// 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 GuestAddress(get_fdt_addr(&guest_mem))
-        .checked_sub(round_to_pagesize(initramfs_size) as u64)
-    {
-        Some(offset) => {
-            if guest_mem.address_in_range(offset) {
-                Ok(offset.raw_value())
-            } else {
-                Err(super::Error::AArch64Setup(Error::InitramfsAddress))
-            }
-        }
-        None => Err(super::Error::AArch64Setup(Error::InitramfsAddress)),
-    }
-}
-
-/// Returns the memory address where the kernel could be loaded.
-pub fn get_kernel_start() -> u64 {
-    layout::RAM_64BIT_START
-}
-
-// Auxiliary function to get the address where the device tree blob is loaded.
-fn get_fdt_addr(mem: &GuestMemoryMmap) -> u64 {
-    // If the memory allocated is smaller than the size allocated for the FDT,
-    // we return the start of the DRAM so that
-    // we allow the code to try and load the FDT.
-
-    if let Some(addr) = mem.last_addr().checked_sub(layout::FDT_MAX_SIZE as u64 - 1) {
-        if mem.address_in_range(addr) {
-            return addr.raw_value();
-        }
-    }
-
-    layout::RAM_64BIT_START
-}
-
-pub fn get_host_cpu_phys_bits() -> u8 {
-    // The value returned here is used to determine the physical address space size
-    // for a VM (IPA size).
-    // In recent kernel versions, the maximum IPA size supported by the host can be
-    // known by querying cap KVM_CAP_ARM_VM_IPA_SIZE. And the IPA size for a
-    // guest can be configured smaller.
-    // But in Cloud-Hypervisor we simply use the maximum value for the VM.
-    // Reference https://lwn.net/Articles/766767/.
-    //
-    // The correct way to query KVM_CAP_ARM_VM_IPA_SIZE is via rust-vmm/kvm-ioctls,
-    // which wraps all IOCTL's and provides easy interface to user hypervisors.
-    // For now the cap hasn't been supported. A separate patch will be submitted to
-    // rust-vmm to add it.
-    // So a hardcoded value is used here as a temporary solution.
-    // It will be replace once rust-vmm/kvm-ioctls is ready.
-    //
-    40
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_arch_memory_regions_dram() {
-        let regions = arch_memory_regions((1usize << 32) as u64); //4GB
-        assert_eq!(4, regions.len());
-        assert_eq!(GuestAddress(layout::RAM_64BIT_START), regions[3].0);
-        assert_eq!(1usize << 32, regions[3].1);
-        assert_eq!(RegionType::Ram, regions[3].2);
-    }
-
-    #[test]
-    fn test_get_fdt_addr() {
-        let mut regions = Vec::new();
-
-        regions.push((
-            GuestAddress(layout::RAM_64BIT_START),
-            (layout::FDT_MAX_SIZE - 0x1000) as usize,
-        ));
-        let mem = GuestMemoryMmap::from_ranges(&regions).expect("Cannot initialize memory");
-        assert_eq!(get_fdt_addr(&mem), layout::RAM_64BIT_START);
-        regions.clear();
-
-        regions.push((
-            GuestAddress(layout::RAM_64BIT_START),
-            (layout::FDT_MAX_SIZE) as usize,
-        ));
-        let mem = GuestMemoryMmap::from_ranges(&regions).expect("Cannot initialize memory");
-        assert_eq!(get_fdt_addr(&mem), layout::RAM_64BIT_START);
-        regions.clear();
-
-        regions.push((
-            GuestAddress(layout::RAM_64BIT_START),
-            (layout::FDT_MAX_SIZE + 0x1000) as usize,
-        ));
-        let mem = GuestMemoryMmap::from_ranges(&regions).expect("Cannot initialize memory");
-        assert_eq!(get_fdt_addr(&mem), 0x1000 + layout::RAM_64BIT_START);
-        regions.clear();
-    }
+/// Stub function that needs to be implemented when aarch64 functionality is added.
+pub fn get_reserved_mem_addr() -> usize {
+    0
 }

arch/src/aarch64/regs.rs

@@ -1,81 +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};
-use vm_memory::GuestMemoryMmap;
-
-/// 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,
-    mem: &GuestMemoryMmap,
-) -> 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(mem) as u64,
-        )
-        .map_err(Error::SetCoreRegister)?;
-    }
-    Ok(())
-}

arch/src/lib.rs

@@ -1,69 +1,40 @@
-// Copyright 2020 Arm Limited (or its affiliates). All rights reserved.
-// Copyright © 2020, Oracle and/or its affiliates.
-//
 // Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-//! Implements platform specific functionality.
-//! Supported platforms: x86_64, aarch64.
-#![allow(clippy::transmute_ptr_to_ptr, clippy::redundant_static_lifetimes)]
+#![allow(
+    clippy::unreadable_literal,
+    clippy::redundant_static_lifetimes,
+    clippy::cast_lossless,
+    clippy::transmute_ptr_to_ptr,
+    clippy::cast_ptr_alignment
+)]
 
-extern crate anyhow;
 extern crate byteorder;
-extern crate hypervisor;
+extern crate kvm_bindings;
 extern crate libc;
-#[macro_use]
-extern crate log;
+
 #[cfg(feature = "acpi")]
 extern crate acpi_tables;
 extern crate arch_gen;
+extern crate kvm_ioctls;
 extern crate linux_loader;
-extern crate serde;
 extern crate vm_memory;
-extern crate vm_migration;
-#[cfg(target_arch = "aarch64")]
-#[macro_use]
-extern crate serde_derive;
-extern crate serde_json;
-extern crate thiserror;
 
-use std::fmt;
 use std::result;
 
-/// Type for returning error code.
 #[derive(Debug)]
 pub enum Error {
     #[cfg(target_arch = "x86_64")]
     /// X86_64 specific error triggered during system configuration.
     X86_64Setup(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.
-    MemmapTablePastRamEnd,
-    /// Error writing memory map table to guest memory.
-    MemmapTableSetup,
-    /// The hvm_start_info structure extends past the end of guest memory.
-    StartInfoPastRamEnd,
-    /// Error writing hvm_start_info to guest memory.
-    StartInfoSetup,
-    /// Failed to compute initramfs address.
-    InitramfsAddress,
-    /// Error writing module entry to guest memory.
-    ModlistSetup(vm_memory::GuestMemoryError),
-    /// RSDP Beyond Guest Memory
-    RsdpPastRamEnd,
 }
-
-/// Type for returning public functions outcome.
 pub type Result<T> = result::Result<T, Error>;
 
-/// Type for memory region types.
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq)]
 pub enum RegionType {
     /// RAM type
     Ram,
@@ -81,15 +52,13 @@ pub enum RegionType {
     Reserved,
 }
 
-/// 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, initramfs_load_addr, layout,
-    layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, layout::IRQ_MAX, EntryPoint,
+    arch_memory_regions, configure_system, get_reserved_mem_addr, layout::CMDLINE_MAX_SIZE,
+    layout::CMDLINE_START,
 };
 
 #[cfg(target_arch = "x86_64")]
@@ -97,69 +66,5 @@ pub mod x86_64;
 
 #[cfg(target_arch = "x86_64")]
 pub use x86_64::{
-    arch_memory_regions, configure_system, configure_vcpu, get_host_cpu_phys_bits,
-    initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE, layout::CMDLINE_START, regs,
-    BootProtocol, CpuidPatch, CpuidReg, EntryPoint,
+    arch_memory_regions, configure_system, layout, layout::CMDLINE_MAX_SIZE, layout::CMDLINE_START,
 };
-
-/// Safe wrapper for `sysconf(_SC_PAGESIZE)`.
-#[cfg(target_arch = "x86_64")]
-#[inline(always)]
-fn pagesize() -> usize {
-    // Trivially safe
-    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
-}
-
-/// Type for passing information about the initramfs in the guest memory.
-pub struct InitramfsConfig {
-    /// Load address of initramfs in guest memory
-    pub address: vm_memory::GuestAddress,
-    /// Size of initramfs in guest memory
-    pub size: usize,
-}
-
-/// Types of devices that can get attached to this platform.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Copy)]
-pub enum DeviceType {
-    /// Device Type: Virtio.
-    Virtio(u32),
-    /// Device Type: Serial.
-    #[cfg(target_arch = "aarch64")]
-    Serial,
-    /// Device Type: RTC.
-    #[cfg(target_arch = "aarch64")]
-    Rtc,
-    /// Device Type: GPIO.
-    #[cfg(target_arch = "aarch64")]
-    Gpio,
-}
-
-/// Default (smallest) memory page size for the supported architectures.
-pub const PAGE_SIZE: usize = 4096;
-
-impl fmt::Display for DeviceType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-/// Structure to describe MMIO device information
-#[derive(Clone, Debug)]
-#[cfg(target_arch = "aarch64")]
-pub struct MmioDeviceInfo {
-    pub addr: u64,
-    pub irq: u32,
-}
-
-#[cfg(target_arch = "aarch64")]
-impl DeviceInfoForFdt for MmioDeviceInfo {
-    fn addr(&self) -> u64 {
-        self.addr
-    }
-    fn irq(&self) -> u32 {
-        self.irq
-    }
-    fn length(&self) -> u64 {
-        4096
-    }
-}

arch/src/x86_64/gdt.rs

@@ -1,5 +1,3 @@
-// Copyright © 2020, Oracle and/or its affiliates.
-//
 // Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 //
@@ -8,51 +6,26 @@
 // found in the LICENSE-BSD-3-Clause file.
 
 // For GDT details see arch/x86/include/asm/segment.h
-use crate::x86_64::SegmentRegister;
+
+use kvm_bindings::kvm_segment;
 
 /// Constructor for a conventional segment GDT (or LDT) entry. Derived from the kernel's segment.h.
 pub fn gdt_entry(flags: u16, base: u32, limit: u32) -> u64 {
-    (((base as u64) & 0xff000000u64) << (56 - 24))
+    ((((base as u64) & 0xff000000u64) << (56 - 24))
         | (((flags as u64) & 0x0000f0ffu64) << 40)
         | (((limit as u64) & 0x000f0000u64) << (48 - 16))
         | (((base as u64) & 0x00ffffffu64) << 16)
-        | ((limit as u64) & 0x0000ffffu64)
+        | ((limit as u64) & 0x0000ffffu64))
 }
 
 fn get_base(entry: u64) -> u64 {
-    (((entry) & 0xFF00000000000000) >> 32)
+    ((((entry) & 0xFF00000000000000) >> 32)
         | (((entry) & 0x000000FF00000000) >> 16)
-        | (((entry) & 0x00000000FFFF0000) >> 16)
+        | (((entry) & 0x00000000FFFF0000) >> 16))
 }
 
-// Extract the segment limit from the GDT segment descriptor.
-//
-// In a segment descriptor, the limit field is 20 bits, so it can directly describe
-// a range from 0 to 0xFFFFF (1MByte). When G flag is set (4-KByte page granularity) it
-// scales the value in the limit field by a factor of 2^12 (4Kbytes), making the effective
-// limit range from 0xFFF (4 KBytes) to 0xFFFF_FFFF (4 GBytes).
-//
-// However, the limit field in the VMCS definition is a 32 bit field, and the limit value is not
-// automatically scaled using the G flag. This means that for a desired range of 4GB for a
-// given segment, its limit must be specified as 0xFFFF_FFFF. Therefore the method of obtaining
-// the limit from the GDT entry is not sufficient, since it only provides 20 bits when 32 bits
-// are necessary. Fortunately, we can check if the G flag is set when extracting the limit since
-// the full GDT entry is passed as an argument, and perform the scaling of the limit value to
-// return the full 32 bit value.
-//
-// The scaling mentioned above is required when using PVH boot, since the guest boots in protected
-// (32-bit) mode and must be able to access the entire 32-bit address space. It does not cause issues
-// for the case of direct boot to 64-bit (long) mode, since in 64-bit mode the processor does not
-// perform runtime limit checking on code or data segments.
 fn get_limit(entry: u64) -> u32 {
-    let limit: u32 =
-        ((((entry) & 0x000F000000000000) >> 32) | ((entry) & 0x000000000000FFFF)) as u32;
-
-    // Perform manual limit scaling if G flag is set
-    match get_g(entry) {
-        0 => limit,
-        _ => ((limit << 12) | 0xFFF), // G flag is either 0 or 1
-    }
+    ((((entry) & 0x000F000000000000) >> 32) | ((entry) & 0x000000000000FFFF)) as u32
 }
 
 fn get_g(entry: u64) -> u8 {
@@ -87,14 +60,14 @@ fn get_type(entry: u64) -> u8 {
     ((entry & 0x00000F0000000000) >> 40) as u8
 }
 
-/// Automatically build the struct for SET_SREGS from the kernel bit fields.
+/// Automatically build the kvm struct for SET_SREGS from the kernel bit fields.
 ///
 /// # Arguments
 ///
 /// * `entry` - The gdt entry.
 /// * `table_index` - Index of the entry in the gdt table.
-pub fn segment_from_gdt(entry: u64, table_index: u8) -> SegmentRegister {
-    SegmentRegister {
+pub fn kvm_segment_from_gdt(entry: u64, table_index: u8) -> kvm_segment {
+    kvm_segment {
         base: get_base(entry),
         limit: get_limit(entry),
         selector: (table_index * 8) as u16,
@@ -121,7 +94,7 @@ mod tests {
     #[test]
     fn field_parse() {
         let gdt = gdt_entry(0xA09B, 0x100000, 0xfffff);
-        let seg = segment_from_gdt(gdt, 0);
+        let seg = kvm_segment_from_gdt(gdt, 0);
         // 0xA09B
         // 'A'
         assert_eq!(0x1, seg.g);
@@ -136,7 +109,7 @@ mod tests {
         assert_eq!(0xB, seg.type_);
         // base and limit
         assert_eq!(0x100000, seg.base);
-        assert_eq!(0xffffffff, seg.limit);
+        assert_eq!(0xfffff, seg.limit);
         assert_eq!(0x0, seg.unusable);
     }
 }

arch/src/x86_64/interrupts.rs

@@ -5,28 +5,30 @@
 // 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;
+
+use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+
+use kvm_bindings::kvm_lapic_state;
+use kvm_ioctls;
 
 #[derive(Debug)]
 pub enum Error {
-    GetLapic(anyhow::Error),
-    SetLapic(anyhow::Error),
+    GetLapic(kvm_ioctls::Error),
+    SetLapic(kvm_ioctls::Error),
 }
 
-pub type Result<T> = result::Result<T, hypervisor::HypervisorCpuError>;
+pub type Result<T> = result::Result<T, Error>;
 
 // Defines poached from apicdef.h kernel header.
-pub const APIC_LVT0: usize = 0x350;
-pub const APIC_LVT1: usize = 0x360;
-pub const APIC_MODE_NMI: u32 = 0x4;
-pub const APIC_MODE_EXTINT: u32 = 0x7;
+const APIC_LVT0: usize = 0x350;
+const APIC_LVT1: usize = 0x360;
+const APIC_MODE_NMI: u32 = 0x4;
+const APIC_MODE_EXTINT: u32 = 0x7;
 
-pub fn get_klapic_reg(klapic: &LapicState, reg_offset: usize) -> u32 {
+fn get_klapic_reg(klapic: &kvm_lapic_state, 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).
@@ -39,7 +41,7 @@ pub fn get_klapic_reg(klapic: &LapicState, reg_offset: usize) -> u32 {
         .expect("Failed to read klapic register")
 }
 
-pub fn set_klapic_reg(klapic: &mut LapicState, reg_offset: usize, value: u32) {
+fn set_klapic_reg(klapic: &mut kvm_lapic_state, 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).
@@ -52,16 +54,16 @@ pub fn set_klapic_reg(klapic: &mut LapicState, reg_offset: usize, value: u32) {
         .expect("Failed to write klapic register")
 }
 
-pub fn set_apic_delivery_mode(reg: u32, mode: u32) -> u32 {
-    ((reg) & !0x700) | ((mode) << 8)
+fn set_apic_delivery_mode(reg: u32, mode: u32) -> u32 {
+    (((reg) & !0x700) | ((mode) << 8))
 }
 
 /// Configures LAPICs.  LAPIC0 is set for external interrupts, LAPIC1 is set for NMI.
 ///
 /// # Arguments
 /// * `vcpu` - The VCPU object to configure.
-pub fn set_lint(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
-    let mut klapic = vcpu.get_lapic()?;
+pub fn set_lint(vcpu: &kvm_ioctls::VcpuFd) -> Result<()> {
+    let mut klapic = vcpu.get_lapic().map_err(Error::GetLapic)?;
 
     let lvt_lint0 = get_klapic_reg(&klapic, APIC_LVT0);
     set_klapic_reg(
@@ -76,19 +78,24 @@ pub fn set_lint(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
         set_apic_delivery_mode(lvt_lint1, APIC_MODE_NMI),
     );
 
-    vcpu.set_lapic(&klapic)
+    vcpu.set_lapic(&klapic).map_err(Error::SetLapic)
 }
 
 #[cfg(test)]
 mod tests {
+    extern crate kvm_ioctls;
+    extern crate rand;
+    use self::rand::Rng;
+
     use super::*;
+    use kvm_ioctls::Kvm;
 
     const KVM_APIC_REG_SIZE: usize = 0x400;
 
     #[test]
     fn test_set_and_get_klapic_reg() {
         let reg_offset = 0x340;
-        let mut klapic = LapicState::default();
+        let mut klapic = kvm_lapic_state::default();
         set_klapic_reg(&mut klapic, reg_offset, 3);
         let value = get_klapic_reg(&klapic, reg_offset);
         assert_eq!(value, 3);
@@ -98,25 +105,54 @@ mod tests {
     #[should_panic]
     fn test_set_and_get_klapic_out_of_bounds() {
         let reg_offset = KVM_APIC_REG_SIZE + 10;
-        let mut klapic = LapicState::default();
+        let mut klapic = kvm_lapic_state::default();
         set_klapic_reg(&mut klapic, reg_offset, 3);
     }
 
     #[test]
     fn test_apic_delivery_mode() {
-        let mut v: Vec<u32> = Vec::new();
-        v.resize(20, 0);
-
-        unsafe {
-            assert_eq!(
-                libc::getrandom(v.as_mut_ptr() as *mut _ as *mut libc::c_void, 80, 0),
-                80
-            );
-        }
+        let mut rng = rand::thread_rng();
+        let mut v: Vec<u32> = (0..20).map(|_| rng.gen::<u32>()).collect();
 
         v.iter_mut()
             .for_each(|x| *x = set_apic_delivery_mode(*x, 2));
         let after: Vec<u32> = v.iter().map(|x| ((*x & !0x700) | ((2) << 8))).collect();
         assert_eq!(v, after);
     }
+
+    #[test]
+    fn test_setlint() {
+        let kvm = kvm_ioctls::Kvm::new().unwrap();
+        assert!(kvm.check_extension(kvm_ioctls::Cap::Irqchip));
+        let vm = kvm.create_vm().unwrap();
+        //the get_lapic ioctl will fail if there is no irqchip created beforehand.
+        assert!(vm.create_irq_chip().is_ok());
+        let vcpu = vm.create_vcpu(0).unwrap();
+        let klapic_before: kvm_lapic_state = vcpu.get_lapic().unwrap();
+
+        // Compute the value that is expected to represent LVT0 and LVT1.
+        let lint0 = get_klapic_reg(&klapic_before, APIC_LVT0);
+        let lint1 = get_klapic_reg(&klapic_before, APIC_LVT1);
+        let lint0_mode_expected = set_apic_delivery_mode(lint0, APIC_MODE_EXTINT);
+        let lint1_mode_expected = set_apic_delivery_mode(lint1, APIC_MODE_NMI);
+
+        set_lint(&vcpu).unwrap();
+
+        // Compute the value that represents LVT0 and LVT1 after set_lint.
+        let klapic_actual: kvm_lapic_state = vcpu.get_lapic().unwrap();
+        let lint0_mode_actual = get_klapic_reg(&klapic_actual, APIC_LVT0);
+        let lint1_mode_actual = get_klapic_reg(&klapic_actual, APIC_LVT1);
+        assert_eq!(lint0_mode_expected, lint0_mode_actual);
+        assert_eq!(lint1_mode_expected, lint1_mode_actual);
+    }
+
+    #[test]
+    fn test_setlint_fails() {
+        let kvm = Kvm::new().unwrap();
+        let vm = kvm.create_vm().unwrap();
+        let vcpu = vm.create_vcpu(0).unwrap();
+        // 'get_lapic' ioctl triggered by the 'set_lint' function will fail if there is no
+        // irqchip created beforehand.
+        assert!(set_lint(&vcpu).is_err());
+    }
 }

arch/src/x86_64/layout.rs

@@ -1,5 +1,3 @@
-// Copyright © 2020, Oracle and/or its affiliates.
-//
 // Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 //
@@ -7,7 +5,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
-use vm_memory::GuestAddress;
+use vm_memory::{GuestAddress, GuestUsize};
 
 /*
 
@@ -28,17 +26,6 @@ pub const LOW_RAM_START: GuestAddress = GuestAddress(0x0);
 pub const BOOT_GDT_START: GuestAddress = GuestAddress(0x500);
 pub const BOOT_IDT_START: GuestAddress = GuestAddress(0x520);
 
-/// Address for the hvm_start_info struct used in PVH boot
-pub const PVH_INFO_START: GuestAddress = GuestAddress(0x6000);
-
-/// Starting address of array of modules of hvm_modlist_entry type.
-/// Used to enable initrd support using the PVH boot ABI.
-pub const MODLIST_START: GuestAddress = GuestAddress(0x6040);
-
-/// Address of memory map table used in PVH boot. Can overlap
-/// with the zero page address since they are mutually exclusive.
-pub const MEMMAP_START: GuestAddress = GuestAddress(0x7000);
-
 /// The 'zero page', a.k.a linux kernel bootparams.
 pub const ZERO_PAGE_START: GuestAddress = GuestAddress(0x7000);
 
@@ -47,10 +34,9 @@ pub const BOOT_STACK_START: GuestAddress = GuestAddress(0x8000);
 pub const BOOT_STACK_POINTER: GuestAddress = GuestAddress(0x8ff0);
 
 // Initial pagetables.
-pub const PML5_START: GuestAddress = GuestAddress(0x9000);
-pub const PML4_START: GuestAddress = GuestAddress(0xa000);
-pub const PDPTE_START: GuestAddress = GuestAddress(0xb000);
-pub const PDE_START: GuestAddress = GuestAddress(0xc000);
+pub const PML4_START: GuestAddress = GuestAddress(0x9000);
+pub const PDPTE_START: GuestAddress = GuestAddress(0xa000);
+pub const PDE_START: GuestAddress = GuestAddress(0xb000);
 
 /// Kernel command line start address.
 pub const CMDLINE_START: GuestAddress = GuestAddress(0x20000);
@@ -70,8 +56,6 @@ pub const EBDA_START: GuestAddress = GuestAddress(0xa0000);
 // ACPI RSDP table
 pub const RSDP_POINTER: GuestAddress = EBDA_START;
 
-pub const SMBIOS_START: u64 = 0xf0000; // First possible location per the spec.
-
 // == End of "EBDA" range ==
 
 // ** High RAM (start: 1MiB, length: 3071MiB) **
@@ -81,22 +65,22 @@ pub const HIGH_RAM_START: GuestAddress = GuestAddress(0x100000);
 
 // ** 32-bit reserved area (start: 3GiB, length: 1GiB) **
 pub const MEM_32BIT_RESERVED_START: GuestAddress = GuestAddress(0xc000_0000);
-pub const MEM_32BIT_RESERVED_SIZE: u64 = 1024 << 20;
+pub const MEM_32BIT_RESERVED_SIZE: GuestUsize = (1024 << 20);
 
 // == Fixed constants within the "32-bit reserved" range ==
 
 // Sub range: 32-bit PCI devices (start: 3GiB, length: 640Mib)
 pub const MEM_32BIT_DEVICES_START: GuestAddress = MEM_32BIT_RESERVED_START;
-pub const MEM_32BIT_DEVICES_SIZE: u64 = 640 << 20;
+pub const MEM_32BIT_DEVICES_SIZE: GuestUsize = (640 << 20);
 
 // PCI MMCONFIG space (start: after the device space, length: 256MiB)
 pub const PCI_MMCONFIG_START: GuestAddress =
     GuestAddress(MEM_32BIT_DEVICES_START.0 + MEM_32BIT_DEVICES_SIZE);
-pub const PCI_MMCONFIG_SIZE: u64 = 256 << 20;
+pub const PCI_MMCONFIG_SIZE: GuestUsize = (256 << 20);
 
 // IOAPIC
 pub const IOAPIC_START: GuestAddress = GuestAddress(0xfec0_0000);
-pub const IOAPIC_SIZE: u64 = 0x20;
+pub const IOAPIC_SIZE: GuestUsize = 0x20;
 
 // APIC
 pub const APIC_START: GuestAddress = GuestAddress(0xfee0_0000);

arch/src/x86_64/mod.rs

@@ -1,132 +1,26 @@
-// Copyright © 2020, Oracle and/or its affiliates.
-//
 // Copyright 2018 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 LICENSE-BSD-3-Clause file.
-use std::sync::Arc;
+
+mod gdt;
 pub mod interrupts;
 pub mod layout;
 mod mptable;
 pub mod regs;
-use crate::InitramfsConfig;
+
 use crate::RegionType;
-use hypervisor::{CpuId, CpuIdEntry, CPUID_FLAG_VALID_INDEX};
 use linux_loader::loader::bootparam::{boot_params, setup_header};
-use linux_loader::loader::elf::start_info::{
-    hvm_memmap_table_entry, hvm_modlist_entry, hvm_start_info,
-};
 use std::mem;
 use vm_memory::{
-    Address, ByteValued, Bytes, GuestAddress, GuestAddressSpace, GuestMemory, GuestMemoryAtomic,
-    GuestMemoryMmap, GuestMemoryRegion, GuestUsize,
+    Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryMmap, GuestUsize,
 };
-mod smbios;
-use std::arch::x86_64;
-#[cfg(feature = "tdx")]
-pub mod tdx;
-
-#[derive(Debug, Copy, Clone)]
-pub enum BootProtocol {
-    LinuxBoot,
-    PvhBoot,
-}
-
-impl ::std::fmt::Display for BootProtocol {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        match self {
-            BootProtocol::LinuxBoot => write!(f, "Linux 64-bit boot protocol"),
-            BootProtocol::PvhBoot => write!(f, "PVH boot protocol"),
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-/// Specifies the entry point address where the guest must start
-/// executing code, as well as which of the supported boot protocols
-/// is to be used to configure the guest initial state.
-pub struct EntryPoint {
-    /// Address in guest memory where the guest must start execution
-    pub entry_addr: GuestAddress,
-    /// Specifies which boot protocol to use
-    pub protocol: BootProtocol,
-    /// This field is used for bzImage to fill zero page
-    pub setup_header: Option<setup_header>,
-}
 
 const E820_RAM: u32 = 1;
 const E820_RESERVED: u32 = 2;
 
-#[derive(Clone)]
-pub struct SgxEpcSection {
-    start: GuestAddress,
-    size: GuestUsize,
-}
-
-impl SgxEpcSection {
-    pub fn new(start: GuestAddress, size: GuestUsize) -> Self {
-        SgxEpcSection { start, size }
-    }
-    pub fn start(&self) -> GuestAddress {
-        self.start
-    }
-    pub fn size(&self) -> GuestUsize {
-        self.size
-    }
-}
-
-#[derive(Clone)]
-pub struct SgxEpcRegion {
-    start: GuestAddress,
-    size: GuestUsize,
-    epc_sections: Vec<SgxEpcSection>,
-}
-
-impl SgxEpcRegion {
-    pub fn new(start: GuestAddress, size: GuestUsize) -> Self {
-        SgxEpcRegion {
-            start,
-            size,
-            epc_sections: Vec::new(),
-        }
-    }
-    pub fn start(&self) -> GuestAddress {
-        self.start
-    }
-    pub fn size(&self) -> GuestUsize {
-        self.size
-    }
-    pub fn epc_sections(&self) -> &Vec<SgxEpcSection> {
-        &self.epc_sections
-    }
-    pub fn push(&mut self, epc_section: SgxEpcSection) {
-        self.epc_sections.push(epc_section);
-    }
-}
-
-// This is a workaround to the Rust enforcement specifying that any implementation of a foreign
-// trait (in this case `DataInit`) where:
-// *    the type that is implementing the trait is foreign or
-// *    all of the parameters being passed to the trait (if there are any) are also foreign
-// is prohibited.
-#[derive(Copy, Clone, Default)]
-struct StartInfoWrapper(hvm_start_info);
-
-// It is safe to initialize StartInfoWrapper which is a wrapper over `hvm_start_info` (a series of ints).
-unsafe impl ByteValued for StartInfoWrapper {}
-
-#[derive(Copy, Clone, Default)]
-struct MemmapTableEntryWrapper(hvm_memmap_table_entry);
-
-unsafe impl ByteValued for MemmapTableEntryWrapper {}
-
-#[derive(Copy, Clone, Default)]
-struct ModlistEntryWrapper(hvm_modlist_entry);
-
-unsafe impl ByteValued for ModlistEntryWrapper {}
-
 // This is a workaround to the Rust enforcement specifying that any implementation of a foreign
 // trait (in this case `DataInit`) where:
 // *    the type that is implementing the trait is foreign or
@@ -142,39 +36,8 @@ unsafe impl ByteValued for BootParamsWrapper {}
 pub enum Error {
     /// Invalid e820 setup params.
     E820Configuration,
-
     /// Error writing MP table to memory.
     MpTableSetup(mptable::Error),
-
-    /// Error configuring the general purpose registers
-    RegsConfiguration(regs::Error),
-
-    /// Error configuring the special registers
-    SregsConfiguration(regs::Error),
-
-    /// Error configuring the floating point related registers
-    FpuConfiguration(regs::Error),
-
-    /// Error configuring the MSR registers
-    MsrsConfiguration(regs::Error),
-
-    /// Failed to set supported CPUs.
-    SetSupportedCpusFailed(anyhow::Error),
-
-    /// Cannot set the local interruption due to bad configuration.
-    LocalIntConfiguration(anyhow::Error),
-
-    /// Error setting up SMBIOS table
-    SmbiosSetup(smbios::Error),
-
-    /// Could not find any SGX EPC section
-    NoSgxEpcSection,
-
-    /// Missing SGX CPU feature
-    MissingSgxFeature,
-
-    /// Missing SGX_LC CPU feature
-    MissingSgxLaunchControlFeature,
 }
 
 impl From<Error> for super::Error {
@@ -183,190 +46,6 @@ impl From<Error> for super::Error {
     }
 }
 
-#[allow(dead_code, clippy::upper_case_acronyms)]
-#[derive(Copy, Clone)]
-pub enum CpuidReg {
-    EAX,
-    EBX,
-    ECX,
-    EDX,
-}
-
-pub struct CpuidPatch {
-    pub function: u32,
-    pub index: u32,
-    pub flags_bit: Option<u8>,
-    pub eax_bit: Option<u8>,
-    pub ebx_bit: Option<u8>,
-    pub ecx_bit: Option<u8>,
-    pub edx_bit: Option<u8>,
-}
-
-impl CpuidPatch {
-    pub fn set_cpuid_reg(
-        cpuid: &mut CpuId,
-        function: u32,
-        index: Option<u32>,
-        reg: CpuidReg,
-        value: u32,
-    ) {
-        let entries = cpuid.as_mut_slice();
-
-        let mut entry_found = false;
-        for entry in entries.iter_mut() {
-            if entry.function == function && (index == None || index.unwrap() == entry.index) {
-                entry_found = true;
-                match reg {
-                    CpuidReg::EAX => {
-                        entry.eax = value;
-                    }
-                    CpuidReg::EBX => {
-                        entry.ebx = value;
-                    }
-                    CpuidReg::ECX => {
-                        entry.ecx = value;
-                    }
-                    CpuidReg::EDX => {
-                        entry.edx = value;
-                    }
-                }
-            }
-        }
-
-        if entry_found {
-            return;
-        }
-
-        // Entry not found, so let's add it.
-        if let Some(index) = index {
-            let mut entry = CpuIdEntry {
-                function,
-                index,
-                flags: CPUID_FLAG_VALID_INDEX,
-                ..Default::default()
-            };
-            match reg {
-                CpuidReg::EAX => {
-                    entry.eax = value;
-                }
-                CpuidReg::EBX => {
-                    entry.ebx = value;
-                }
-                CpuidReg::ECX => {
-                    entry.ecx = value;
-                }
-                CpuidReg::EDX => {
-                    entry.edx = value;
-                }
-            }
-
-            if let Err(e) = cpuid.push(entry) {
-                error!("Failed adding new CPUID entry: {:?}", e);
-            }
-        }
-    }
-
-    pub fn patch_cpuid(cpuid: &mut CpuId, patches: Vec<CpuidPatch>) {
-        let entries = cpuid.as_mut_slice();
-
-        for entry in entries.iter_mut() {
-            for patch in patches.iter() {
-                if entry.function == patch.function && entry.index == patch.index {
-                    if let Some(flags_bit) = patch.flags_bit {
-                        entry.flags |= 1 << flags_bit;
-                    }
-                    if let Some(eax_bit) = patch.eax_bit {
-                        entry.eax |= 1 << eax_bit;
-                    }
-                    if let Some(ebx_bit) = patch.ebx_bit {
-                        entry.ebx |= 1 << ebx_bit;
-                    }
-                    if let Some(ecx_bit) = patch.ecx_bit {
-                        entry.ecx |= 1 << ecx_bit;
-                    }
-                    if let Some(edx_bit) = patch.edx_bit {
-                        entry.edx |= 1 << edx_bit;
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn is_feature_enabled(
-        cpuid: &CpuId,
-        function: u32,
-        index: u32,
-        reg: CpuidReg,
-        feature_bit: usize,
-    ) -> bool {
-        let entries = cpuid.as_slice();
-        let mask = 1 << feature_bit;
-
-        for entry in entries.iter() {
-            if entry.function == function && entry.index == index {
-                let reg_val: u32;
-                match reg {
-                    CpuidReg::EAX => {
-                        reg_val = entry.eax;
-                    }
-                    CpuidReg::EBX => {
-                        reg_val = entry.ebx;
-                    }
-                    CpuidReg::ECX => {
-                        reg_val = entry.ecx;
-                    }
-                    CpuidReg::EDX => {
-                        reg_val = entry.edx;
-                    }
-                }
-
-                return (reg_val & mask) == mask;
-            }
-        }
-
-        false
-    }
-}
-
-pub fn configure_vcpu(
-    fd: &Arc<dyn hypervisor::Vcpu>,
-    id: u8,
-    kernel_entry_point: Option<EntryPoint>,
-    vm_memory: &GuestMemoryAtomic<GuestMemoryMmap>,
-    cpuid: CpuId,
-    kvm_hyperv: bool,
-) -> super::Result<()> {
-    // Per vCPU CPUID changes; common are handled via CpuManager::generate_common_cpuid()
-    let mut cpuid = cpuid;
-    CpuidPatch::set_cpuid_reg(&mut cpuid, 0xb, None, CpuidReg::EDX, u32::from(id));
-    CpuidPatch::set_cpuid_reg(&mut cpuid, 0x1f, None, CpuidReg::EDX, u32::from(id));
-
-    fd.set_cpuid2(&cpuid)
-        .map_err(|e| Error::SetSupportedCpusFailed(e.into()))?;
-
-    if kvm_hyperv {
-        fd.enable_hyperv_synic().unwrap();
-    }
-
-    regs::setup_msrs(fd).map_err(Error::MsrsConfiguration)?;
-    if let Some(kernel_entry_point) = kernel_entry_point {
-        // Safe to unwrap because this method is called after the VM is configured
-        regs::setup_regs(
-            fd,
-            kernel_entry_point.entry_addr.raw_value(),
-            layout::BOOT_STACK_POINTER.raw_value(),
-            layout::ZERO_PAGE_START.raw_value(),
-            kernel_entry_point.protocol,
-        )
-        .map_err(Error::RegsConfiguration)?;
-        regs::setup_fpu(fd).map_err(Error::FpuConfiguration)?;
-        regs::setup_sregs(&vm_memory.memory(), fd, kernel_entry_point.protocol)
-            .map_err(Error::SregsConfiguration)?;
-    }
-    interrupts::set_lint(fd).map_err(|e| Error::LocalIntConfiguration(e.into()))?;
-    Ok(())
-}
-
 /// Returns a Vec of the valid memory addresses.
 /// These should be used to configure the GuestMemory structure for the platform.
 /// For x86_64 all addresses are valid from the start of the kernel except a
@@ -427,231 +106,33 @@ pub fn configure_system(
     guest_mem: &GuestMemoryMmap,
     cmdline_addr: GuestAddress,
     cmdline_size: usize,
-    initramfs: &Option<InitramfsConfig>,
-    _num_cpus: u8,
+    num_cpus: u8,
     setup_hdr: Option<setup_header>,
     rsdp_addr: Option<GuestAddress>,
-    boot_prot: BootProtocol,
-    sgx_epc_region: Option<SgxEpcRegion>,
-) -> super::Result<()> {
-    let size = smbios::setup_smbios(guest_mem).map_err(Error::SmbiosSetup)?;
-
-    // Place the MP table after the SMIOS table aligned to 16 bytes
-    let offset = GuestAddress(layout::SMBIOS_START).unchecked_add(size);
-    let offset = GuestAddress((offset.0 + 16) & !0xf);
-    mptable::setup_mptable(offset, guest_mem, _num_cpus).map_err(Error::MpTableSetup)?;
-
-    // Check that the RAM is not smaller than the RSDP start address
-    if let Some(rsdp_addr) = rsdp_addr {
-        if rsdp_addr.0 > guest_mem.last_addr().0 {
-            return Err(super::Error::RsdpPastRamEnd);
-        }
-    }
-
-    match boot_prot {
-        BootProtocol::PvhBoot => {
-            configure_pvh(
-                guest_mem,
-                cmdline_addr,
-                initramfs,
-                rsdp_addr,
-                sgx_epc_region,
-            )?;
-        }
-        BootProtocol::LinuxBoot => {
-            error!("Using deprecated LinuxBoot protocol: Please configure your kernel with CONFIG_PVH=y and supply the `vmlinux` file to `--kernel`");
-            configure_64bit_boot(
-                guest_mem,
-                cmdline_addr,
-                cmdline_size,
-                initramfs,
-                setup_hdr,
-                rsdp_addr,
-                sgx_epc_region,
-            )?;
-        }
-    }
-
-    Ok(())
-}
-
-fn configure_pvh(
-    guest_mem: &GuestMemoryMmap,
-    cmdline_addr: GuestAddress,
-    initramfs: &Option<InitramfsConfig>,
-    rsdp_addr: Option<GuestAddress>,
-    sgx_epc_region: Option<SgxEpcRegion>,
-) -> super::Result<()> {
-    const XEN_HVM_START_MAGIC_VALUE: u32 = 0x336ec578;
-
-    let mut start_info: StartInfoWrapper = StartInfoWrapper(hvm_start_info::default());
-
-    start_info.0.magic = XEN_HVM_START_MAGIC_VALUE;
-    start_info.0.version = 1; // pvh has version 1
-    start_info.0.nr_modules = 0;
-    start_info.0.cmdline_paddr = cmdline_addr.raw_value() as u64;
-    start_info.0.memmap_paddr = layout::MEMMAP_START.raw_value();
-
-    if let Some(rsdp_addr) = rsdp_addr {
-        start_info.0.rsdp_paddr = rsdp_addr.0;
-    }
-
-    if let Some(initramfs_config) = initramfs {
-        // The initramfs has been written to guest memory already, here we just need to
-        // create the module structure that describes it.
-        let ramdisk_mod: ModlistEntryWrapper = ModlistEntryWrapper(hvm_modlist_entry {
-            paddr: initramfs_config.address.raw_value(),
-            size: initramfs_config.size as u64,
-            ..Default::default()
-        });
-
-        start_info.0.nr_modules += 1;
-        start_info.0.modlist_paddr = layout::MODLIST_START.raw_value();
-
-        // Write the modlist struct to guest memory.
-        guest_mem
-            .write_obj(ramdisk_mod, layout::MODLIST_START)
-            .map_err(super::Error::ModlistSetup)?;
-    }
-
-    // Vector to hold the memory maps which needs to be written to guest memory
-    // at MEMMAP_START after all of the mappings are recorded.
-    let mut memmap: Vec<hvm_memmap_table_entry> = Vec::new();
-
-    // Create the memory map entries.
-    add_memmap_entry(&mut memmap, 0, layout::EBDA_START.raw_value(), E820_RAM);
-
-    let mem_end = guest_mem.last_addr();
-
-    if mem_end < layout::MEM_32BIT_RESERVED_START {
-        add_memmap_entry(
-            &mut memmap,
-            layout::HIGH_RAM_START.raw_value(),
-            mem_end.unchecked_offset_from(layout::HIGH_RAM_START) + 1,
-            E820_RAM,
-        );
-    } else {
-        add_memmap_entry(
-            &mut memmap,
-            layout::HIGH_RAM_START.raw_value(),
-            layout::MEM_32BIT_RESERVED_START.unchecked_offset_from(layout::HIGH_RAM_START),
-            E820_RAM,
-        );
-        if mem_end > layout::RAM_64BIT_START {
-            add_memmap_entry(
-                &mut memmap,
-                layout::RAM_64BIT_START.raw_value(),
-                mem_end.unchecked_offset_from(layout::RAM_64BIT_START) + 1,
-                E820_RAM,
-            );
-        }
-    }
-
-    add_memmap_entry(
-        &mut memmap,
-        layout::PCI_MMCONFIG_START.0,
-        layout::PCI_MMCONFIG_SIZE,
-        E820_RESERVED,
-    );
-
-    if let Some(sgx_epc_region) = sgx_epc_region {
-        add_memmap_entry(
-            &mut memmap,
-            sgx_epc_region.start().raw_value(),
-            sgx_epc_region.size() as u64,
-            E820_RESERVED,
-        );
-    }
-
-    start_info.0.memmap_entries = memmap.len() as u32;
-
-    // Copy the vector with the memmap table to the MEMMAP_START address
-    // which is already saved in the memmap_paddr field of hvm_start_info struct.
-    let mut memmap_start_addr = layout::MEMMAP_START;
-
-    guest_mem
-        .checked_offset(
-            memmap_start_addr,
-            mem::size_of::<hvm_memmap_table_entry>() * start_info.0.memmap_entries as usize,
-        )
-        .ok_or(super::Error::MemmapTablePastRamEnd)?;
-
-    // For every entry in the memmap vector, create a MemmapTableEntryWrapper
-    // and write it to guest memory.
-    for memmap_entry in memmap {
-        let map_entry_wrapper: MemmapTableEntryWrapper = MemmapTableEntryWrapper(memmap_entry);
-
-        guest_mem
-            .write_obj(map_entry_wrapper, memmap_start_addr)
-            .map_err(|_| super::Error::MemmapTableSetup)?;
-        memmap_start_addr =
-            memmap_start_addr.unchecked_add(mem::size_of::<hvm_memmap_table_entry>() as u64);
-    }
-
-    // The hvm_start_info struct itself must be stored at PVH_START_INFO
-    // address, and %rbx will be initialized to contain PVH_INFO_START prior to
-    // starting the guest, as required by the PVH ABI.
-    let start_info_addr = layout::PVH_INFO_START;
-
-    guest_mem
-        .checked_offset(start_info_addr, mem::size_of::<hvm_start_info>())
-        .ok_or(super::Error::StartInfoPastRamEnd)?;
-
-    // Write the start_info struct to guest memory.
-    guest_mem
-        .write_obj(start_info, start_info_addr)
-        .map_err(|_| super::Error::StartInfoSetup)?;
-
-    Ok(())
-}
-
-fn add_memmap_entry(memmap: &mut Vec<hvm_memmap_table_entry>, addr: u64, size: u64, mem_type: u32) {
-    // Add the table entry to the vector
-    memmap.push(hvm_memmap_table_entry {
-        addr,
-        size,
-        type_: mem_type,
-        reserved: 0,
-    });
-}
-
-fn configure_64bit_boot(
-    guest_mem: &GuestMemoryMmap,
-    cmdline_addr: GuestAddress,
-    cmdline_size: usize,
-    initramfs: &Option<InitramfsConfig>,
-    setup_hdr: Option<setup_header>,
-    rsdp_addr: Option<GuestAddress>,
-    sgx_epc_region: Option<SgxEpcRegion>,
 ) -> super::Result<()> {
     const KERNEL_BOOT_FLAG_MAGIC: u16 = 0xaa55;
     const KERNEL_HDR_MAGIC: u32 = 0x53726448;
     const KERNEL_LOADER_OTHER: u8 = 0xff;
     const KERNEL_MIN_ALIGNMENT_BYTES: u32 = 0x1000000; // Must be non-zero.
 
+    // Note that this puts the mptable at the last 1k of Linux's 640k base RAM
+    mptable::setup_mptable(guest_mem, num_cpus).map_err(Error::MpTableSetup)?;
+
     let mut params: BootParamsWrapper = BootParamsWrapper(boot_params::default());
 
     if let Some(hdr) = setup_hdr {
-        // We should use the header if the loader provides one (e.g. from a bzImage).
         params.0.hdr = hdr;
+        params.0.hdr.cmd_line_ptr = cmdline_addr.raw_value() as u32;
+        params.0.hdr.cmdline_size = cmdline_size as u32;
     } else {
+        params.0.hdr.type_of_loader = KERNEL_LOADER_OTHER;
         params.0.hdr.boot_flag = KERNEL_BOOT_FLAG_MAGIC;
         params.0.hdr.header = KERNEL_HDR_MAGIC;
+        params.0.hdr.cmd_line_ptr = cmdline_addr.raw_value() as u32;
+        params.0.hdr.cmdline_size = cmdline_size as u32;
         params.0.hdr.kernel_alignment = KERNEL_MIN_ALIGNMENT_BYTES;
     };
 
-    // Common bootparams settings
-    if params.0.hdr.type_of_loader == 0 {
-        params.0.hdr.type_of_loader = KERNEL_LOADER_OTHER;
-    }
-    params.0.hdr.cmd_line_ptr = cmdline_addr.raw_value() as u32;
-    params.0.hdr.cmdline_size = cmdline_size as u32;
-
-    if let Some(initramfs_config) = initramfs {
-        params.0.hdr.ramdisk_image = initramfs_config.address.raw_value() as u32;
-        params.0.hdr.ramdisk_size = initramfs_config.size as u32;
-    }
-
     add_e820_entry(&mut params.0, 0, layout::EBDA_START.raw_value(), E820_RAM)?;
 
     let mem_end = guest_mem.last_addr();
@@ -686,15 +167,6 @@ fn configure_64bit_boot(
         E820_RESERVED,
     )?;
 
-    if let Some(sgx_epc_region) = sgx_epc_region {
-        add_e820_entry(
-            &mut params.0,
-            sgx_epc_region.start().raw_value(),
-            sgx_epc_region.size() as u64,
-            E820_RESERVED,
-        )?;
-    }
-
     if let Some(rsdp_addr) = rsdp_addr {
         params.0.acpi_rsdp_addr = rsdp_addr.0;
     }
@@ -730,161 +202,6 @@ fn add_e820_entry(
     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 first_region = guest_mem
-        .find_region(GuestAddress::new(0))
-        .ok_or(super::Error::InitramfsAddress)?;
-    // It's safe to cast to usize because the size of a region can't be greater than usize.
-    let lowmem_size = first_region.len() as usize;
-
-    if lowmem_size < initramfs_size {
-        return Err(super::Error::InitramfsAddress);
-    }
-
-    let aligned_addr: u64 = ((lowmem_size - initramfs_size) & !(crate::pagesize() - 1)) as u64;
-    Ok(aligned_addr)
-}
-
-pub fn get_host_cpu_phys_bits() -> u8 {
-    unsafe {
-        let leaf = x86_64::__cpuid(0x8000_0000);
-
-        // Detect and handle AMD SME (Secure Memory Encryption) properly.
-        // Some physical address bits may become reserved when the feature is enabled.
-        // See AMD64 Architecture Programmer's Manual Volume 2, Section 7.10.1
-        let reduced = if leaf.eax >= 0x8000_001f
-            && leaf.ebx == 0x6874_7541    // Vendor ID: AuthenticAMD
-            && leaf.ecx == 0x444d_4163
-            && leaf.edx == 0x6974_6e65
-            && x86_64::__cpuid(0x8000_001f).eax & 0x1 != 0
-        {
-            (x86_64::__cpuid(0x8000_001f).ebx >> 6) & 0x3f
-        } else {
-            0
-        };
-
-        if leaf.eax >= 0x8000_0008 {
-            let leaf = x86_64::__cpuid(0x8000_0008);
-            ((leaf.eax & 0xff) - reduced) as u8
-        } else {
-            36
-        }
-    }
-}
-
-pub fn update_cpuid_topology(
-    cpuid: &mut CpuId,
-    threads_per_core: u8,
-    cores_per_die: u8,
-    dies_per_package: u8,
-) {
-    let thread_width = 8 - (threads_per_core - 1).leading_zeros();
-    let core_width = (8 - (cores_per_die - 1).leading_zeros()) + thread_width;
-    let die_width = (8 - (dies_per_package - 1).leading_zeros()) + core_width;
-
-    // CPU Topology leaf 0xb
-    CpuidPatch::set_cpuid_reg(cpuid, 0xb, Some(0), CpuidReg::EAX, thread_width);
-    CpuidPatch::set_cpuid_reg(
-        cpuid,
-        0xb,
-        Some(0),
-        CpuidReg::EBX,
-        u32::from(threads_per_core),
-    );
-    CpuidPatch::set_cpuid_reg(cpuid, 0xb, Some(0), CpuidReg::ECX, 1 << 8);
-
-    CpuidPatch::set_cpuid_reg(cpuid, 0xb, Some(1), CpuidReg::EAX, die_width);
-    CpuidPatch::set_cpuid_reg(
-        cpuid,
-        0xb,
-        Some(1),
-        CpuidReg::EBX,
-        u32::from(dies_per_package * cores_per_die * threads_per_core),
-    );
-    CpuidPatch::set_cpuid_reg(cpuid, 0xb, Some(1), CpuidReg::ECX, 2 << 8);
-
-    // CPU Topology leaf 0x1f
-    CpuidPatch::set_cpuid_reg(cpuid, 0x1f, Some(0), CpuidReg::EAX, thread_width);
-    CpuidPatch::set_cpuid_reg(
-        cpuid,
-        0x1f,
-        Some(0),
-        CpuidReg::EBX,
-        u32::from(threads_per_core),
-    );
-    CpuidPatch::set_cpuid_reg(cpuid, 0x1f, Some(0), CpuidReg::ECX, 1 << 8);
-
-    CpuidPatch::set_cpuid_reg(cpuid, 0x1f, Some(1), CpuidReg::EAX, core_width);
-    CpuidPatch::set_cpuid_reg(
-        cpuid,
-        0x1f,
-        Some(1),
-        CpuidReg::EBX,
-        u32::from(cores_per_die * threads_per_core),
-    );
-    CpuidPatch::set_cpuid_reg(cpuid, 0x1f, Some(1), CpuidReg::ECX, 2 << 8);
-
-    CpuidPatch::set_cpuid_reg(cpuid, 0x1f, Some(2), CpuidReg::EAX, die_width);
-    CpuidPatch::set_cpuid_reg(
-        cpuid,
-        0x1f,
-        Some(2),
-        CpuidReg::EBX,
-        u32::from(dies_per_package * cores_per_die * threads_per_core),
-    );
-    CpuidPatch::set_cpuid_reg(cpuid, 0x1f, Some(2), CpuidReg::ECX, 5 << 8);
-}
-
-// The goal is to update the CPUID sub-leaves to reflect the number of EPC
-// sections exposed to the guest.
-pub fn update_cpuid_sgx(cpuid: &mut CpuId, epc_sections: Vec<SgxEpcSection>) -> Result<(), Error> {
-    // Something's wrong if there's no EPC section.
-    if epc_sections.is_empty() {
-        return Err(Error::NoSgxEpcSection);
-    }
-    // We can't go further if the hypervisor does not support SGX feature.
-    if !CpuidPatch::is_feature_enabled(cpuid, 0x7, 0, CpuidReg::EBX, 2) {
-        return Err(Error::MissingSgxFeature);
-    }
-    // We can't go further if the hypervisor does not support SGX_LC feature.
-    if !CpuidPatch::is_feature_enabled(cpuid, 0x7, 0, CpuidReg::ECX, 30) {
-        return Err(Error::MissingSgxLaunchControlFeature);
-    }
-
-    // Get host CPUID for leaf 0x12, subleaf 0x2. This is to retrieve EPC
-    // properties such as confidentiality and integrity.
-    let leaf = unsafe { std::arch::x86_64::__cpuid_count(0x12, 0x2) };
-
-    for (i, epc_section) in epc_sections.iter().enumerate() {
-        let subleaf_idx = i + 2;
-        let start = epc_section.start().raw_value();
-        let size = epc_section.size() as u64;
-        let eax = (start & 0xffff_f000) as u32 | 0x1;
-        let ebx = (start >> 32) as u32;
-        let ecx = (size & 0xffff_f000) as u32 | (leaf.ecx & 0xf);
-        let edx = (size >> 32) as u32;
-        // CPU Topology leaf 0x12
-        CpuidPatch::set_cpuid_reg(cpuid, 0x12, Some(subleaf_idx as u32), CpuidReg::EAX, eax);
-        CpuidPatch::set_cpuid_reg(cpuid, 0x12, Some(subleaf_idx as u32), CpuidReg::EBX, ebx);
-        CpuidPatch::set_cpuid_reg(cpuid, 0x12, Some(subleaf_idx as u32), CpuidReg::ECX, ecx);
-        CpuidPatch::set_cpuid_reg(cpuid, 0x12, Some(subleaf_idx as u32), CpuidReg::EDX, edx);
-    }
-
-    // Add one NULL entry to terminate the dynamic list
-    let subleaf_idx = epc_sections.len() + 2;
-    // CPU Topology leaf 0x12
-    CpuidPatch::set_cpuid_reg(cpuid, 0x12, Some(subleaf_idx as u32), CpuidReg::EAX, 0);
-    CpuidPatch::set_cpuid_reg(cpuid, 0x12, Some(subleaf_idx as u32), CpuidReg::EBX, 0);
-    CpuidPatch::set_cpuid_reg(cpuid, 0x12, Some(subleaf_idx as u32), CpuidReg::ECX, 0);
-    CpuidPatch::set_cpuid_reg(cpuid, 0x12, Some(subleaf_idx as u32), CpuidReg::EDX, 0);
-
-    Ok(())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -892,7 +209,7 @@ mod tests {
 
     #[test]
     fn regions_lt_4gb() {
-        let regions = arch_memory_regions(1 << 29);
+        let regions = arch_memory_regions(1 << 29 as GuestUsize);
         assert_eq!(3, regions.len());
         assert_eq!(GuestAddress(0), regions[0].0);
         assert_eq!(1usize << 29, regions[0].1);
@@ -900,7 +217,7 @@ mod tests {
 
     #[test]
     fn regions_gt_4gb() {
-        let regions = arch_memory_regions((1 << 32) + 0x8000);
+        let regions = arch_memory_regions((1 << 32 as GuestUsize) + 0x8000);
         assert_eq!(4, regions.len());
         assert_eq!(GuestAddress(0), regions[0].0);
         assert_eq!(GuestAddress(1 << 32), regions[1].0);
@@ -909,18 +226,8 @@ mod tests {
     #[test]
     fn test_system_configuration() {
         let no_vcpus = 4;
-        let gm = GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
-        let config_err = configure_system(
-            &gm,
-            GuestAddress(0),
-            0,
-            &None,
-            1,
-            None,
-            Some(layout::RSDP_POINTER),
-            BootProtocol::LinuxBoot,
-            None,
-        );
+        let gm = GuestMemoryMmap::from_ranges(&vec![(GuestAddress(0), 0x10000)]).unwrap();
+        let config_err = configure_system(&gm, GuestAddress(0), 0, 1, None, None);
         assert!(config_err.is_err());
 
         // Now assigning some memory that falls before the 32bit memory hole.
@@ -932,31 +239,7 @@ mod tests {
             .map(|r| (r.0, r.1))
             .collect();
         let gm = GuestMemoryMmap::from_ranges(&ram_regions).unwrap();
-        configure_system(
-            &gm,
-            GuestAddress(0),
-            0,
-            &None,
-            no_vcpus,
-            None,
-            None,
-            BootProtocol::LinuxBoot,
-            None,
-        )
-        .unwrap();
-
-        configure_system(
-            &gm,
-            GuestAddress(0),
-            0,
-            &None,
-            no_vcpus,
-            None,
-            None,
-            BootProtocol::PvhBoot,
-            None,
-        )
-        .unwrap();
+        configure_system(&gm, GuestAddress(0), 0, no_vcpus, None, None).unwrap();
 
         // Now assigning some memory that is equal to the start of the 32bit memory hole.
         let mem_size = 3328 << 20;
@@ -967,31 +250,7 @@ mod tests {
             .map(|r| (r.0, r.1))
             .collect();
         let gm = GuestMemoryMmap::from_ranges(&ram_regions).unwrap();
-        configure_system(
-            &gm,
-            GuestAddress(0),
-            0,
-            &None,
-            no_vcpus,
-            None,
-            None,
-            BootProtocol::LinuxBoot,
-            None,
-        )
-        .unwrap();
-
-        configure_system(
-            &gm,
-            GuestAddress(0),
-            0,
-            &None,
-            no_vcpus,
-            None,
-            None,
-            BootProtocol::PvhBoot,
-            None,
-        )
-        .unwrap();
+        configure_system(&gm, GuestAddress(0), 0, no_vcpus, None, None).unwrap();
 
         // Now assigning some memory that falls after the 32bit memory hole.
         let mem_size = 3330 << 20;
@@ -1002,31 +261,7 @@ mod tests {
             .map(|r| (r.0, r.1))
             .collect();
         let gm = GuestMemoryMmap::from_ranges(&ram_regions).unwrap();
-        configure_system(
-            &gm,
-            GuestAddress(0),
-            0,
-            &None,
-            no_vcpus,
-            None,
-            None,
-            BootProtocol::LinuxBoot,
-            None,
-        )
-        .unwrap();
-
-        configure_system(
-            &gm,
-            GuestAddress(0),
-            0,
-            &None,
-            no_vcpus,
-            None,
-            None,
-            BootProtocol::PvhBoot,
-            None,
-        )
-        .unwrap();
+        configure_system(&gm, GuestAddress(0), 0, no_vcpus, None, None).unwrap();
     }
 
     #[test]
@@ -1068,29 +303,4 @@ mod tests {
         )
         .is_err());
     }
-
-    #[test]
-    fn test_add_memmap_entry() {
-        let mut memmap: Vec<hvm_memmap_table_entry> = Vec::new();
-
-        let expected_memmap = vec![
-            hvm_memmap_table_entry {
-                addr: 0x0,
-                size: 0x1000,
-                type_: E820_RAM,
-                ..Default::default()
-            },
-            hvm_memmap_table_entry {
-                addr: 0x10000,
-                size: 0xa000,
-                type_: E820_RESERVED,
-                ..Default::default()
-            },
-        ];
-
-        add_memmap_entry(&mut memmap, 0, 0x1000, E820_RAM);
-        add_memmap_entry(&mut memmap, 0x10000, 0xa000, E820_RESERVED);
-
-        assert_eq!(format!("{:?}", memmap), format!("{:?}", expected_memmap));
-    }
 }

arch/src/x86_64/mptable.rs

@@ -13,10 +13,8 @@ use std::slice;
 use libc::c_char;
 
 use arch_gen::x86::mpspec;
-use layout::{APIC_START, HIGH_RAM_START, IOAPIC_START};
-use vm_memory::{
-    Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryError, GuestMemoryMmap,
-};
+use layout::{APIC_START, IOAPIC_START, MPTABLE_START};
+use vm_memory::{Address, ByteValued, Bytes, GuestMemory, GuestMemoryError, GuestMemoryMmap};
 
 // This is a workaround to the Rust enforcement specifying that any implementation of a foreign
 // trait (in this case `ByteValued`) where:
@@ -123,21 +121,16 @@ 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<()> {
+pub fn setup_mptable(mem: &GuestMemoryMmap, num_cpus: u8) -> Result<()> {
     if num_cpus as u32 > MAX_SUPPORTED_CPUS {
         return Err(Error::TooManyCpus);
     }
 
     // Used to keep track of the next base pointer into the MP table.
-    let mut base_mp = offset;
+    let mut base_mp = MPTABLE_START;
 
     let mp_size = compute_mp_size(num_cpus);
 
-    if offset.unchecked_add(mp_size as u64) >= HIGH_RAM_START {
-        warn!("Skipping mptable creation due to insufficient space");
-        return Ok(());
-    }
-
     let mut checksum: u8 = 0;
     let ioapicid: u8 = num_cpus + 1;
 
@@ -287,7 +280,6 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
 #[cfg(test)]
 mod tests {
     use super::*;
-    use layout::MPTABLE_START;
     use vm_memory::{GuestAddress, GuestUsize};
 
     fn table_entry_size(type_: u8) -> usize {
@@ -307,7 +299,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(&mem, num_cpus).unwrap();
     }
 
     #[test]
@@ -316,7 +308,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());
+        assert!(setup_mptable(&mem, num_cpus).is_err());
     }
 
     #[test]
@@ -325,7 +317,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(&mem, num_cpus).unwrap();
 
         let mpf_intel: MpfIntelWrapper = mem.read_obj(MPTABLE_START).unwrap();
 
@@ -341,7 +333,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(&mem, num_cpus).unwrap();
 
         let mpf_intel: MpfIntelWrapper = mem.read_obj(MPTABLE_START).unwrap();
         let mpc_offset = GuestAddress(mpf_intel.0.physptr as GuestUsize);
@@ -375,7 +367,7 @@ mod tests {
         .unwrap();
 
         for i in 0..MAX_SUPPORTED_CPUS as u8 {
-            setup_mptable(MPTABLE_START, &mem, i).unwrap();
+            setup_mptable(&mem, i).unwrap();
 
             let mpf_intel: MpfIntelWrapper = mem.read_obj(MPTABLE_START).unwrap();
             let mpc_offset = GuestAddress(mpf_intel.0.physptr as GuestUsize);
@@ -408,7 +400,7 @@ mod tests {
         let mem =
             GuestMemoryMmap::from_ranges(&[(MPTABLE_START, compute_mp_size(cpus as u8))]).unwrap();
 
-        let result = setup_mptable(MPTABLE_START, &mem, cpus as u8);
+        let result = setup_mptable(&mem, cpus as u8);
         assert!(result.is_err());
     }
 }

arch/src/x86_64/regs.rs

@@ -1,49 +1,47 @@
-// Copyright © 2020, Oracle and/or its affiliates.
-//
 // Copyright 2018 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 LICENSE-BSD-3-Clause file.
-use std::sync::Arc;
+
 use std::{mem, result};
 
-use super::BootProtocol;
-use hypervisor::arch::x86::gdt::{gdt_entry, segment_from_gdt};
-use hypervisor::arch::x86::regs::*;
-use hypervisor::x86_64::{FpuState, SpecialRegisters, StandardRegisters};
-use layout::{
-    BOOT_GDT_START, BOOT_IDT_START, PDE_START, PDPTE_START, PML4_START, PML5_START, PVH_INFO_START,
-};
+use super::gdt::{gdt_entry, kvm_segment_from_gdt};
+use arch_gen::x86::msr_index;
+use kvm_bindings::{kvm_fpu, kvm_msr_entry, kvm_regs, kvm_sregs, Msrs};
+use kvm_ioctls::VcpuFd;
+use layout::{BOOT_GDT_START, BOOT_IDT_START, PDE_START, PDPTE_START, PML4_START};
 use vm_memory::{Address, Bytes, GuestMemory, GuestMemoryError, GuestMemoryMmap};
 
+// MTRR constants
+const MTRR_ENABLE: u64 = 0x800; // IA32_MTRR_DEF_TYPE MSR: E (MTRRs enabled) flag, bit 11
+const MTRR_MEM_TYPE_WB: u64 = 0x6;
+
 #[derive(Debug)]
 pub enum Error {
     /// Failed to get SREGs for this CPU.
-    GetStatusRegisters(hypervisor::HypervisorCpuError),
+    GetStatusRegisters(kvm_ioctls::Error),
     /// Failed to set base registers for this CPU.
-    SetBaseRegisters(hypervisor::HypervisorCpuError),
+    SetBaseRegisters(kvm_ioctls::Error),
     /// Failed to configure the FPU.
-    SetFpuRegisters(hypervisor::HypervisorCpuError),
+    SetFPURegisters(kvm_ioctls::Error),
     /// Setting up MSRs failed.
-    SetModelSpecificRegisters(hypervisor::HypervisorCpuError),
+    SetModelSpecificRegisters(kvm_ioctls::Error),
     /// Failed to set SREGs for this CPU.
-    SetStatusRegisters(hypervisor::HypervisorCpuError),
+    SetStatusRegisters(kvm_ioctls::Error),
     /// Checking the GDT address failed.
-    CheckGdtAddr,
+    CheckGDTAddr,
     /// Writing the GDT to RAM failed.
-    WriteGdt(GuestMemoryError),
+    WriteGDT(GuestMemoryError),
     /// Writing the IDT to RAM failed.
-    WriteIdt(GuestMemoryError),
+    WriteIDT(GuestMemoryError),
     /// Writing PDPTE to RAM failed.
-    WritePdpteAddress(GuestMemoryError),
+    WritePDPTEAddress(GuestMemoryError),
     /// Writing PDE to RAM failed.
-    WritePdeAddress(GuestMemoryError),
+    WritePDEAddress(GuestMemoryError),
     /// Writing PML4 to RAM failed.
-    WritePml4Address(GuestMemoryError),
-    /// Writing PML5 to RAM failed.
-    WritePml5Address(GuestMemoryError),
+    WritePML4Address(GuestMemoryError),
 }
 
 pub type Result<T> = result::Result<T, Error>;
@@ -53,14 +51,14 @@ pub type Result<T> = result::Result<T, Error>;
 /// # Arguments
 ///
 /// * `vcpu` - Structure for the VCPU that holds the VCPU's fd.
-pub fn setup_fpu(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
-    let fpu: FpuState = FpuState {
+pub fn setup_fpu(vcpu: &VcpuFd) -> Result<()> {
+    let fpu: kvm_fpu = kvm_fpu {
         fcw: 0x37f,
         mxcsr: 0x1f80,
         ..Default::default()
     };
 
-    vcpu.set_fpu(&fpu).map_err(Error::SetFpuRegisters)
+    vcpu.set_fpu(&fpu).map_err(Error::SetFPURegisters)
 }
 
 /// Configure Model Specific Registers (MSRs) for a given CPU.
@@ -68,8 +66,8 @@ pub fn setup_fpu(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
 /// # Arguments
 ///
 /// * `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())
+pub fn setup_msrs(vcpu: &VcpuFd) -> Result<()> {
+    vcpu.set_msrs(&create_msr_entries())
         .map_err(Error::SetModelSpecificRegisters)?;
 
     Ok(())
@@ -83,31 +81,16 @@ pub fn setup_msrs(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
 /// * `boot_ip` - Starting instruction pointer.
 /// * `boot_sp` - Starting stack pointer.
 /// * `boot_si` - Must point to zero page address per Linux ABI.
-pub fn setup_regs(
-    vcpu: &Arc<dyn hypervisor::Vcpu>,
-    boot_ip: u64,
-    boot_sp: u64,
-    boot_si: u64,
-    boot_prot: BootProtocol,
-) -> Result<()> {
-    let regs: StandardRegisters = match boot_prot {
-        // Configure regs as required by PVH boot protocol.
-        BootProtocol::PvhBoot => StandardRegisters {
-            rflags: 0x0000000000000002u64,
-            rbx: PVH_INFO_START.raw_value(),
-            rip: boot_ip,
-            ..Default::default()
-        },
-        // Configure regs as required by Linux 64-bit boot protocol.
-        BootProtocol::LinuxBoot => StandardRegisters {
-            rflags: 0x0000000000000002u64,
-            rip: boot_ip,
-            rsp: boot_sp,
-            rbp: boot_sp,
-            rsi: boot_si,
-            ..Default::default()
-        },
+pub fn setup_regs(vcpu: &VcpuFd, boot_ip: u64, boot_sp: u64, boot_si: u64) -> Result<()> {
+    let regs: kvm_regs = kvm_regs {
+        rflags: 0x0000000000000002u64,
+        rip: boot_ip,
+        rsp: boot_sp,
+        rbp: boot_sp,
+        rsi: boot_si,
+        ..Default::default()
     };
+
     vcpu.set_regs(&regs).map_err(Error::SetBaseRegisters)
 }
 
@@ -117,31 +100,31 @@ pub fn setup_regs(
 ///
 /// * `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>,
-    boot_prot: BootProtocol,
-) -> Result<()> {
-    let mut sregs: SpecialRegisters = vcpu.get_sregs().map_err(Error::GetStatusRegisters)?;
+pub fn setup_sregs(mem: &GuestMemoryMmap, vcpu: &VcpuFd) -> Result<()> {
+    let mut sregs: kvm_sregs = vcpu.get_sregs().map_err(Error::GetStatusRegisters)?;
 
-    configure_segments_and_sregs(mem, &mut sregs, boot_prot)?;
-
-    if let BootProtocol::LinuxBoot = boot_prot {
-        setup_page_tables(mem, &mut sregs)?; // TODO(dgreid) - Can this be done once per system instead?
-    }
+    configure_segments_and_sregs(mem, &mut sregs)?;
+    setup_page_tables(mem, &mut sregs)?; // TODO(dgreid) - Can this be done once per system instead?
 
     vcpu.set_sregs(&sregs).map_err(Error::SetStatusRegisters)
 }
 
 const BOOT_GDT_MAX: usize = 4;
 
+const EFER_LMA: u64 = 0x400;
+const EFER_LME: u64 = 0x100;
+
+const X86_CR0_PE: u64 = 0x1;
+const X86_CR0_PG: u64 = 0x80000000;
+const X86_CR4_PAE: u64 = 0x20;
+
 fn write_gdt_table(table: &[u64], guest_mem: &GuestMemoryMmap) -> Result<()> {
     let boot_gdt_addr = BOOT_GDT_START;
     for (index, entry) in table.iter().enumerate() {
         let addr = guest_mem
             .checked_offset(boot_gdt_addr, index * mem::size_of::<u64>())
-            .ok_or(Error::CheckGdtAddr)?;
-        guest_mem.write_obj(*entry, addr).map_err(Error::WriteGdt)?;
+            .ok_or(Error::CheckGDTAddr)?;
+        guest_mem.write_obj(*entry, addr).map_err(Error::WriteGDT)?;
     }
     Ok(())
 }
@@ -150,38 +133,20 @@ fn write_idt_value(val: u64, guest_mem: &GuestMemoryMmap) -> Result<()> {
     let boot_idt_addr = BOOT_IDT_START;
     guest_mem
         .write_obj(val, boot_idt_addr)
-        .map_err(Error::WriteIdt)
+        .map_err(Error::WriteIDT)
 }
 
-pub fn configure_segments_and_sregs(
-    mem: &GuestMemoryMmap,
-    sregs: &mut SpecialRegisters,
-    boot_prot: BootProtocol,
-) -> Result<()> {
-    let gdt_table: [u64; BOOT_GDT_MAX as usize] = match boot_prot {
-        BootProtocol::PvhBoot => {
-            // Configure GDT entries as specified by PVH boot protocol
-            [
-                gdt_entry(0, 0, 0),               // NULL
-                gdt_entry(0xc09b, 0, 0xffffffff), // CODE
-                gdt_entry(0xc093, 0, 0xffffffff), // DATA
-                gdt_entry(0x008b, 0, 0x67),       // TSS
-            ]
-        }
-        BootProtocol::LinuxBoot => {
-            // Configure GDT entries as specified by Linux 64bit boot protocol
-            [
-                gdt_entry(0, 0, 0),            // NULL
-                gdt_entry(0xa09b, 0, 0xfffff), // CODE
-                gdt_entry(0xc093, 0, 0xfffff), // DATA
-                gdt_entry(0x808b, 0, 0xfffff), // TSS
-            ]
-        }
-    };
+fn configure_segments_and_sregs(mem: &GuestMemoryMmap, sregs: &mut kvm_sregs) -> Result<()> {
+    let gdt_table: [u64; BOOT_GDT_MAX as usize] = [
+        gdt_entry(0, 0, 0),            // NULL
+        gdt_entry(0xa09b, 0, 0xfffff), // CODE
+        gdt_entry(0xc093, 0, 0xfffff), // DATA
+        gdt_entry(0x808b, 0, 0xfffff), // TSS
+    ];
 
-    let code_seg = segment_from_gdt(gdt_table[1], 1);
-    let data_seg = segment_from_gdt(gdt_table[2], 2);
-    let tss_seg = segment_from_gdt(gdt_table[3], 3);
+    let code_seg = kvm_segment_from_gdt(gdt_table[1], 1);
+    let data_seg = kvm_segment_from_gdt(gdt_table[2], 2);
+    let tss_seg = kvm_segment_from_gdt(gdt_table[3], 3);
 
     // Write segments
     write_gdt_table(&gdt_table[..], mem)?;
@@ -200,64 +165,111 @@ pub fn configure_segments_and_sregs(
     sregs.ss = data_seg;
     sregs.tr = tss_seg;
 
-    match boot_prot {
-        BootProtocol::PvhBoot => {
-            sregs.cr0 = CR0_PE;
-            sregs.cr4 = 0;
-        }
-        BootProtocol::LinuxBoot => {
-            /* 64-bit protected mode */
-            sregs.cr0 |= CR0_PE;
-            sregs.efer |= EFER_LME | EFER_LMA;
-        }
-    }
+    /* 64-bit protected mode */
+    sregs.cr0 |= X86_CR0_PE;
+    sregs.efer |= EFER_LME | EFER_LMA;
 
     Ok(())
 }
 
-pub fn setup_page_tables(mem: &GuestMemoryMmap, sregs: &mut SpecialRegisters) -> Result<()> {
-    // Puts PML5 or PML4 right after zero page but aligned to 4k.
-    if unsafe { std::arch::x86_64::__cpuid(7).ecx } & (1 << 16) != 0 {
-        // Entry covering VA [0..256TB)
-        mem.write_obj(PML4_START.raw_value() | 0x03, PML5_START)
-            .map_err(Error::WritePml5Address)?;
-
-        sregs.cr3 = PML5_START.raw_value();
-        sregs.cr4 |= CR4_LA57;
-    } else {
-        sregs.cr3 = PML4_START.raw_value();
-    }
+fn setup_page_tables(mem: &GuestMemoryMmap, sregs: &mut kvm_sregs) -> Result<()> {
+    // Puts PML4 right after zero page but aligned to 4k.
 
     // Entry covering VA [0..512GB)
     mem.write_obj(PDPTE_START.raw_value() | 0x03, PML4_START)
-        .map_err(Error::WritePml4Address)?;
+        .map_err(Error::WritePML4Address)?;
 
     // Entry covering VA [0..1GB)
     mem.write_obj(PDE_START.raw_value() | 0x03, PDPTE_START)
-        .map_err(Error::WritePdpteAddress)?;
-
+        .map_err(Error::WritePDPTEAddress)?;
     // 512 2MB entries together covering VA [0..1GB). Note we are assuming
     // CPU supports 2MB pages (/proc/cpuinfo has 'pse'). All modern CPUs do.
     for i in 0..512 {
         mem.write_obj((i << 21) + 0x83u64, PDE_START.unchecked_add(i * 8))
-            .map_err(Error::WritePdeAddress)?;
+            .map_err(Error::WritePDEAddress)?;
     }
 
-    sregs.cr4 |= CR4_PAE;
-    sregs.cr0 |= CR0_PG;
-
+    sregs.cr3 = PML4_START.raw_value();
+    sregs.cr4 |= X86_CR4_PAE;
+    sregs.cr0 |= X86_CR0_PG;
     Ok(())
 }
 
+fn create_msr_entries() -> Msrs {
+    let mut entries = Vec::<kvm_msr_entry>::new();
+
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_IA32_SYSENTER_CS,
+        data: 0x0,
+        ..Default::default()
+    });
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_IA32_SYSENTER_ESP,
+        data: 0x0,
+        ..Default::default()
+    });
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_IA32_SYSENTER_EIP,
+        data: 0x0,
+        ..Default::default()
+    });
+    // x86_64 specific msrs, we only run on x86_64 not x86.
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_STAR,
+        data: 0x0,
+        ..Default::default()
+    });
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_CSTAR,
+        data: 0x0,
+        ..Default::default()
+    });
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_KERNEL_GS_BASE,
+        data: 0x0,
+        ..Default::default()
+    });
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_SYSCALL_MASK,
+        data: 0x0,
+        ..Default::default()
+    });
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_LSTAR,
+        data: 0x0,
+        ..Default::default()
+    });
+    // end of x86_64 specific code
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_IA32_TSC,
+        data: 0x0,
+        ..Default::default()
+    });
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_IA32_MISC_ENABLE,
+        data: msr_index::MSR_IA32_MISC_ENABLE_FAST_STRING as u64,
+        ..Default::default()
+    });
+    entries.push(kvm_msr_entry {
+        index: msr_index::MSR_MTRRdefType,
+        data: MTRR_ENABLE | MTRR_MEM_TYPE_WB,
+        ..Default::default()
+    });
+
+    Msrs::from_entries(&entries)
+}
+
 #[cfg(test)]
 mod tests {
+    extern crate kvm_ioctls;
     extern crate vm_memory;
 
     use super::*;
+    use kvm_ioctls::Kvm;
     use vm_memory::{GuestAddress, GuestMemoryMmap};
 
     fn create_guest_mem() -> GuestMemoryMmap {
-        GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap()
+        GuestMemoryMmap::from_ranges(&vec![(GuestAddress(0), 0x10000)]).unwrap()
     }
 
     fn read_u64(gm: &GuestMemoryMmap, offset: GuestAddress) -> u64 {
@@ -266,9 +278,9 @@ mod tests {
 
     #[test]
     fn segments_and_sregs() {
-        let mut sregs: SpecialRegisters = Default::default();
+        let mut sregs: kvm_sregs = Default::default();
         let gm = create_guest_mem();
-        configure_segments_and_sregs(&gm, &mut sregs, BootProtocol::LinuxBoot).unwrap();
+        configure_segments_and_sregs(&gm, &mut sregs).unwrap();
 
         assert_eq!(0x0, read_u64(&gm, BOOT_GDT_START));
         assert_eq!(
@@ -286,59 +298,26 @@ mod tests {
         assert_eq!(0x0, read_u64(&gm, BOOT_IDT_START));
 
         assert_eq!(0, sregs.cs.base);
-        assert_eq!(0xffffffff, sregs.ds.limit);
+        assert_eq!(0xfffff, sregs.ds.limit);
         assert_eq!(0x10, sregs.es.selector);
         assert_eq!(1, sregs.fs.present);
         assert_eq!(1, sregs.gs.g);
         assert_eq!(0, sregs.ss.avl);
         assert_eq!(0, sregs.tr.base);
-        assert_eq!(0xffffffff, sregs.tr.limit);
+        assert_eq!(0xfffff, sregs.tr.limit);
         assert_eq!(0, sregs.tr.avl);
-        assert_eq!(CR0_PE, sregs.cr0);
+        assert_eq!(X86_CR0_PE, sregs.cr0);
         assert_eq!(EFER_LME | EFER_LMA, sregs.efer);
-
-        configure_segments_and_sregs(&gm, &mut sregs, BootProtocol::PvhBoot).unwrap();
-        assert_eq!(0x0, read_u64(&gm, BOOT_GDT_START));
-        assert_eq!(
-            0xcf9b000000ffff,
-            read_u64(&gm, BOOT_GDT_START.unchecked_add(8))
-        );
-        assert_eq!(
-            0xcf93000000ffff,
-            read_u64(&gm, BOOT_GDT_START.unchecked_add(16))
-        );
-        assert_eq!(
-            0x8b0000000067,
-            read_u64(&gm, BOOT_GDT_START.unchecked_add(24))
-        );
-        assert_eq!(0x0, read_u64(&gm, BOOT_IDT_START));
-
-        assert_eq!(0, sregs.cs.base);
-        assert_eq!(0xffffffff, sregs.ds.limit);
-        assert_eq!(0x10, sregs.es.selector);
-        assert_eq!(1, sregs.fs.present);
-        assert_eq!(1, sregs.gs.g);
-        assert_eq!(0, sregs.ss.avl);
-        assert_eq!(0, sregs.tr.base);
-        assert_eq!(0, sregs.tr.g);
-        assert_eq!(0x67, sregs.tr.limit);
-        assert_eq!(0xb, sregs.tr.type_);
-        assert_eq!(0, sregs.tr.avl);
-        assert_eq!(CR0_PE, sregs.cr0);
-        assert_eq!(0, sregs.cr4);
     }
 
     #[test]
     fn page_tables() {
-        let mut sregs: SpecialRegisters = Default::default();
+        let mut sregs: kvm_sregs = Default::default();
         let gm = create_guest_mem();
         setup_page_tables(&gm, &mut sregs).unwrap();
 
-        if unsafe { std::arch::x86_64::__cpuid(7).ecx } & (1 << 16) != 0 {
-            assert_eq!(0xa003, read_u64(&gm, PML5_START));
-        }
-        assert_eq!(0xb003, read_u64(&gm, PML4_START));
-        assert_eq!(0xc003, read_u64(&gm, PDPTE_START));
+        assert_eq!(0xa003, read_u64(&gm, PML4_START));
+        assert_eq!(0xb003, read_u64(&gm, PDPTE_START));
         for i in 0..512 {
             assert_eq!(
                 (i << 21) + 0x83u64,
@@ -346,12 +325,99 @@ mod tests {
             );
         }
 
-        if unsafe { std::arch::x86_64::__cpuid(7).ecx } & (1 << 16) != 0 {
-            assert_eq!(PML5_START.raw_value(), sregs.cr3);
-        } else {
-            assert_eq!(PML4_START.raw_value(), sregs.cr3);
-        }
-        assert_eq!(CR4_PAE, sregs.cr4);
-        assert_eq!(CR0_PG, sregs.cr0);
+        assert_eq!(PML4_START.raw_value(), sregs.cr3);
+        assert_eq!(X86_CR4_PAE, sregs.cr4);
+        assert_eq!(X86_CR0_PG, sregs.cr0);
+    }
+
+    #[test]
+    fn test_setup_fpu() {
+        let kvm = Kvm::new().unwrap();
+        let vm = kvm.create_vm().unwrap();
+        let vcpu = vm.create_vcpu(0).unwrap();
+        setup_fpu(&vcpu).unwrap();
+
+        let expected_fpu: kvm_fpu = kvm_fpu {
+            fcw: 0x37f,
+            mxcsr: 0x1f80,
+            ..Default::default()
+        };
+        let actual_fpu: kvm_fpu = vcpu.get_fpu().unwrap();
+        // TODO: auto-generate kvm related structures with PartialEq on.
+        assert_eq!(expected_fpu.fcw, actual_fpu.fcw);
+        // Setting the mxcsr register from kvm_fpu inside setup_fpu does not influence anything.
+        // See 'kvm_arch_vcpu_ioctl_set_fpu' from arch/x86/kvm/x86.c.
+        // The mxcsr will stay 0 and the assert below fails. Decide whether or not we should
+        // remove it at all.
+        // assert!(expected_fpu.mxcsr == actual_fpu.mxcsr);
+    }
+
+    #[test]
+    fn test_setup_msrs() {
+        let kvm = Kvm::new().unwrap();
+        let vm = kvm.create_vm().unwrap();
+        let vcpu = vm.create_vcpu(0).unwrap();
+        setup_msrs(&vcpu).unwrap();
+
+        // This test will check against the last MSR entry configured (the tenth one).
+        // See create_msr_entries for details.
+        let mut msrs = Msrs::from_entries(&[kvm_msr_entry {
+            index: msr_index::MSR_IA32_MISC_ENABLE,
+            ..Default::default()
+        }]);
+
+        // get_msrs returns the number of msrs that it succeed in reading. We only want to read 1
+        // in this test case scenario.
+        let read_msrs = vcpu.get_msrs(&mut msrs).unwrap();
+        assert_eq!(read_msrs, 1);
+
+        // Official entries that were setup when we did setup_msrs. We need to assert that the
+        // tenth one (i.e the one with index msr_index::MSR_IA32_MISC_ENABLE has the data we
+        // expect.
+        let entry_vec = create_msr_entries();
+        assert_eq!(entry_vec.as_slice()[9], msrs.as_slice()[0]);
+    }
+
+    #[test]
+    fn test_setup_regs() {
+        let kvm = Kvm::new().unwrap();
+        let vm = kvm.create_vm().unwrap();
+        let vcpu = vm.create_vcpu(0).unwrap();
+
+        let expected_regs: kvm_regs = kvm_regs {
+            rflags: 0x0000000000000002u64,
+            rip: 1,
+            rsp: 2,
+            rbp: 2,
+            rsi: 3,
+            ..Default::default()
+        };
+
+        setup_regs(
+            &vcpu,
+            expected_regs.rip,
+            expected_regs.rsp,
+            expected_regs.rsi,
+        )
+        .unwrap();
+
+        let actual_regs: kvm_regs = vcpu.get_regs().unwrap();
+        assert_eq!(actual_regs, expected_regs);
+    }
+
+    #[test]
+    fn test_setup_sregs() {
+        let kvm = Kvm::new().unwrap();
+        let vm = kvm.create_vm().unwrap();
+        let vcpu = vm.create_vcpu(0).unwrap();
+
+        let mut expected_sregs: kvm_sregs = vcpu.get_sregs().unwrap();
+        let gm = create_guest_mem();
+        configure_segments_and_sregs(&gm, &mut expected_sregs).unwrap();
+        setup_page_tables(&gm, &mut expected_sregs).unwrap();
+
+        setup_sregs(&gm, &vcpu).unwrap();
+        let actual_sregs: kvm_sregs = vcpu.get_sregs().unwrap();
+        assert_eq!(expected_sregs, actual_sregs);
     }
 }

arch/src/x86_64/smbios.rs

@@ -1,271 +0,0 @@
-// Copyright © 2020 Intel Corporation
-//
-// Copyright 2019 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use layout::SMBIOS_START;
-use std::fmt::{self, Display};
-use std::mem;
-use std::result;
-use std::slice;
-use vm_memory::ByteValued;
-use vm_memory::{Address, Bytes, GuestAddress, GuestMemoryMmap};
-
-#[allow(unused_variables)]
-#[derive(Debug)]
-pub enum Error {
-    /// There was too little guest memory to store the entire SMBIOS table.
-    NotEnoughMemory,
-    /// The SMBIOS table has too little address space to be stored.
-    AddressOverflow,
-    /// Failure while zeroing out the memory for the SMBIOS table.
-    Clear,
-    /// Failure to write SMBIOS entrypoint structure
-    WriteSmbiosEp,
-    /// 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)
-    }
-}
-
-pub type Result<T> = result::Result<T, Error>;
-
-// Constants sourced from SMBIOS Spec 3.2.0.
-const SM3_MAGIC_IDENT: &[u8; 5usize] = b"_SM3_";
-const BIOS_INFORMATION: u8 = 0;
-const SYSTEM_INFORMATION: u8 = 1;
-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`.
-    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() {
-        checksum = checksum.wrapping_add(*i);
-    }
-    (!checksum).wrapping_add(1)
-}
-
-#[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,
-}
-unsafe impl ByteValued for Smbios30Entrypoint {}
-
-impl Clone for Smbios30Entrypoint {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-#[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
-    }
-}
-
-unsafe impl ByteValued for SmbiosBiosInfo {}
-
-#[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,
-}
-
-impl Clone for SmbiosSysInfo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-unsafe impl ByteValued for SmbiosSysInfo {}
-
-fn write_and_incr<T: ByteValued>(
-    mem: &GuestMemoryMmap,
-    val: T,
-    mut curptr: GuestAddress,
-) -> Result<GuestAddress> {
-    mem.write_obj(val, curptr).map_err(|_| Error::WriteData)?;
-    curptr = curptr
-        .checked_add(mem::size_of::<T>() as u64)
-        .ok_or(Error::NotEnoughMemory)?;
-    Ok(curptr)
-}
-
-fn write_string(
-    mem: &GuestMemoryMmap,
-    val: &str,
-    mut curptr: GuestAddress,
-) -> Result<GuestAddress> {
-    for c in val.as_bytes().iter() {
-        curptr = write_and_incr(mem, *c, curptr)?;
-    }
-    curptr = write_and_incr(mem, 0u8, curptr)?;
-    Ok(curptr)
-}
-
-pub fn setup_smbios(mem: &GuestMemoryMmap) -> Result<u64> {
-    let physptr = GuestAddress(SMBIOS_START)
-        .checked_add(mem::size_of::<Smbios30Entrypoint>() as u64)
-        .ok_or(Error::NotEnoughMemory)?;
-    let mut curptr = physptr;
-    let mut handle = 0;
-
-    {
-        handle += 1;
-        let smbios_biosinfo = SmbiosBiosInfo {
-            typ: BIOS_INFORMATION,
-            length: mem::size_of::<SmbiosBiosInfo>() as u8,
-            handle,
-            vendor: 1,  // First string written in this section
-            version: 2, // Second string written in this section
-            characteristics: PCI_SUPPORTED,
-            characteristics_ext2: IS_VIRTUAL_MACHINE,
-            ..Default::default()
-        };
-        curptr = write_and_incr(mem, smbios_biosinfo, curptr)?;
-        curptr = write_string(mem, "cloud-hypervisor", curptr)?;
-        curptr = write_string(mem, "0", curptr)?;
-        curptr = write_and_incr(mem, 0u8, curptr)?;
-    }
-
-    {
-        handle += 1;
-        let smbios_sysinfo = SmbiosSysInfo {
-            typ: 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
-            ..Default::default()
-        };
-        curptr = write_and_incr(mem, smbios_sysinfo, curptr)?;
-        curptr = write_string(mem, "Cloud Hypervisor", curptr)?;
-        curptr = write_string(mem, "cloud-hypervisor", 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,
-            handle,
-            ..Default::default()
-        };
-        curptr = write_and_incr(mem, smbios_sysinfo, curptr)?;
-        curptr = write_and_incr(mem, 0u8, curptr)?;
-    }
-
-    {
-        let mut smbios_ep = Smbios30Entrypoint {
-            signature: *SM3_MAGIC_IDENT,
-            length: mem::size_of::<Smbios30Entrypoint>() as u8,
-            // SMBIOS rev 3.2.0
-            majorver: 0x03,
-            minorver: 0x02,
-            docrev: 0x00,
-            revision: 0x01, // SMBIOS 3.0
-            max_size: curptr.unchecked_offset_from(physptr) as u32,
-            physptr: physptr.0,
-            ..Default::default()
-        };
-        smbios_ep.checksum = compute_checksum(&smbios_ep);
-        mem.write_obj(smbios_ep, GuestAddress(SMBIOS_START))
-            .map_err(|_| Error::WriteSmbiosEp)?;
-    }
-
-    Ok(curptr.unchecked_offset_from(physptr))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn struct_size() {
-        assert_eq!(
-            mem::size_of::<Smbios30Entrypoint>(),
-            0x18usize,
-            concat!("Size of: ", stringify!(Smbios30Entrypoint))
-        );
-        assert_eq!(
-            mem::size_of::<SmbiosBiosInfo>(),
-            0x14usize,
-            concat!("Size of: ", stringify!(SmbiosBiosInfo))
-        );
-        assert_eq!(
-            mem::size_of::<SmbiosSysInfo>(),
-            0x1busize,
-            concat!("Size of: ", stringify!(SmbiosSysInfo))
-        );
-    }
-
-    #[test]
-    fn entrypoint_checksum() {
-        let mem = GuestMemoryMmap::from_ranges(&[(GuestAddress(SMBIOS_START), 4096)]).unwrap();
-
-        setup_smbios(&mem).unwrap();
-
-        let smbios_ep: Smbios30Entrypoint = mem.read_obj(GuestAddress(SMBIOS_START)).unwrap();
-
-        assert_eq!(compute_checksum(&smbios_ep), 0);
-    }
-}

arch/src/x86_64/tdx/mod.rs

@@ -1,318 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-use std::fs::File;
-use std::io::{Read, Seek, SeekFrom};
-use thiserror::Error;
-use vm_memory::{ByteValued, Bytes, GuestAddress, GuestMemoryError, GuestMemoryMmap};
-
-#[derive(Error, Debug)]
-pub enum TdvfError {
-    #[error("Failed read TDVF descriptor: {0}")]
-    ReadDescriptor(#[source] std::io::Error),
-    #[error("Failed read TDVF descriptor offset: {0}")]
-    ReadDescriptorOffset(#[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}")]
-    GuestMemoryWriteHob(#[source] GuestMemoryError),
-}
-
-// TDVF_DESCRIPTOR
-#[repr(packed)]
-pub struct TdvfDescriptor {
-    signature: [u8; 4],
-    length: u32,
-    version: u32,
-    num_sections: u32, // NumberOfSectionEntry
-}
-
-// TDVF_SECTION
-#[repr(packed)]
-#[derive(Clone, Copy, Default, Debug)]
-pub struct TdvfSection {
-    pub data_offset: u32,
-    pub data_size: u32, // RawDataSize
-    pub address: u64,   // MemoryAddress
-    pub size: u64,      // MemoryDataSize
-    pub r#type: TdvfSectionType,
-    pub attributes: u32,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy, Debug)]
-pub enum TdvfSectionType {
-    Bfv,
-    Cfv,
-    TdHob,
-    TempMem,
-    Reserved = 0xffffffff,
-}
-
-impl Default for TdvfSectionType {
-    fn default() -> Self {
-        TdvfSectionType::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
-    file.seek(SeekFrom::End(-0x20))
-        .map_err(TdvfError::ReadDescriptorOffset)?;
-
-    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))
-        .map_err(TdvfError::ReadDescriptor)?;
-
-    let mut descriptor: TdvfDescriptor = unsafe { std::mem::zeroed() };
-    // Safe as 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,
-            std::mem::size_of::<TdvfDescriptor>(),
-        )
-    })
-    .map_err(TdvfError::ReadDescriptor)?;
-
-    if &descriptor.signature != b"TDVF" {
-        return Err(TdvfError::InvalidDescriptorSignature);
-    }
-
-    if descriptor.length as usize
-        != std::mem::size_of::<TdvfDescriptor>()
-            + std::mem::size_of::<TdvfSection>() * descriptor.num_sections as usize
-    {
-        return Err(TdvfError::InvalidDescriptorSize);
-    }
-
-    if descriptor.version != 1 {
-        return Err(TdvfError::InvalidDescriptorVersion);
-    }
-
-    let mut sections = Vec::new();
-    sections.resize_with(descriptor.num_sections as usize, TdvfSection::default);
-
-    // Safe as we read exactly the advertised sections
-    file.read_exact(unsafe {
-        std::slice::from_raw_parts_mut(
-            sections.as_mut_ptr() as *mut u8,
-            descriptor.num_sections as usize * std::mem::size_of::<TdvfSection>(),
-        )
-    })
-    .map_err(TdvfError::ReadDescriptor)?;
-
-    Ok(sections)
-}
-
-#[repr(u16)]
-#[derive(Copy, Clone, Debug)]
-enum HobType {
-    Handoff = 0x1,
-    ResourceDescriptor = 0x3,
-    Unused = 0xfffe,
-    EndOfHobList = 0xffff,
-}
-
-impl Default for HobType {
-    fn default() -> Self {
-        HobType::Unused
-    }
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-struct HobHeader {
-    r#type: HobType,
-    length: u16,
-    reserved: u32,
-}
-unsafe impl ByteValued for HobHeader {}
-
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-struct HobHandoffInfoTable {
-    header: HobHeader,
-    version: u32,
-    efi_memory_top: u64,
-    efi_memory_bottom: u64,
-    efi_free_memory_top: u64,
-    efi_free_memory_bottom: u64,
-    efi_end_of_hob_list: u64,
-}
-unsafe impl ByteValued for HobHandoffInfoTable {}
-
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-struct EfiGuid {
-    data1: u32,
-    data2: u16,
-    data3: u16,
-    data4: [u8; 8],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-struct HobResourceDescriptor {
-    header: HobHeader,
-    owner: EfiGuid,
-    resource_type: u32,
-    resource_attribute: u32,
-    physical_start: u64,
-    resource_length: u64,
-}
-unsafe impl ByteValued for HobResourceDescriptor {}
-
-pub struct TdHob {
-    start_offset: u64,
-    current_offset: u64,
-}
-
-fn align_hob(v: u64) -> u64 {
-    (v + 7) / 8 * 8
-}
-
-impl TdHob {
-    fn update_offset<T>(&mut self) {
-        self.current_offset = align_hob(self.current_offset + std::mem::size_of::<T>() as u64)
-    }
-
-    pub fn start(offset: u64) -> TdHob {
-        // Leave a gap to place the HandoffTable at the start as it can only be filled in later
-        let mut hob = TdHob {
-            start_offset: offset,
-            current_offset: offset,
-        };
-        hob.update_offset::<HobHandoffInfoTable>();
-        hob
-    }
-
-    pub fn finish(&mut self, mem: &GuestMemoryMmap) -> Result<(), TdvfError> {
-        // Write end
-        let end = HobHeader {
-            r#type: HobType::EndOfHobList,
-            length: std::mem::size_of::<HobHeader>() as u16,
-            reserved: 0,
-        };
-        info!("Writing HOB end {:x} {:x?}", self.current_offset, end);
-        mem.write_obj(end, GuestAddress(self.current_offset))
-            .map_err(TdvfError::GuestMemoryWriteHob)?;
-        self.update_offset::<HobHeader>();
-
-        // Write handoff, delayed as it needs end of HOB list
-        let efi_end_of_hob_list = self.current_offset;
-        let handoff = HobHandoffInfoTable {
-            header: HobHeader {
-                r#type: HobType::Handoff,
-                length: std::mem::size_of::<HobHandoffInfoTable>() as u16,
-                reserved: 0,
-            },
-            version: 0x9,
-            efi_memory_top: 0,
-            efi_memory_bottom: 0,
-            efi_free_memory_top: 0,
-            efi_free_memory_bottom: 0,
-            efi_end_of_hob_list,
-        };
-        info!("Writing HOB start {:x} {:x?}", self.start_offset, handoff);
-        mem.write_obj(handoff, GuestAddress(self.start_offset))
-            .map_err(TdvfError::GuestMemoryWriteHob)
-    }
-
-    pub fn add_resource(
-        &mut self,
-        mem: &GuestMemoryMmap,
-        physical_start: u64,
-        resource_length: u64,
-        resource_type: u32,
-        resource_attribute: u32,
-    ) -> Result<(), TdvfError> {
-        let resource_descriptor = HobResourceDescriptor {
-            header: HobHeader {
-                r#type: HobType::ResourceDescriptor,
-                length: std::mem::size_of::<HobResourceDescriptor>() as u16,
-                reserved: 0,
-            },
-            owner: EfiGuid::default(),
-            resource_type,
-            resource_attribute,
-            physical_start,
-            resource_length,
-        };
-        info!(
-            "Writing HOB resource {:x} {:x?}",
-            self.current_offset, resource_descriptor
-        );
-        mem.write_obj(resource_descriptor, GuestAddress(self.current_offset))
-            .map_err(TdvfError::GuestMemoryWriteHob)?;
-        self.update_offset::<HobResourceDescriptor>();
-        Ok(())
-    }
-
-    pub fn add_memory_resource(
-        &mut self,
-        mem: &GuestMemoryMmap,
-        physical_start: u64,
-        resource_length: u64,
-        ram: bool,
-    ) -> Result<(), TdvfError> {
-        self.add_resource(
-            mem,
-            physical_start,
-            resource_length,
-            if ram {
-                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_TESTED
-             * which differs from the spec (due to TDVF implementation issue?)
-             */
-            0x7,
-        )
-    }
-
-    pub fn add_mmio_resource(
-        &mut self,
-        mem: &GuestMemoryMmap,
-        physical_start: u64,
-        resource_length: u64,
-    ) -> Result<(), TdvfError> {
-        self.add_resource(
-            mem,
-            physical_start,
-            resource_length,
-            0x1, /* EFI_RESOURCE_MEMORY_MAPPED_IO */
-            /*
-             * EFI_RESOURCE_ATTRIBUTE_PRESENT | EFI_RESOURCE_ATTRIBUTE_INITIALIZED | EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE
-             */
-            0x403,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    #[ignore]
-    fn test_parse_tdvf_sections() {
-        let mut f = std::fs::File::open("tdvf.fd").unwrap();
-        let sections = parse_tdvf_sections(&mut f).unwrap();
-        for section in sections {
-            eprintln!("{:x?}", section)
-        }
-    }
-}

arch_gen/src/x86/mod.rs

@@ -8,7 +8,18 @@
 #[allow(non_upper_case_globals)]
 #[allow(non_camel_case_types)]
 #[allow(non_snake_case)]
+#[allow(
+    clippy::unreadable_literal,
+    clippy::redundant_static_lifetimes,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::useless_transmute,
+    clippy::should_implement_trait,
+    clippy::transmute_ptr_to_ptr
+)]
 #[allow(non_camel_case_types)]
 #[allow(non_upper_case_globals)]
 #[allow(clippy::unreadable_literal, clippy::redundant_static_lifetimes)]
 pub mod mpspec;
+#[allow(non_upper_case_globals)]
+#[allow(clippy::unreadable_literal, clippy::redundant_static_lifetimes)]
+pub mod msr_index;

arch_gen/src/x86/mpspec.rs

@@ -67,7 +67,7 @@ fn bindgen_test_layout_mpf_intel() {
         concat!("Alignment of ", stringify!(mpf_intel))
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).signature as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).signature as *const _ as usize },
         0usize,
         concat!(
             "Alignment of field: ",
@@ -77,7 +77,7 @@ fn bindgen_test_layout_mpf_intel() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).physptr as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).physptr as *const _ as usize },
         4usize,
         concat!(
             "Alignment of field: ",
@@ -87,7 +87,7 @@ fn bindgen_test_layout_mpf_intel() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).length as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).length as *const _ as usize },
         8usize,
         concat!(
             "Alignment of field: ",
@@ -97,7 +97,7 @@ fn bindgen_test_layout_mpf_intel() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).specification as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).specification as *const _ as usize },
         9usize,
         concat!(
             "Alignment of field: ",
@@ -107,7 +107,7 @@ fn bindgen_test_layout_mpf_intel() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).checksum as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).checksum as *const _ as usize },
         10usize,
         concat!(
             "Alignment of field: ",
@@ -117,7 +117,7 @@ fn bindgen_test_layout_mpf_intel() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).feature1 as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).feature1 as *const _ as usize },
         11usize,
         concat!(
             "Alignment of field: ",
@@ -127,7 +127,7 @@ fn bindgen_test_layout_mpf_intel() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).feature2 as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).feature2 as *const _ as usize },
         12usize,
         concat!(
             "Alignment of field: ",
@@ -137,7 +137,7 @@ fn bindgen_test_layout_mpf_intel() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).feature3 as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).feature3 as *const _ as usize },
         13usize,
         concat!(
             "Alignment of field: ",
@@ -147,7 +147,7 @@ fn bindgen_test_layout_mpf_intel() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).feature4 as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).feature4 as *const _ as usize },
         14usize,
         concat!(
             "Alignment of field: ",
@@ -157,7 +157,7 @@ fn bindgen_test_layout_mpf_intel() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpf_intel>()).feature5 as *const _ as usize },
+        unsafe { &(*(0 as *const mpf_intel)).feature5 as *const _ as usize },
         15usize,
         concat!(
             "Alignment of field: ",
@@ -200,7 +200,7 @@ fn bindgen_test_layout_mpc_table() {
         concat!("Alignment of ", stringify!(mpc_table))
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).signature as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).signature as *const _ as usize },
         0usize,
         concat!(
             "Alignment of field: ",
@@ -210,7 +210,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).length as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).length as *const _ as usize },
         4usize,
         concat!(
             "Alignment of field: ",
@@ -220,7 +220,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).spec as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).spec as *const _ as usize },
         6usize,
         concat!(
             "Alignment of field: ",
@@ -230,7 +230,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).checksum as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).checksum as *const _ as usize },
         7usize,
         concat!(
             "Alignment of field: ",
@@ -240,7 +240,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).oem as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).oem as *const _ as usize },
         8usize,
         concat!(
             "Alignment of field: ",
@@ -250,7 +250,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).productid as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).productid as *const _ as usize },
         16usize,
         concat!(
             "Alignment of field: ",
@@ -260,7 +260,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).oemptr as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).oemptr as *const _ as usize },
         28usize,
         concat!(
             "Alignment of field: ",
@@ -270,7 +270,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).oemsize as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).oemsize as *const _ as usize },
         32usize,
         concat!(
             "Alignment of field: ",
@@ -280,7 +280,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).oemcount as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).oemcount as *const _ as usize },
         34usize,
         concat!(
             "Alignment of field: ",
@@ -290,7 +290,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).lapic as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).lapic as *const _ as usize },
         36usize,
         concat!(
             "Alignment of field: ",
@@ -300,7 +300,7 @@ fn bindgen_test_layout_mpc_table() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_table>()).reserved as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_table)).reserved as *const _ as usize },
         40usize,
         concat!(
             "Alignment of field: ",
@@ -339,7 +339,7 @@ fn bindgen_test_layout_mpc_cpu() {
         concat!("Alignment of ", stringify!(mpc_cpu))
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_cpu>()).type_ as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_cpu)).type_ as *const _ as usize },
         0usize,
         concat!(
             "Alignment of field: ",
@@ -349,7 +349,7 @@ fn bindgen_test_layout_mpc_cpu() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_cpu>()).apicid as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_cpu)).apicid as *const _ as usize },
         1usize,
         concat!(
             "Alignment of field: ",
@@ -359,7 +359,7 @@ fn bindgen_test_layout_mpc_cpu() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_cpu>()).apicver as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_cpu)).apicver as *const _ as usize },
         2usize,
         concat!(
             "Alignment of field: ",
@@ -369,7 +369,7 @@ fn bindgen_test_layout_mpc_cpu() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_cpu>()).cpuflag as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_cpu)).cpuflag as *const _ as usize },
         3usize,
         concat!(
             "Alignment of field: ",
@@ -379,7 +379,7 @@ fn bindgen_test_layout_mpc_cpu() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_cpu>()).cpufeature as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_cpu)).cpufeature as *const _ as usize },
         4usize,
         concat!(
             "Alignment of field: ",
@@ -389,7 +389,7 @@ fn bindgen_test_layout_mpc_cpu() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_cpu>()).featureflag as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_cpu)).featureflag as *const _ as usize },
         8usize,
         concat!(
             "Alignment of field: ",
@@ -399,7 +399,7 @@ fn bindgen_test_layout_mpc_cpu() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_cpu>()).reserved as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_cpu)).reserved as *const _ as usize },
         12usize,
         concat!(
             "Alignment of field: ",
@@ -434,7 +434,7 @@ fn bindgen_test_layout_mpc_bus() {
         concat!("Alignment of ", stringify!(mpc_bus))
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_bus>()).type_ as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_bus)).type_ as *const _ as usize },
         0usize,
         concat!(
             "Alignment of field: ",
@@ -444,7 +444,7 @@ fn bindgen_test_layout_mpc_bus() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_bus>()).busid as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_bus)).busid as *const _ as usize },
         1usize,
         concat!(
             "Alignment of field: ",
@@ -454,7 +454,7 @@ fn bindgen_test_layout_mpc_bus() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_bus>()).bustype as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_bus)).bustype as *const _ as usize },
         2usize,
         concat!(
             "Alignment of field: ",
@@ -491,7 +491,7 @@ fn bindgen_test_layout_mpc_ioapic() {
         concat!("Alignment of ", stringify!(mpc_ioapic))
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_ioapic>()).type_ as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_ioapic)).type_ as *const _ as usize },
         0usize,
         concat!(
             "Alignment of field: ",
@@ -501,7 +501,7 @@ fn bindgen_test_layout_mpc_ioapic() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_ioapic>()).apicid as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_ioapic)).apicid as *const _ as usize },
         1usize,
         concat!(
             "Alignment of field: ",
@@ -511,7 +511,7 @@ fn bindgen_test_layout_mpc_ioapic() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_ioapic>()).apicver as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_ioapic)).apicver as *const _ as usize },
         2usize,
         concat!(
             "Alignment of field: ",
@@ -521,7 +521,7 @@ fn bindgen_test_layout_mpc_ioapic() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_ioapic>()).flags as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_ioapic)).flags as *const _ as usize },
         3usize,
         concat!(
             "Alignment of field: ",
@@ -531,7 +531,7 @@ fn bindgen_test_layout_mpc_ioapic() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_ioapic>()).apicaddr as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_ioapic)).apicaddr as *const _ as usize },
         4usize,
         concat!(
             "Alignment of field: ",
@@ -570,7 +570,7 @@ fn bindgen_test_layout_mpc_intsrc() {
         concat!("Alignment of ", stringify!(mpc_intsrc))
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_intsrc>()).type_ as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_intsrc)).type_ as *const _ as usize },
         0usize,
         concat!(
             "Alignment of field: ",
@@ -580,7 +580,7 @@ fn bindgen_test_layout_mpc_intsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_intsrc>()).irqtype as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_intsrc)).irqtype as *const _ as usize },
         1usize,
         concat!(
             "Alignment of field: ",
@@ -590,7 +590,7 @@ fn bindgen_test_layout_mpc_intsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_intsrc>()).irqflag as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_intsrc)).irqflag as *const _ as usize },
         2usize,
         concat!(
             "Alignment of field: ",
@@ -600,7 +600,7 @@ fn bindgen_test_layout_mpc_intsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_intsrc>()).srcbus as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_intsrc)).srcbus as *const _ as usize },
         4usize,
         concat!(
             "Alignment of field: ",
@@ -610,7 +610,7 @@ fn bindgen_test_layout_mpc_intsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_intsrc>()).srcbusirq as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_intsrc)).srcbusirq as *const _ as usize },
         5usize,
         concat!(
             "Alignment of field: ",
@@ -620,7 +620,7 @@ fn bindgen_test_layout_mpc_intsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_intsrc>()).dstapic as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_intsrc)).dstapic as *const _ as usize },
         6usize,
         concat!(
             "Alignment of field: ",
@@ -630,7 +630,7 @@ fn bindgen_test_layout_mpc_intsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_intsrc>()).dstirq as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_intsrc)).dstirq as *const _ as usize },
         7usize,
         concat!(
             "Alignment of field: ",
@@ -674,7 +674,7 @@ fn bindgen_test_layout_mpc_lintsrc() {
         concat!("Alignment of ", stringify!(mpc_lintsrc))
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_lintsrc>()).type_ as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_lintsrc)).type_ as *const _ as usize },
         0usize,
         concat!(
             "Alignment of field: ",
@@ -684,7 +684,7 @@ fn bindgen_test_layout_mpc_lintsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_lintsrc>()).irqtype as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_lintsrc)).irqtype as *const _ as usize },
         1usize,
         concat!(
             "Alignment of field: ",
@@ -694,7 +694,7 @@ fn bindgen_test_layout_mpc_lintsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_lintsrc>()).irqflag as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_lintsrc)).irqflag as *const _ as usize },
         2usize,
         concat!(
             "Alignment of field: ",
@@ -704,7 +704,7 @@ fn bindgen_test_layout_mpc_lintsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_lintsrc>()).srcbusid as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_lintsrc)).srcbusid as *const _ as usize },
         4usize,
         concat!(
             "Alignment of field: ",
@@ -714,7 +714,7 @@ fn bindgen_test_layout_mpc_lintsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_lintsrc>()).srcbusirq as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_lintsrc)).srcbusirq as *const _ as usize },
         5usize,
         concat!(
             "Alignment of field: ",
@@ -724,7 +724,7 @@ fn bindgen_test_layout_mpc_lintsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_lintsrc>()).destapic as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_lintsrc)).destapic as *const _ as usize },
         6usize,
         concat!(
             "Alignment of field: ",
@@ -734,7 +734,7 @@ fn bindgen_test_layout_mpc_lintsrc() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_lintsrc>()).destapiclint as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_lintsrc)).destapiclint as *const _ as usize },
         7usize,
         concat!(
             "Alignment of field: ",
@@ -771,7 +771,7 @@ fn bindgen_test_layout_mpc_oemtable() {
         concat!("Alignment of ", stringify!(mpc_oemtable))
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_oemtable>()).signature as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_oemtable)).signature as *const _ as usize },
         0usize,
         concat!(
             "Alignment of field: ",
@@ -781,7 +781,7 @@ fn bindgen_test_layout_mpc_oemtable() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_oemtable>()).length as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_oemtable)).length as *const _ as usize },
         4usize,
         concat!(
             "Alignment of field: ",
@@ -791,7 +791,7 @@ fn bindgen_test_layout_mpc_oemtable() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_oemtable>()).rev as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_oemtable)).rev as *const _ as usize },
         6usize,
         concat!(
             "Alignment of field: ",
@@ -801,7 +801,7 @@ fn bindgen_test_layout_mpc_oemtable() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_oemtable>()).checksum as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_oemtable)).checksum as *const _ as usize },
         7usize,
         concat!(
             "Alignment of field: ",
@@ -811,7 +811,7 @@ fn bindgen_test_layout_mpc_oemtable() {
         )
     );
     assert_eq!(
-        unsafe { &(*std::ptr::null::<mpc_oemtable>()).mpc as *const _ as usize },
+        unsafe { &(*(0 as *const mpc_oemtable)).mpc as *const _ as usize },
         8usize,
         concat!(
             "Alignment of field: ",

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 = []
-io_uring = []
-
-[dependencies]
-io-uring = ">=0.4.0"
-libc = "0.2.94"
-log = "0.4.14"
-qcow = { path = "../qcow" }
-serde = ">=1.0.27"
-serde_derive = ">=1.0.27"
-serde_json = ">=1.0.9"
-thiserror = "1.0"
-virtio-bindings = { version = "0.1", features = ["virtio-v5_0_0"]}
-vm-memory = { version = "0.5.0", features = ["backend-mmap", "backend-atomic"] }
-vm-virtio = { path = "../vm-virtio" }
-vmm-sys-util = ">=0.3.1"
-

block_util/src/async_io.rs

@@ -1,56 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use thiserror::Error;
-use vmm_sys_util::eventfd::EventFd;
-
-#[derive(Error, Debug)]
-pub enum DiskFileError {
-    /// Failed getting disk file size.
-    #[error("Failed getting disk file size: {0}")]
-    Size(#[source] std::io::Error),
-    /// Failed creating a new AsyncIo.
-    #[error("Failed creating a new AsyncIo: {0}")]
-    NewAsyncIo(#[source] std::io::Error),
-}
-
-pub type DiskFileResult<T> = std::result::Result<T, DiskFileError>;
-
-pub trait DiskFile: Send + Sync {
-    fn size(&mut self) -> DiskFileResult<u64>;
-    fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>>;
-}
-
-#[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/fixed_vhd_async.rs

@@ -1,110 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// 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,
-}
-
-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(),
-        })
-    }
-}
-
-impl DiskFile for FixedVhdDiskAsync {
-    fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self.size)
-    }
-
-    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)
-                .map_err(DiskFileError::NewAsyncIo)?,
-        ) as Box<dyn AsyncIo>)
-    }
-}
-
-pub struct FixedVhdAsync {
-    raw_file_async: RawFileAsync,
-    size: u64,
-}
-
-impl FixedVhdAsync {
-    pub fn new(fd: RawFd, ring_depth: u32, size: u64) -> std::io::Result<Self> {
-        let raw_file_async = RawFileAsync::new(fd, ring_depth)?;
-
-        Ok(FixedVhdAsync {
-            raw_file_async,
-            size,
-        })
-    }
-}
-
-impl AsyncIo for FixedVhdAsync {
-    fn notifier(&self) -> &EventFd {
-        self.raw_file_async.notifier()
-    }
-
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        if offset as u64 >= self.size {
-            return Err(AsyncIoError::ReadVectored(std::io::Error::new(
-                std::io::ErrorKind::InvalidData,
-                format!(
-                    "Invalid offset {}, can't be larger than file size {}",
-                    offset, self.size
-                ),
-            )));
-        }
-
-        self.raw_file_async.read_vectored(offset, iovecs, user_data)
-    }
-
-    fn write_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        if offset as u64 >= self.size {
-            return Err(AsyncIoError::WriteVectored(std::io::Error::new(
-                std::io::ErrorKind::InvalidData,
-                format!(
-                    "Invalid offset {}, can't be larger than file size {}",
-                    offset, self.size
-                ),
-            )));
-        }
-
-        self.raw_file_async
-            .write_vectored(offset, iovecs, user_data)
-    }
-
-    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
-        self.raw_file_async.fsync(user_data)
-    }
-
-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        self.raw_file_async.complete()
-    }
-}

block_util/src/fixed_vhd_sync.rs

@@ -1,107 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// 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,
-}
-
-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(),
-        })
-    }
-}
-
-impl DiskFile for FixedVhdDiskSync {
-    fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self.size)
-    }
-
-    fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
-        Ok(Box::new(
-            FixedVhdSync::new(self.file.as_raw_fd(), self.size)
-                .map_err(DiskFileError::NewAsyncIo)?,
-        ) as Box<dyn AsyncIo>)
-    }
-}
-
-pub struct FixedVhdSync {
-    raw_file_sync: RawFileSync,
-    size: u64,
-}
-
-impl FixedVhdSync {
-    pub fn new(fd: RawFd, size: u64) -> std::io::Result<Self> {
-        Ok(FixedVhdSync {
-            raw_file_sync: RawFileSync::new(fd),
-            size,
-        })
-    }
-}
-
-impl AsyncIo for FixedVhdSync {
-    fn notifier(&self) -> &EventFd {
-        self.raw_file_sync.notifier()
-    }
-
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        if offset as u64 >= self.size {
-            return Err(AsyncIoError::ReadVectored(std::io::Error::new(
-                std::io::ErrorKind::InvalidData,
-                format!(
-                    "Invalid offset {}, can't be larger than file size {}",
-                    offset, self.size
-                ),
-            )));
-        }
-
-        self.raw_file_sync.read_vectored(offset, iovecs, user_data)
-    }
-
-    fn write_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        if offset as u64 >= self.size {
-            return Err(AsyncIoError::WriteVectored(std::io::Error::new(
-                std::io::ErrorKind::InvalidData,
-                format!(
-                    "Invalid offset {}, can't be larger than file size {}",
-                    offset, self.size
-                ),
-            )));
-        }
-
-        self.raw_file_sync.write_vectored(offset, iovecs, user_data)
-    }
-
-    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
-        self.raw_file_sync.fsync(user_data)
-    }
-
-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        self.raw_file_sync.complete()
-    }
-}

block_util/src/lib.rs

@@ -1,620 +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;
-#[macro_use]
-extern crate serde_derive;
-
-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;
-
-use crate::async_io::{AsyncIo, AsyncIoError, AsyncIoResult, DiskFileError, DiskFileResult};
-#[cfg(feature = "io_uring")]
-use io_uring::{opcode, IoUring, Probe};
-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;
-#[cfg(feature = "io_uring")]
-use std::os::unix::io::AsRawFd;
-use std::path::Path;
-use std::result;
-use std::sync::{Arc, Mutex};
-use virtio_bindings::bindings::virtio_blk::*;
-use vm_memory::{ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryError, GuestMemoryMmap};
-use vm_virtio::DescriptorChain;
-use vmm_sys_util::eventfd::EventFd;
-
-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),
-}
-
-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,
-        }
-    }
-}
-
-#[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 Request {
-    pub request_type: RequestType,
-    pub sector: u64,
-    pub data_descriptors: Vec<(GuestAddress, u32)>,
-    pub status_addr: GuestAddress,
-    pub writeback: bool,
-}
-
-impl Request {
-    pub fn parse(
-        avail_desc: &DescriptorChain,
-        mem: &GuestMemoryMmap,
-    ) -> result::Result<Request, Error> {
-        // The head contains the request type which MUST be readable.
-        if avail_desc.is_write_only() {
-            return Err(Error::UnexpectedWriteOnlyDescriptor);
-        }
-
-        let mut req = Request {
-            request_type: request_type(&mem, avail_desc.addr)?,
-            sector: sector(&mem, avail_desc.addr)?,
-            data_descriptors: Vec::new(),
-            status_addr: GuestAddress(0),
-            writeback: true,
-        };
-
-        let status_desc;
-        let mut desc = avail_desc
-            .next_descriptor()
-            .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
-                    .next_descriptor()
-                    .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)
-    }
-
-    #[allow(clippy::ptr_arg)]
-    pub fn execute<T: Seek + Read + Write>(
-        &self,
-        disk: &mut T,
-        disk_nsectors: u64,
-        mem: &GuestMemoryMmap,
-        disk_id: &Vec<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.as_slice(), *data_addr)
-                        .map_err(ExecuteError::Write)?;
-                }
-                RequestType::Unsupported(t) => return Err(ExecuteError::Unsupported(t)),
-            };
-        }
-        Ok(len)
-    }
-
-    pub fn execute_async(
-        &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 {
-            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 buf = mem
-                .get_slice(*data_addr, *data_len as usize)
-                .map_err(ExecuteError::GetHostAddress)?
-                .as_ptr();
-            let iovec = libc::iovec {
-                iov_base: buf as *mut libc::c_void,
-                iov_len: *data_len as libc::size_t,
-            };
-            iovecs.push(iovec);
-        }
-
-        // Queue operations expected to be submitted.
-        match request_type {
-            RequestType::In => {
-                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 set_writeback(&mut self, writeback: bool) {
-        self.writeback = writeback
-    }
-}
-
-#[derive(Copy, Clone, Debug, Default, Deserialize, Serialize)]
-#[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],
-}
-unsafe impl ByteValued for VirtioBlockConfig {}
-
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize)]
-#[repr(C, packed)]
-pub struct VirtioBlockGeometry {
-    pub cylinders: u16,
-    pub heads: u8,
-    pub sectors: u8,
-}
-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.
-#[cfg(feature = "io_uring")]
-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 event_fd = match EventFd::new(libc::EFD_NONBLOCK) {
-        Ok(fd) => fd,
-        Err(e) => {
-            info!("{} failed to create eventfd: {}", error_msg, e);
-            return false;
-        }
-    };
-
-    // Check we can register an eventfd as this is going to be needed while
-    // using io_uring with the virtio block device. This also validates that
-    // io_uring_register() syscall is supported.
-    match submitter.register_eventfd(event_fd.as_raw_fd()) {
-        Ok(_) => {}
-        Err(e) => {
-            info!("{} failed to register eventfd: {}", error_msg, e);
-            return false;
-        }
-    }
-
-    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
-}
-
-#[cfg(not(feature = "io_uring"))]
-pub fn block_io_uring_is_supported() -> bool {
-    false
-}
-
-pub fn disk_size(file: &mut dyn Seek, semaphore: &mut Arc<Mutex<()>>) -> DiskFileResult<u64> {
-    // Take the semaphore to ensure other threads are not interacting with
-    // the underlying file.
-    let _lock = semaphore.lock().unwrap();
-
-    Ok(file.seek(SeekFrom::End(0)).map_err(DiskFileError::Size)? as u64)
-}
-
-pub trait ReadSeekFile: Read + Seek {}
-impl<F: Read + Seek> ReadSeekFile for F {}
-
-pub fn read_vectored_sync(
-    offset: libc::off_t,
-    iovecs: Vec<libc::iovec>,
-    user_data: u64,
-    file: &mut dyn ReadSeekFile,
-    eventfd: &EventFd,
-    completion_list: &mut Vec<(u64, i32)>,
-    semaphore: &mut Arc<Mutex<()>>,
-) -> 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 = {
-        // Take the semaphore to ensure other threads are not interacting
-        // with the underlying file.
-        let _lock = semaphore.lock().unwrap();
-
-        // 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(())
-}
-
-pub trait WriteSeekFile: Write + Seek {}
-impl<F: Write + Seek> WriteSeekFile for F {}
-
-pub fn write_vectored_sync(
-    offset: libc::off_t,
-    iovecs: Vec<libc::iovec>,
-    user_data: u64,
-    file: &mut dyn WriteSeekFile,
-    eventfd: &EventFd,
-    completion_list: &mut Vec<(u64, i32)>,
-    semaphore: &mut Arc<Mutex<()>>,
-) -> 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 = {
-        // Take the semaphore to ensure other threads are not interacting
-        // with the underlying file.
-        let _lock = semaphore.lock().unwrap();
-
-        // 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(())
-}
-
-pub fn fsync_sync(
-    user_data: Option<u64>,
-    file: &mut dyn Write,
-    eventfd: &EventFd,
-    completion_list: &mut Vec<(u64, i32)>,
-    semaphore: &mut Arc<Mutex<()>>,
-) -> AsyncIoResult<()> {
-    let result: i32 = {
-        // Take the semaphore to ensure other threads are not interacting
-        // with the underlying file.
-        let _lock = semaphore.lock().unwrap();
-
-        // 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(())
-}
-
-pub enum ImageType {
-    FixedVhd,
-    Qcow2,
-    Raw,
-}
-
-const QCOW_MAGIC: u32 = 0x5146_49fb;
-
-/// 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 {
-        ImageType::Raw
-    };
-
-    Ok(image_type)
-}

block_util/src/qcow_sync.rs

@@ -1,111 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileResult};
-use crate::{disk_size, fsync_sync, read_vectored_sync, write_vectored_sync};
-use qcow::{QcowFile, RawFile};
-use std::fs::File;
-use std::sync::{Arc, Mutex};
-use vmm_sys_util::eventfd::EventFd;
-
-pub struct QcowDiskSync {
-    qcow_file: QcowFile,
-    semaphore: Arc<Mutex<()>>,
-}
-
-impl QcowDiskSync {
-    pub fn new(file: File, direct_io: bool) -> Self {
-        QcowDiskSync {
-            qcow_file: QcowFile::from(RawFile::new(file, direct_io))
-                .expect("Failed creating QcowFile"),
-            semaphore: Arc::new(Mutex::new(())),
-        }
-    }
-}
-
-impl DiskFile for QcowDiskSync {
-    fn size(&mut self) -> DiskFileResult<u64> {
-        disk_size(&mut self.qcow_file, &mut self.semaphore)
-    }
-
-    fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
-        Ok(Box::new(QcowSync::new(
-            self.qcow_file.clone(),
-            self.semaphore.clone(),
-        )) as Box<dyn AsyncIo>)
-    }
-}
-
-pub struct QcowSync {
-    qcow_file: QcowFile,
-    eventfd: EventFd,
-    completion_list: Vec<(u64, i32)>,
-    semaphore: Arc<Mutex<()>>,
-}
-
-impl QcowSync {
-    pub fn new(qcow_file: QcowFile, semaphore: Arc<Mutex<()>>) -> Self {
-        QcowSync {
-            qcow_file,
-            eventfd: EventFd::new(libc::EFD_NONBLOCK)
-                .expect("Failed creating EventFd for QcowSync"),
-            completion_list: Vec::new(),
-            semaphore,
-        }
-    }
-}
-
-impl AsyncIo for QcowSync {
-    fn notifier(&self) -> &EventFd {
-        &self.eventfd
-    }
-
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        read_vectored_sync(
-            offset,
-            iovecs,
-            user_data,
-            &mut self.qcow_file,
-            &self.eventfd,
-            &mut self.completion_list,
-            &mut self.semaphore,
-        )
-    }
-
-    fn write_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        write_vectored_sync(
-            offset,
-            iovecs,
-            user_data,
-            &mut self.qcow_file,
-            &self.eventfd,
-            &mut self.completion_list,
-            &mut self.semaphore,
-        )
-    }
-
-    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
-        fsync_sync(
-            user_data,
-            &mut self.qcow_file,
-            &self.eventfd,
-            &mut self.completion_list,
-            &mut self.semaphore,
-        )
-    }
-
-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        self.completion_list.drain(..).collect()
-    }
-}

block_util/src/raw_async.rs

@@ -1,159 +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,
-};
-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>)
-    }
-}
-
-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
-    }
-}

block_util/src/raw_sync.rs

@@ -1,122 +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,
-};
-use std::fs::File;
-use std::io::{Seek, SeekFrom};
-use std::os::unix::io::{AsRawFd, RawFd};
-use vmm_sys_util::eventfd::EventFd;
-
-pub struct RawFileDiskSync {
-    file: File,
-}
-
-impl RawFileDiskSync {
-    pub fn new(file: File) -> Self {
-        RawFileDiskSync { file }
-    }
-}
-
-impl DiskFile for RawFileDiskSync {
-    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(RawFileSync::new(self.file.as_raw_fd())) as Box<dyn AsyncIo>)
-    }
-}
-
-pub struct RawFileSync {
-    fd: RawFd,
-    eventfd: EventFd,
-    completion_list: Vec<(u64, i32)>,
-}
-
-impl RawFileSync {
-    pub fn new(fd: RawFd) -> Self {
-        RawFileSync {
-            fd,
-            eventfd: EventFd::new(libc::EFD_NONBLOCK).expect("Failed creating EventFd for RawFile"),
-            completion_list: Vec::new(),
-        }
-    }
-}
-
-impl AsyncIo for RawFileSync {
-    fn notifier(&self) -> &EventFd {
-        &self.eventfd
-    }
-
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        let result = unsafe {
-            libc::preadv(
-                self.fd as libc::c_int,
-                iovecs.as_ptr() as *const libc::iovec,
-                iovecs.len() as libc::c_int,
-                offset,
-            )
-        };
-        if result < 0 {
-            return Err(AsyncIoError::ReadVectored(std::io::Error::last_os_error()));
-        }
-
-        self.completion_list.push((user_data, result as i32));
-        self.eventfd.write(1).unwrap();
-
-        Ok(())
-    }
-
-    fn write_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: Vec<libc::iovec>,
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        let result = unsafe {
-            libc::pwritev(
-                self.fd as libc::c_int,
-                iovecs.as_ptr() as *const libc::iovec,
-                iovecs.len() as libc::c_int,
-                offset,
-            )
-        };
-        if result < 0 {
-            return Err(AsyncIoError::WriteVectored(std::io::Error::last_os_error()));
-        }
-
-        self.completion_list.push((user_data, result as i32));
-        self.eventfd.write(1).unwrap();
-
-        Ok(())
-    }
-
-    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
-        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.eventfd.write(1).unwrap();
-        }
-
-        Ok(())
-    }
-
-    fn complete(&mut self) -> Vec<(u64, i32)> {
-        self.completion_list.drain(..).collect()
-    }
-}

block_util/src/vhd.rs

@@ -1,221 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-
-use std::convert::TryInto;
-use std::fs::File;
-use std::io::{Read, Seek, SeekFrom};
-
-#[derive(Clone, Copy)]
-pub struct VhdFooter {
-    cookie: u64,
-    features: u32,
-    file_format_version: u32,
-    data_offset: u64,
-    time_stamp: u32,
-    creator_application: u32,
-    creator_version: u32,
-    creator_host_os: u32,
-    original_size: u64,
-    current_size: u64,
-    disk_geometry: u32,
-    disk_type: u32,
-    checksum: u32,
-    unique_id: u128,
-    saved_state: u8,
-}
-
-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] };
-
-        // Place the cursor 512 bytes before the end of the file, as this is
-        // where the footer starts.
-        file.seek(SeekFrom::End(-512))?;
-
-        // Fill in the VhdFooter structure
-        file.read_exact(&mut s.data)?;
-
-        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()),
-        })
-    }
-
-    pub fn cookie(&self) -> u64 {
-        self.cookie
-    }
-    pub fn features(&self) -> u32 {
-        self.features
-    }
-    pub fn file_format_version(&self) -> u32 {
-        self.file_format_version
-    }
-    pub fn data_offset(&self) -> u64 {
-        self.data_offset
-    }
-    pub fn time_stamp(&self) -> u32 {
-        self.time_stamp
-    }
-    pub fn creator_application(&self) -> u32 {
-        self.creator_application
-    }
-    pub fn creator_version(&self) -> u32 {
-        self.creator_version
-    }
-    pub fn creator_host_os(&self) -> u32 {
-        self.creator_host_os
-    }
-    pub fn original_size(&self) -> u64 {
-        self.original_size
-    }
-    pub fn current_size(&self) -> u64 {
-        self.current_size
-    }
-    pub fn disk_geometry(&self) -> u32 {
-        self.disk_geometry
-    }
-    pub fn disk_type(&self) -> u32 {
-        self.disk_type
-    }
-    pub fn checksum(&self) -> u32 {
-        self.checksum
-    }
-    pub fn unique_id(&self) -> u128 {
-        self.unique_id
-    }
-    pub fn saved_state(&self) -> u8 {
-        self.saved_state
-    }
-}
-
-/// Determine image type through file parsing.
-pub fn is_fixed_vhd(f: &mut File) -> std::io::Result<bool> {
-    let footer = VhdFooter::new(f)?;
-
-    // "conectix" => 0x636f6e6563746978
-    Ok(footer.cookie() == 0x636f6e6563746978
-        && footer.file_format_version() == 0x0001_0000
-        && footer.data_offset() == 0xffff_ffff_ffff_ffff
-        && footer.disk_type() == 0x2)
-}
-
-#[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;
-
-    fn valid_fixed_vhd_footer() -> Vec<u8> {
-        vec![
-            0x63, 0x6f, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x78, // cookie
-            0x00, 0x00, 0x00, 0x02, // features
-            0x00, 0x01, 0x00, 0x00, // file format version
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // data offset
-            0x27, 0xa6, 0xa6, 0x5d, // time stamp
-            0x71, 0x65, 0x6d, 0x75, // creator application
-            0x00, 0x05, 0x00, 0x03, // creator version
-            0x57, 0x69, 0x32, 0x6b, // creator host os
-            0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // original size
-            0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // current size
-            0x11, 0xe0, 0x10, 0x3f, // disk geometry
-            0x00, 0x00, 0x00, 0x02, // disk type
-            0x00, 0x00, 0x00, 0x00, // checksum
-            0x98, 0x7b, 0xb1, 0xcd, 0x84, 0x14, 0x41, 0xfc, 0xa4, 0xab, 0xd0, 0x69, 0x45, 0x2b,
-            0xf2, 0x23, // unique id
-            0x00, // saved state
-        ]
-    }
-
-    fn valid_dynamic_vhd_footer() -> Vec<u8> {
-        vec![
-            0x63, 0x6f, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x78, // cookie
-            0x00, 0x00, 0x00, 0x02, // features
-            0x00, 0x01, 0x00, 0x00, // file format version
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // data offset
-            0x27, 0xa6, 0xa6, 0x5d, // time stamp
-            0x71, 0x65, 0x6d, 0x75, // creator application
-            0x00, 0x05, 0x00, 0x03, // creator version
-            0x57, 0x69, 0x32, 0x6b, // creator host os
-            0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // original size
-            0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // current size
-            0x11, 0xe0, 0x10, 0x3f, // disk geometry
-            0x00, 0x00, 0x00, 0x03, // disk type
-            0x00, 0x00, 0x00, 0x00, // checksum
-            0x98, 0x7b, 0xb1, 0xcd, 0x84, 0x14, 0x41, 0xfc, 0xa4, 0xab, 0xd0, 0x69, 0x45, 0x2b,
-            0xf2, 0x23, // unique id
-            0x00, // saved state
-        ]
-    }
-
-    fn with_file<F>(footer: &[u8], mut testfn: F)
-    where
-        F: FnMut(File),
-    {
-        let mut disk_file: File = TempFile::new().unwrap().into_file();
-        disk_file.set_len(0x1000_0200).unwrap();
-        disk_file.seek(SeekFrom::Start(0x1000_0000)).unwrap();
-        disk_file.write_all(&footer).unwrap();
-
-        testfn(disk_file); // File closed when the function exits.
-    }
-
-    #[test]
-    fn test_check_vhd_footer() {
-        with_file(&valid_fixed_vhd_footer(), |mut file: File| {
-            let vhd_footer = VhdFooter::new(&mut file).expect("Failed to create VHD footer");
-            assert_eq!(vhd_footer.cookie(), 0x636f_6e65_6374_6978);
-            assert_eq!(vhd_footer.features(), 0x0000_0002);
-            assert_eq!(vhd_footer.file_format_version(), 0x0001_0000);
-            assert_eq!(vhd_footer.data_offset(), 0xffff_ffff_ffff_ffff);
-            assert_eq!(vhd_footer.time_stamp(), 0x27a6_a65d);
-            assert_eq!(vhd_footer.creator_application(), 0x7165_6d75);
-            assert_eq!(vhd_footer.creator_version(), 0x0005_0003);
-            assert_eq!(vhd_footer.creator_host_os(), 0x5769_326b);
-            assert_eq!(vhd_footer.original_size(), 0x0000_0000_1000_0000);
-            assert_eq!(vhd_footer.current_size(), 0x0000_0000_1000_0000);
-            assert_eq!(vhd_footer.disk_geometry(), 0x11e0_103f);
-            assert_eq!(vhd_footer.disk_type(), 0x0000_0002);
-            assert_eq!(vhd_footer.checksum(), 0x0000_0000);
-            assert_eq!(
-                vhd_footer.unique_id(),
-                0x987b_b1cd_8414_41fc_a4ab_d069_452b_f223
-            );
-            assert_eq!(vhd_footer.saved_state(), 0x00);
-        });
-    }
-
-    #[test]
-    fn test_is_fixed_vhd() {
-        with_file(&valid_fixed_vhd_footer(), |mut file: File| {
-            assert!(is_fixed_vhd(&mut file).unwrap());
-        });
-    }
-
-    #[test]
-    fn test_is_not_fixed_vhd() {
-        with_file(&valid_dynamic_vhd_footer(), |mut file: File| {
-            assert!(!(is_fixed_vhd(&mut file).unwrap()));
-        });
-    }
-}

build.rs

@@ -1,27 +0,0 @@
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-#[macro_use(crate_version)]
-extern crate clap;
-
-use std::process::Command;
-
-fn main() {
-    let mut version = "v".to_owned() + crate_version!();
-
-    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;
-            }
-        }
-    }
-
-    // This println!() has a special behavior, as it will set the environment
-    // variable BUILT_VERSION, so that it can be reused from the binary.
-    // Particularly, this is used from src/main.rs to display the exact
-    // version.
-    println!("cargo:rustc-env=BUILT_VERSION={}", version);
-}

devices/Cargo.toml

@@ -4,23 +4,19 @@ version = "0.1.0"
 authors = ["The Chromium OS Authors"]
 
 [dependencies]
-anyhow = "1.0"
-bitflags = ">=1.2.1"
-byteorder = "1.4.3"
-epoll = ">=4.0.1"
-libc = "0.2.94"
-log = "0.4.14"
-serde = {version = ">=1.0.27", features = ["rc"] }
-serde_derive = ">=1.0.27"
-serde_json = ">=1.0.9"
+bitflags = "1.2.1"
+byteorder = "1.3.4"
+epoll = "4.1.0"
+libc = "0.2.66"
+log = "0.4.8"
 vm-device = { path = "../vm-device" }
-acpi_tables = { path = "../acpi_tables", optional = true }
-vm-memory = "0.5.0"
-vm-migration = { path = "../vm-migration" }
-vmm-sys-util = ">=0.3.1"
+vm-memory = { git = "https://github.com/rust-vmm/vm-memory" }
+vmm-sys-util = "0.4.0"
+
+[dev-dependencies]
+tempfile = "3.1.0"
 
 [features]
 default = []
-acpi = ["acpi_tables"]
+acpi = []
 cmos = []
-fwdebug = []

devices/src/acpi.rs

@@ -3,16 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-use acpi_tables::{aml, aml::Aml};
-use std::sync::{Arc, Barrier};
-use std::time::Instant;
+use std::sync::Arc;
 use vm_device::interrupt::InterruptSourceGroup;
-use vm_device::BusDevice;
-use vm_memory::GuestAddress;
 use vmm_sys_util::eventfd::EventFd;
-use AcpiNotificationFlags;
-
-pub const GED_DEVICE_ACPI_SIZE: usize = 0x1;
+use BusDevice;
+use HotPlugNotificationFlags;
 
 /// A device for handling ACPI shutdown and reboot
 pub struct AcpiShutdownDevice {
@@ -39,7 +34,7 @@ impl BusDevice for AcpiShutdownDevice {
         }
     }
 
-    fn write(&mut self, _base: u64, _offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
+    fn write(&mut self, _base: u64, _offset: u64, data: &[u8]) {
         if data[0] == 1 {
             debug!("ACPI Reboot signalled");
             if let Err(e) = self.reset_evt.write(1) {
@@ -57,35 +52,28 @@ impl BusDevice for AcpiShutdownDevice {
                 error!("Error triggering ACPI shutdown event: {}", e);
             }
         }
-        None
     }
 }
 
 /// A device for handling ACPI GED event generation
-pub struct AcpiGedDevice {
+pub struct AcpiGEDDevice {
     interrupt: Arc<Box<dyn InterruptSourceGroup>>,
-    notification_type: AcpiNotificationFlags,
+    notification_type: HotPlugNotificationFlags,
     ged_irq: u32,
-    address: GuestAddress,
 }
 
-impl AcpiGedDevice {
-    pub fn new(
-        interrupt: Arc<Box<dyn InterruptSourceGroup>>,
-        ged_irq: u32,
-        address: GuestAddress,
-    ) -> AcpiGedDevice {
-        AcpiGedDevice {
+impl AcpiGEDDevice {
+    pub fn new(interrupt: Arc<Box<dyn InterruptSourceGroup>>, ged_irq: u32) -> AcpiGEDDevice {
+        AcpiGEDDevice {
             interrupt,
-            notification_type: AcpiNotificationFlags::NO_DEVICES_CHANGED,
+            notification_type: HotPlugNotificationFlags::NO_DEVICES_CHANGED,
             ged_irq,
-            address,
         }
     }
 
     pub fn notify(
         &mut self,
-        notification_type: AcpiNotificationFlags,
+        notification_type: HotPlugNotificationFlags,
     ) -> Result<(), std::io::Error> {
         self.notification_type |= notification_type;
         self.interrupt.trigger(0)
@@ -97,111 +85,12 @@ impl AcpiGedDevice {
 }
 
 // I/O port reports what type of notification was made
-impl BusDevice for AcpiGedDevice {
+impl BusDevice for AcpiGEDDevice {
     // Spec has all fields as zero
     fn read(&mut self, _base: u64, _offset: u64, data: &mut [u8]) {
         data[0] = self.notification_type.bits();
-        self.notification_type = AcpiNotificationFlags::NO_DEVICES_CHANGED;
-    }
-}
-
-#[cfg(feature = "acpi")]
-impl Aml for AcpiGedDevice {
-    fn to_aml_bytes(&self) -> Vec<u8> {
-        aml::Device::new(
-            "_SB_.GED_".into(),
-            vec![
-                &aml::Name::new("_HID".into(), &"ACPI0013"),
-                &aml::Name::new("_UID".into(), &aml::ZERO),
-                &aml::Name::new(
-                    "_CRS".into(),
-                    &aml::ResourceTemplate::new(vec![&aml::Interrupt::new(
-                        true,
-                        true,
-                        false,
-                        false,
-                        self.ged_irq,
-                    )]),
-                ),
-                &aml::OpRegion::new(
-                    "GDST".into(),
-                    aml::OpRegionSpace::SystemMemory,
-                    self.address.0 as usize,
-                    GED_DEVICE_ACPI_SIZE,
-                ),
-                &aml::Field::new(
-                    "GDST".into(),
-                    aml::FieldAccessType::Byte,
-                    aml::FieldUpdateRule::WriteAsZeroes,
-                    vec![aml::FieldEntry::Named(*b"GDAT", 8)],
-                ),
-                &aml::Method::new(
-                    "_EVT".into(),
-                    1,
-                    true,
-                    vec![
-                        &aml::Store::new(&aml::Local(0), &aml::Path::new("GDAT")),
-                        &aml::And::new(&aml::Local(1), &aml::Local(0), &aml::ONE),
-                        &aml::If::new(
-                            &aml::Equal::new(&aml::Local(1), &aml::ONE),
-                            vec![&aml::MethodCall::new("\\_SB_.CPUS.CSCN".into(), vec![])],
-                        ),
-                        &aml::And::new(&aml::Local(1), &aml::Local(0), &2usize),
-                        &aml::If::new(
-                            &aml::Equal::new(&aml::Local(1), &2usize),
-                            vec![&aml::MethodCall::new("\\_SB_.MHPC.MSCN".into(), vec![])],
-                        ),
-                        &aml::And::new(&aml::Local(1), &aml::Local(0), &4usize),
-                        &aml::If::new(
-                            &aml::Equal::new(&aml::Local(1), &4usize),
-                            vec![&aml::MethodCall::new("\\_SB_.PCI0.PCNT".into(), vec![])],
-                        ),
-                        &aml::And::new(&aml::Local(1), &aml::Local(0), &8usize),
-                        &aml::If::new(
-                            &aml::Equal::new(&aml::Local(1), &8usize),
-                            vec![&aml::Notify::new(
-                                &aml::Path::new("\\_SB_.PWRB"),
-                                &0x80usize,
-                            )],
-                        ),
-                    ],
-                ),
-            ],
-        )
-        .to_aml_bytes()
-    }
-}
-
-pub struct AcpiPmTimerDevice {
-    start: Instant,
-}
-
-impl AcpiPmTimerDevice {
-    pub fn new() -> Self {
-        Self {
-            start: Instant::now(),
-        }
-    }
-}
-
-impl Default for AcpiPmTimerDevice {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl BusDevice for AcpiPmTimerDevice {
-    fn read(&mut self, _base: u64, _offset: u64, data: &mut [u8]) {
-        let now = Instant::now();
-        let since = now.duration_since(self.start);
-        let nanos = since.as_nanos();
-
-        const PM_TIMER_FREQUENCY_HZ: u128 = 3_579_545;
-        const NANOS_PER_SECOND: u128 = 1_000_000_000;
-
-        let counter = (nanos * PM_TIMER_FREQUENCY_HZ) / NANOS_PER_SECOND;
-        let counter: u32 = (counter & 0xffff_ffff) as u32;
-
-        data.copy_from_slice(&counter.to_le_bytes());
+        self.notification_type = HotPlugNotificationFlags::NO_DEVICES_CHANGED;
     }
+
+    fn write(&mut self, _base: u64, _offset: u64, _data: &[u8]) {}
 }

devices/src/bus.rs

@@ -9,7 +9,7 @@
 
 use std::cmp::{Ord, Ordering, PartialEq, PartialOrd};
 use std::collections::btree_map::BTreeMap;
-use std::sync::{Arc, Barrier, Mutex, RwLock, Weak};
+use std::sync::{Arc, Mutex, RwLock};
 use std::{convert, error, fmt, io, result};
 
 /// Trait for devices that respond to reads or writes in an arbitrary address space.
@@ -21,9 +21,9 @@ pub trait BusDevice: Send {
     /// Reads at `offset` from this device
     fn read(&mut self, base: u64, offset: u64, data: &mut [u8]) {}
     /// Writes at `offset` into this device
-    fn write(&mut self, base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
-        None
-    }
+    fn write(&mut self, base: u64, offset: u64, data: &[u8]) {}
+    /// Triggers the `irq_mask` interrupt on this device
+    fn interrupt(&self, irq_mask: u32) {}
 }
 
 #[derive(Debug)]
@@ -95,7 +95,7 @@ impl PartialOrd for BusRange {
 /// only restriction is that no two devices can overlap in this address space.
 #[derive(Default)]
 pub struct Bus {
-    devices: RwLock<BTreeMap<BusRange, Weak<Mutex<dyn BusDevice>>>>,
+    devices: RwLock<BTreeMap<BusRange, Arc<Mutex<dyn BusDevice>>>>,
 }
 
 impl Bus {
@@ -112,7 +112,7 @@ impl Bus {
             .range(..=BusRange { base: addr, len: 1 })
             .rev()
             .next()?;
-        dev.upgrade().map(|d| (*range, d.clone()))
+        Some((*range, dev.clone()))
     }
 
     #[allow(clippy::type_complexity)]
@@ -147,7 +147,7 @@ impl Bus {
             .devices
             .write()
             .unwrap()
-            .insert(BusRange { base, len }, Arc::downgrade(&device))
+            .insert(BusRange { base, len }, device)
             .is_some()
         {
             return Err(Error::Overlap);
@@ -171,24 +171,6 @@ impl Bus {
         Ok(())
     }
 
-    /// Removes all entries referencing the given device.
-    pub fn remove_by_device(&self, device: &Arc<Mutex<dyn BusDevice>>) -> Result<()> {
-        let mut device_list = self.devices.write().unwrap();
-        let mut remove_key_list = Vec::new();
-
-        for (key, value) in device_list.iter() {
-            if Arc::ptr_eq(&value.upgrade().unwrap(), device) {
-                remove_key_list.push(*key);
-            }
-        }
-
-        for key in remove_key_list.iter() {
-            device_list.remove(key);
-        }
-
-        Ok(())
-    }
-
     /// Updates the address range for an existing device.
     pub fn update_range(
         &self,
@@ -214,30 +196,30 @@ impl Bus {
     /// Reads data from the device that owns the range containing `addr` and puts it into `data`.
     ///
     /// Returns true on success, otherwise `data` is untouched.
-    pub fn read(&self, addr: u64, data: &mut [u8]) -> Result<()> {
+    pub fn read(&self, addr: u64, data: &mut [u8]) -> bool {
         if let Some((base, offset, dev)) = self.resolve(addr) {
             // OK to unwrap as lock() failing is a serious error condition and should panic.
             dev.lock()
                 .expect("Failed to acquire device lock")
                 .read(base, offset, data);
-            Ok(())
+            true
         } else {
-            Err(Error::MissingAddressRange)
+            false
         }
     }
 
     /// Writes `data` to the device that owns the range containing `addr`.
     ///
     /// Returns true on success, otherwise `data` is untouched.
-    pub fn write(&self, addr: u64, data: &[u8]) -> Result<Option<Arc<Barrier>>> {
+    pub fn write(&self, addr: u64, data: &[u8]) -> bool {
         if let Some((base, offset, dev)) = self.resolve(addr) {
             // OK to unwrap as lock() failing is a serious error condition and should panic.
-            Ok(dev
-                .lock()
+            dev.lock()
                 .expect("Failed to acquire device lock")
-                .write(base, offset, data))
+                .write(base, offset, data);
+            true
         } else {
-            Err(Error::MissingAddressRange)
+            false
         }
     }
 }
@@ -257,12 +239,10 @@ mod tests {
             }
         }
 
-        fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
+        fn write(&mut self, _base: u64, offset: u64, data: &[u8]) {
             for (i, v) in data.iter().enumerate() {
                 assert_eq!(*v, (offset as u8) + (i as u8))
             }
-
-            None
         }
     }
 
@@ -284,45 +264,42 @@ mod tests {
         assert!(bus.insert(dummy.clone(), 0x0, 0x20).is_err());
         assert!(bus.insert(dummy.clone(), 0x20, 0x05).is_ok());
         assert!(bus.insert(dummy.clone(), 0x25, 0x05).is_ok());
-        assert!(bus.insert(dummy, 0x0, 0x10).is_ok());
+        assert!(bus.insert(dummy.clone(), 0x0, 0x10).is_ok());
     }
 
     #[test]
-    #[allow(clippy::redundant_clone)]
     fn bus_read_write() {
         let bus = Bus::new();
         let dummy = Arc::new(Mutex::new(DummyDevice));
         assert!(bus.insert(dummy.clone(), 0x10, 0x10).is_ok());
-        assert!(bus.read(0x10, &mut [0, 0, 0, 0]).is_ok());
-        assert!(bus.write(0x10, &[0, 0, 0, 0]).is_ok());
-        assert!(bus.read(0x11, &mut [0, 0, 0, 0]).is_ok());
-        assert!(bus.write(0x11, &[0, 0, 0, 0]).is_ok());
-        assert!(bus.read(0x16, &mut [0, 0, 0, 0]).is_ok());
-        assert!(bus.write(0x16, &[0, 0, 0, 0]).is_ok());
-        assert!(bus.read(0x20, &mut [0, 0, 0, 0]).is_err());
-        assert!(bus.write(0x20, &[0, 0, 0, 0]).is_err());
-        assert!(bus.read(0x06, &mut [0, 0, 0, 0]).is_err());
-        assert!(bus.write(0x06, &[0, 0, 0, 0]).is_err());
+        assert!(bus.read(0x10, &mut [0, 0, 0, 0]));
+        assert!(bus.write(0x10, &[0, 0, 0, 0]));
+        assert!(bus.read(0x11, &mut [0, 0, 0, 0]));
+        assert!(bus.write(0x11, &[0, 0, 0, 0]));
+        assert!(bus.read(0x16, &mut [0, 0, 0, 0]));
+        assert!(bus.write(0x16, &[0, 0, 0, 0]));
+        assert!(!bus.read(0x20, &mut [0, 0, 0, 0]));
+        assert!(!bus.write(0x20, &mut [0, 0, 0, 0]));
+        assert!(!bus.read(0x06, &mut [0, 0, 0, 0]));
+        assert!(!bus.write(0x06, &mut [0, 0, 0, 0]));
     }
 
     #[test]
-    #[allow(clippy::redundant_clone)]
     fn bus_read_write_values() {
         let bus = Bus::new();
         let dummy = Arc::new(Mutex::new(ConstantDevice));
         assert!(bus.insert(dummy.clone(), 0x10, 0x10).is_ok());
 
         let mut values = [0, 1, 2, 3];
-        assert!(bus.read(0x10, &mut values).is_ok());
+        assert!(bus.read(0x10, &mut values));
         assert_eq!(values, [0, 1, 2, 3]);
-        assert!(bus.write(0x10, &values).is_ok());
-        assert!(bus.read(0x15, &mut values).is_ok());
+        assert!(bus.write(0x10, &values));
+        assert!(bus.read(0x15, &mut values));
         assert_eq!(values, [5, 6, 7, 8]);
-        assert!(bus.write(0x15, &values).is_ok());
+        assert!(bus.write(0x15, &values));
     }
 
     #[test]
-    #[allow(clippy::redundant_clone)]
     fn busrange_cmp() {
         let range = BusRange { base: 0x10, len: 2 };
         assert_eq!(range, BusRange { base: 0x10, len: 3 });
@@ -335,10 +312,11 @@ mod tests {
 
         let bus = Bus::new();
         let mut data = [1, 2, 3, 4];
-        let device = Arc::new(Mutex::new(DummyDevice));
-        assert!(bus.insert(device.clone(), 0x10, 0x10).is_ok());
-        assert!(bus.write(0x10, &data).is_ok());
-        assert!(bus.read(0x10, &mut data).is_ok());
+        assert!(bus
+            .insert(Arc::new(Mutex::new(DummyDevice)), 0x10, 0x10)
+            .is_ok());
+        assert!(bus.write(0x10, &mut data));
+        assert!(bus.read(0x10, &mut data));
         assert_eq!(data, [1, 2, 3, 4]);
     }
 

devices/src/gic.rs

@@ -1,86 +0,0 @@
-// Copyright 2020, ARM Limited.
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use super::interrupt_controller::{Error, InterruptController};
-use std::result;
-use std::sync::Arc;
-use vm_device::interrupt::{
-    InterruptIndex, InterruptManager, InterruptSourceConfig, InterruptSourceGroup,
-    LegacyIrqSourceConfig, MsiIrqGroupConfig,
-};
-use vmm_sys_util::eventfd::EventFd;
-
-type Result<T> = result::Result<T, Error>;
-
-// Reserve 32 IRQs for legacy device.
-pub const IRQ_LEGACY_BASE: usize = 0;
-pub const IRQ_LEGACY_COUNT: usize = 32;
-
-// This Gic struct implements InterruptController to provide interrupt delivery service.
-// The Gic source files in arch/ folder maintain the Aarch64 specific Gic device.
-// The 2 Gic instances could be merged together.
-// Leave this refactoring to future. Two options may be considered:
-//   1. Move Gic*.rs from arch/ folder here.
-//   2. Move this file and ioapic.rs to arch/, as they are architecture specific.
-pub struct Gic {
-    interrupt_source_group: Arc<Box<dyn InterruptSourceGroup>>,
-}
-
-impl Gic {
-    pub fn new(
-        _vcpu_count: u8,
-        interrupt_manager: Arc<dyn InterruptManager<GroupConfig = MsiIrqGroupConfig>>,
-    ) -> Result<Gic> {
-        let interrupt_source_group = interrupt_manager
-            .create_group(MsiIrqGroupConfig {
-                base: IRQ_LEGACY_BASE as InterruptIndex,
-                count: IRQ_LEGACY_COUNT as InterruptIndex,
-            })
-            .map_err(Error::CreateInterruptSourceGroup)?;
-
-        Ok(Gic {
-            interrupt_source_group,
-        })
-    }
-}
-
-impl InterruptController for Gic {
-    fn enable(&self) -> Result<()> {
-        // Set irqfd for legacy interrupts
-        self.interrupt_source_group
-            .enable()
-            .map_err(Error::EnableInterrupt)?;
-
-        // Set irq_routing for legacy interrupts.
-        //   irqchip: Hardcode to 0 as we support only 1 GIC
-        //   pin: Use irq number as pin
-        for i in IRQ_LEGACY_BASE..(IRQ_LEGACY_BASE + IRQ_LEGACY_COUNT) {
-            let config = LegacyIrqSourceConfig {
-                irqchip: 0,
-                pin: i as u32,
-            };
-            self.interrupt_source_group
-                .update(
-                    i as InterruptIndex,
-                    InterruptSourceConfig::LegacyIrq(config),
-                )
-                .map_err(Error::EnableInterrupt)?;
-        }
-        Ok(())
-    }
-
-    // This should be called anytime an interrupt needs to be injected into the
-    // running guest.
-    fn service_irq(&mut self, irq: usize) -> Result<()> {
-        self.interrupt_source_group
-            .trigger(irq as InterruptIndex)
-            .map_err(Error::TriggerInterrupt)?;
-
-        Ok(())
-    }
-
-    fn notifier(&self, irq: usize) -> Option<EventFd> {
-        self.interrupt_source_group.notifier(irq as InterruptIndex)
-    }
-}

devices/src/interrupt_controller.rs

@@ -1,61 +0,0 @@
-// Copyright 2020, ARM Limited.
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use std::io;
-use std::result;
-use vmm_sys_util::eventfd::EventFd;
-
-#[derive(Debug)]
-pub enum Error {
-    /// Invalid trigger mode.
-    InvalidTriggerMode,
-    /// Invalid delivery mode.
-    InvalidDeliveryMode,
-    /// Failed creating the interrupt source group.
-    CreateInterruptSourceGroup(io::Error),
-    /// Failed triggering the interrupt.
-    TriggerInterrupt(io::Error),
-    /// Failed masking the interrupt.
-    MaskInterrupt(io::Error),
-    /// Failed unmasking the interrupt.
-    UnmaskInterrupt(io::Error),
-    /// Failed updating the interrupt.
-    UpdateInterrupt(io::Error),
-    /// Failed enabling the interrupt.
-    EnableInterrupt(io::Error),
-}
-
-type Result<T> = result::Result<T, Error>;
-
-pub struct MsiMessage {
-    // Message Address Register
-    //   31-20: Base address. Fixed value (0x0FEE)
-    //   19-12: Destination ID
-    //   11-4:  Reserved
-    //   3:     Redirection Hint indication
-    //   2:     Destination Mode
-    //   1-0:   Reserved
-    pub addr: u32,
-    // Message Data Register
-    //   32-16: Reserved
-    //   15:    Trigger Mode. 0 = Edge, 1 = Level
-    //   14:    Level. 0 = Deassert, 1 = Assert
-    //   13-11: Reserved
-    //   10-8:  Delivery Mode
-    //   7-0:   Vector
-    pub data: u32,
-}
-
-// Introduce trait InterruptController to uniform the interrupt
-// service provided for devices.
-// Device manager uses this trait without caring whether it is a
-// IOAPIC (X86) or GIC (Arm).
-pub trait InterruptController: Send {
-    fn service_irq(&mut self, irq: usize) -> Result<()>;
-    #[cfg(target_arch = "aarch64")]
-    fn enable(&self) -> Result<()>;
-    #[cfg(target_arch = "x86_64")]
-    fn end_of_interrupt(&mut self, vec: u8);
-    fn notifier(&self, irq: usize) -> Option<EventFd>;
-}

devices/src/ioapic.rs

@@ -9,19 +9,38 @@
 // Implementation of an intel 82093AA Input/Output Advanced Programmable Interrupt Controller
 // See https://pdos.csail.mit.edu/6.828/2016/readings/ia32/ioapic.pdf for a specification.
 
-use super::interrupt_controller::{Error, InterruptController};
-use anyhow::anyhow;
+use crate::BusDevice;
 use byteorder::{ByteOrder, LittleEndian};
+use std::io;
 use std::result;
-use std::sync::{Arc, Barrier};
+use std::sync::Arc;
 use vm_device::interrupt::{
     InterruptIndex, InterruptManager, InterruptSourceConfig, InterruptSourceGroup,
     MsiIrqGroupConfig, MsiIrqSourceConfig,
 };
-use vm_device::BusDevice;
 use vm_memory::GuestAddress;
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-use vmm_sys_util::eventfd::EventFd;
+
+#[derive(Debug)]
+pub enum Error {
+    /// Invalid destination mode.
+    InvalidDestinationMode,
+    /// Invalid trigger mode.
+    InvalidTriggerMode,
+    /// Invalid delivery mode.
+    InvalidDeliveryMode,
+    /// Failed creating the interrupt source group.
+    CreateInterruptSourceGroup(io::Error),
+    /// Failed triggering the interrupt.
+    TriggerInterrupt(io::Error),
+    /// Failed masking the interrupt.
+    MaskInterrupt(io::Error),
+    /// Failed unmasking the interrupt.
+    UnmaskInterrupt(io::Error),
+    /// Failed updating the interrupt.
+    UpdateInterrupt(io::Error),
+    /// Failed enabling the interrupt.
+    EnableInterrupt(io::Error),
+}
 
 type Result<T> = result::Result<T, Error>;
 
@@ -61,12 +80,10 @@ fn trigger_mode(entry: RedirectionTableEntry) -> u8 {
 fn interrupt_mask(entry: RedirectionTableEntry) -> u8 {
     ((entry >> 16) & 0x1u64) as u8
 }
-fn destination_field(entry: RedirectionTableEntry) -> u8 {
-    // When the destination mode is physical, the destination field should only
-    // be defined through bits 56-59, as defined in the IOAPIC specification.
-    // But from the APIC specification, the APIC ID is always defined on 8 bits
-    // no matter which destination mode is selected. That's why we always
-    // retrieve the destination field based on bits 56-63.
+fn destination_field_physical(entry: RedirectionTableEntry) -> u8 {
+    ((entry >> 56) & 0xfu64) as u8
+}
+fn destination_field_logical(entry: RedirectionTableEntry) -> u8 {
     ((entry >> 56) & 0xffu64) as u8
 }
 fn set_delivery_status(entry: &mut RedirectionTableEntry, val: u8) {
@@ -82,6 +99,25 @@ fn set_remote_irr(entry: &mut RedirectionTableEntry, val: u8) {
     *entry |= u64::from(val & 0x1) << 14;
 }
 
+pub struct MsiMessage {
+    // Message Address Register
+    //   31-20: Base address. Fixed value (0x0FEE)
+    //   19-12: Destination ID
+    //   11-4:  Reserved
+    //   3:     Redirection Hint indication
+    //   2:     Destination Mode
+    //   1-0:   Reserved
+    pub addr: u32,
+    // Message Data Register
+    //   32-16: Reserved
+    //   15:    Trigger Mode. 0 = Edge, 1 = Level
+    //   14:    Level. 0 = Deassert, 1 = Assert
+    //   13-11: Reserved
+    //   10-8:  Delivery Mode
+    //   7-0:   Vector
+    pub data: u32,
+}
+
 pub const NUM_IOAPIC_PINS: usize = 24;
 const IOAPIC_VERSION_ID: u32 = 0x0017_0011;
 
@@ -96,6 +132,12 @@ const IOWIN_OFF: u8 = 0x10;
 const IOWIN_SCALE: u8 = 0x2;
 const REG_MAX_OFFSET: u8 = IOWIN_OFF + (NUM_IOAPIC_PINS as u8 * 2) - 1;
 
+#[repr(u8)]
+enum DestinationMode {
+    Physical = 0,
+    Logical = 1,
+}
+
 #[repr(u8)]
 enum TriggerMode {
     Edge = 0,
@@ -106,9 +148,9 @@ enum TriggerMode {
 enum DeliveryMode {
     Fixed = 0b000,
     Lowest = 0b001,
-    Smi = 0b010,        // System management interrupt
+    SMI = 0b010,        // System management interrupt
     RemoteRead = 0b011, // This is no longer supported by intel.
-    Nmi = 0b100,        // Non maskable interrupt
+    NMI = 0b100,        // Non maskable interrupt
     Init = 0b101,
     Startup = 0b110,
     External = 0b111,
@@ -124,24 +166,13 @@ fn decode_irq_from_selector(selector: u8) -> (usize, bool) {
 }
 
 pub struct Ioapic {
-    id: String,
-    id_reg: u32,
+    id: u32,
     reg_sel: u32,
     reg_entries: [RedirectionTableEntry; NUM_IOAPIC_PINS],
-    used_entries: [bool; NUM_IOAPIC_PINS],
     apic_address: GuestAddress,
     interrupt_source_group: Arc<Box<dyn InterruptSourceGroup>>,
 }
 
-#[derive(Serialize, Deserialize)]
-pub struct IoapicState {
-    id_reg: u32,
-    reg_sel: u32,
-    reg_entries: [RedirectionTableEntry; NUM_IOAPIC_PINS],
-    used_entries: [bool; NUM_IOAPIC_PINS],
-    apic_address: u64,
-}
-
 impl BusDevice for Ioapic {
     fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
         assert!(data.len() == 4);
@@ -160,7 +191,7 @@ impl BusDevice for Ioapic {
         LittleEndian::write_u32(data, value);
     }
 
-    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
+    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) {
         assert!(data.len() == 4);
 
         debug!("IOAPIC_W @ offset 0x{:x}", offset);
@@ -174,123 +205,63 @@ impl BusDevice for Ioapic {
                 error!("IOAPIC: failed writing at offset {}", offset);
             }
         }
-        None
     }
 }
 
 impl Ioapic {
     pub fn new(
-        id: String,
         apic_address: GuestAddress,
         interrupt_manager: Arc<dyn InterruptManager<GroupConfig = MsiIrqGroupConfig>>,
     ) -> Result<Ioapic> {
         let interrupt_source_group = interrupt_manager
             .create_group(MsiIrqGroupConfig {
-                base: 0,
+                base: 0 as InterruptIndex,
                 count: NUM_IOAPIC_PINS as InterruptIndex,
             })
             .map_err(Error::CreateInterruptSourceGroup)?;
 
-        // The IOAPIC is created with entries already masked. The guest will be
-        // in charge of unmasking them if/when necessary.
+        interrupt_source_group
+            .enable()
+            .map_err(Error::EnableInterrupt)?;
+
         Ok(Ioapic {
-            id,
-            id_reg: 0,
+            id: 0,
             reg_sel: 0,
-            reg_entries: [0x10000; NUM_IOAPIC_PINS],
-            used_entries: [false; NUM_IOAPIC_PINS],
+            reg_entries: [0; NUM_IOAPIC_PINS],
             apic_address,
             interrupt_source_group,
         })
     }
 
-    fn ioapic_write(&mut self, val: u32) {
-        debug!("IOAPIC_W reg 0x{:x}, val 0x{:x}", self.reg_sel, val);
-
-        match self.reg_sel as u8 {
-            IOAPIC_REG_VERSION => {
-                if val == 0 {
-                    // Windows writes zero here (see #1791)
-                } else {
-                    error!(
-                        "IOAPIC: invalid write to version register (0x{:x}): 0x{:x}",
-                        self.reg_sel, val
-                    );
-                }
-            }
-            IOAPIC_REG_ID => self.id_reg = (val >> 24) & 0xf,
-            IOWIN_OFF..=REG_MAX_OFFSET => {
-                let (index, is_high_bits) = decode_irq_from_selector(self.reg_sel as u8);
-                if is_high_bits {
-                    self.reg_entries[index] &= 0xffff_ffff;
-                    self.reg_entries[index] |= u64::from(val) << 32;
-                } else {
-                    // Ensure not to override read-only bits:
-                    // - Delivery Status (bit 12)
-                    // - Remote IRR (bit 14)
-                    self.reg_entries[index] &= 0xffff_ffff_0000_5000;
-                    self.reg_entries[index] |= u64::from(val) & 0xffff_afff;
-                }
-                // The entry must be updated through the interrupt source
-                // group.
-                if let Err(e) = self.update_entry(index) {
-                    error!("Failed updating IOAPIC entry: {:?}", e);
-                }
-                // Store the information this IRQ is now being used.
-                self.used_entries[index] = true;
-            }
-            _ => error!(
-                "IOAPIC: invalid write to register offset 0x{:x}",
-                self.reg_sel
-            ),
-        }
-    }
-
-    fn ioapic_read(&self) -> u32 {
-        debug!("IOAPIC_R reg 0x{:x}", self.reg_sel);
-
-        match self.reg_sel as u8 {
-            IOAPIC_REG_VERSION => IOAPIC_VERSION_ID,
-            IOAPIC_REG_ID | IOAPIC_REG_ARBITRATION_ID => (self.id_reg & 0xf) << 24,
-            IOWIN_OFF..=REG_MAX_OFFSET => {
-                let (index, is_high_bits) = decode_irq_from_selector(self.reg_sel as u8);
-                if is_high_bits {
-                    (self.reg_entries[index] >> 32) as u32
-                } else {
-                    (self.reg_entries[index] & 0xffff_ffff) as u32
-                }
-            }
-            _ => {
-                error!(
-                    "IOAPIC: invalid read from register offset 0x{:x}",
-                    self.reg_sel
-                );
-                0
+    // The ioapic must be informed about EOIs in order to deassert interrupts
+    // already sent.
+    pub fn end_of_interrupt(&mut self, vec: u8) {
+        for i in 0..NUM_IOAPIC_PINS {
+            let entry = &mut self.reg_entries[i];
+            // Clear Remote IRR bit
+            if vector(*entry) == vec && trigger_mode(*entry) == 1 {
+                set_remote_irr(entry, 0);
             }
         }
     }
 
-    fn state(&self) -> IoapicState {
-        IoapicState {
-            id_reg: self.id_reg,
-            reg_sel: self.reg_sel,
-            reg_entries: self.reg_entries,
-            used_entries: self.used_entries,
-            apic_address: self.apic_address.0,
-        }
-    }
+    // This should be called anytime an interrupt needs to be injected into the
+    // running guest.
+    pub fn service_irq(&mut self, irq: usize) -> Result<()> {
+        let entry = &mut self.reg_entries[irq];
 
-    fn set_state(&mut self, state: &IoapicState) -> Result<()> {
-        self.id_reg = state.id_reg;
-        self.reg_sel = state.reg_sel;
-        self.reg_entries = state.reg_entries;
-        self.used_entries = state.used_entries;
-        self.apic_address = GuestAddress(state.apic_address);
-        for (irq, entry) in self.used_entries.iter().enumerate() {
-            if *entry {
-                self.update_entry(irq)?;
-            }
+        self.interrupt_source_group
+            .trigger(irq as InterruptIndex)
+            .map_err(Error::TriggerInterrupt)?;
+        debug!("Interrupt successfully delivered");
+
+        // If trigger mode is level sensitive, set the Remote IRR bit.
+        // It will be cleared when the EOI is received.
+        if trigger_mode(*entry) == 1 {
+            set_remote_irr(entry, 1);
         }
+        // Clear the Delivery Status bit
+        set_delivery_status(entry, 0);
 
         Ok(())
     }
@@ -300,7 +271,11 @@ impl Ioapic {
 
         // Validate Destination Mode value, and retrieve Destination ID
         let destination_mode = destination_mode(entry);
-        let destination_id = destination_field(entry);
+        let destination_id: u8 = match destination_mode {
+            x if x == DestinationMode::Physical as u8 => destination_field_physical(entry),
+            x if x == DestinationMode::Logical as u8 => destination_field_logical(entry),
+            _ => return Err(Error::InvalidDestinationMode),
+        };
 
         // When this bit is set, the message is directed to the processor with
         // the lowest interrupt priority among processors that can receive the
@@ -325,9 +300,9 @@ impl Ioapic {
         match delivery_mode {
             x if (x == DeliveryMode::Fixed as u8)
                 || (x == DeliveryMode::Lowest as u8)
-                || (x == DeliveryMode::Smi as u8)
+                || (x == DeliveryMode::SMI as u8)
                 || (x == DeliveryMode::RemoteRead as u8)
-                || (x == DeliveryMode::Nmi as u8)
+                || (x == DeliveryMode::NMI as u8)
                 || (x == DeliveryMode::Init as u8)
                 || (x == DeliveryMode::Startup as u8)
                 || (x == DeliveryMode::External as u8) => {}
@@ -344,7 +319,6 @@ impl Ioapic {
             high_addr: 0x0,
             low_addr,
             data,
-            devid: 0,
         };
 
         self.interrupt_source_group
@@ -363,63 +337,52 @@ impl Ioapic {
 
         Ok(())
     }
-}
 
-impl InterruptController for Ioapic {
-    // The ioapic must be informed about EOIs in order to deassert interrupts
-    // already sent.
-    fn end_of_interrupt(&mut self, vec: u8) {
-        for i in 0..NUM_IOAPIC_PINS {
-            let entry = &mut self.reg_entries[i];
-            // Clear Remote IRR bit
-            if vector(*entry) == vec && trigger_mode(*entry) == 1 {
-                set_remote_irr(entry, 0);
+    fn ioapic_write(&mut self, val: u32) {
+        debug!("IOAPIC_W reg 0x{:x}, val 0x{:x}", self.reg_sel, val);
+
+        match self.reg_sel as u8 {
+            IOAPIC_REG_ID => self.id = (val >> 24) & 0xf,
+            IOWIN_OFF..=REG_MAX_OFFSET => {
+                let (index, is_high_bits) = decode_irq_from_selector(self.reg_sel as u8);
+                if is_high_bits {
+                    self.reg_entries[index] &= 0xffff_ffff;
+                    self.reg_entries[index] |= u64::from(val) << 32;
+                } else {
+                    // Ensure not to override read-only bits:
+                    // - Delivery Status (bit 12)
+                    // - Remote IRR (bit 14)
+                    self.reg_entries[index] &= 0xffff_ffff_0000_5000;
+                    self.reg_entries[index] |= u64::from(val) & 0xffff_afff;
+                }
+                // The entry must be updated through the interrupt source
+                // group.
+                if let Err(e) = self.update_entry(index) {
+                    error!("Failed updating IOAPIC entry: {:?}", e);
+                }
+            }
+            _ => error!("IOAPIC: invalid write to register offset"),
+        }
+    }
+
+    fn ioapic_read(&self) -> u32 {
+        debug!("IOAPIC_R reg 0x{:x}", self.reg_sel);
+
+        match self.reg_sel as u8 {
+            IOAPIC_REG_VERSION => IOAPIC_VERSION_ID,
+            IOAPIC_REG_ID | IOAPIC_REG_ARBITRATION_ID => (self.id & 0xf) << 24,
+            IOWIN_OFF..=REG_MAX_OFFSET => {
+                let (index, is_high_bits) = decode_irq_from_selector(self.reg_sel as u8);
+                if is_high_bits {
+                    (self.reg_entries[index] >> 32) as u32
+                } else {
+                    (self.reg_entries[index] & 0xffff_ffff) as u32
+                }
+            }
+            _ => {
+                error!("IOAPIC: invalid read from register offset");
+                0
             }
         }
     }
-
-    // This should be called anytime an interrupt needs to be injected into the
-    // running guest.
-    fn service_irq(&mut self, irq: usize) -> Result<()> {
-        let entry = &mut self.reg_entries[irq];
-
-        self.interrupt_source_group
-            .trigger(irq as InterruptIndex)
-            .map_err(Error::TriggerInterrupt)?;
-        debug!("Interrupt successfully delivered");
-
-        // If trigger mode is level sensitive, set the Remote IRR bit.
-        // It will be cleared when the EOI is received.
-        if trigger_mode(*entry) == 1 {
-            set_remote_irr(entry, 1);
-        }
-        // Clear the Delivery Status bit
-        set_delivery_status(entry, 0);
-
-        Ok(())
-    }
-
-    fn notifier(&self, irq: usize) -> Option<EventFd> {
-        self.interrupt_source_group.notifier(irq as InterruptIndex)
-    }
 }
-
-impl Snapshottable for Ioapic {
-    fn id(&self) -> String {
-        self.id.clone()
-    }
-
-    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_state(&self.id, &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_state(&self.id)?).map_err(|e| {
-            MigratableError::Restore(anyhow!("Could not restore state for {}: {:?}", self.id, e))
-        })
-    }
-}
-
-impl Pausable for Ioapic {}
-impl Transportable for Ioapic {}
-impl Migratable for Ioapic {}

devices/src/legacy/cmos.rs

@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-use libc::{clock_gettime, gmtime_r, time_t, timespec, tm, CLOCK_REALTIME};
+use libc::{gmtime_r, time, time_t, tm};
 use std::cmp::min;
 use std::mem;
-use std::sync::{Arc, Barrier};
-use vm_device::BusDevice;
+
+use crate::BusDevice;
 
 const INDEX_MASK: u8 = 0x7f;
 const INDEX_OFFSET: u64 = 0x0;
@@ -45,17 +45,16 @@ impl Cmos {
 }
 
 impl BusDevice for Cmos {
-    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
+    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) {
         if data.len() != 1 {
-            return None;
+            return;
         }
 
         match offset {
             INDEX_OFFSET => self.index = data[0] & INDEX_MASK,
             DATA_OFFSET => self.data[self.index as usize] = data[0],
             o => panic!("bad write offset on CMOS device: {}", o),
-        };
-        None
+        }
     }
 
     fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
@@ -78,17 +77,14 @@ impl BusDevice for Cmos {
                 let day;
                 let month;
                 let year;
-                // The clock_gettime and gmtime_r calls are safe as long as the structs they are
-                // given are large enough, and neither of them fail. It is safe to zero initialize
-                // the tm and timespec struct because it contains only plain data.
-                let update_in_progress = unsafe {
-                    let mut timespec: timespec = mem::zeroed();
-                    clock_gettime(CLOCK_REALTIME, &mut timespec as *mut _);
-
-                    let now: time_t = timespec.tv_sec;
+                // The time and gmtime_r calls are safe as long as the structs they are given are
+                // large enough, and neither of them fail. It is safe to zero initialize the tm
+                // struct because it contains only plain data.
+                unsafe {
                     let mut tm: tm = mem::zeroed();
+                    let mut now: time_t = 0;
+                    time(&mut now as *mut _);
                     gmtime_r(&now, &mut tm as *mut _);
-
                     // The following lines of code are safe but depend on tm being in scope.
                     seconds = tm.tm_sec;
                     minutes = tm.tm_min;
@@ -97,11 +93,6 @@ impl BusDevice for Cmos {
                     day = tm.tm_mday;
                     month = tm.tm_mon + 1;
                     year = tm.tm_year;
-
-                    // Update in Progress bit held for last 224us of each second
-                    const NANOSECONDS_PER_SECOND: i64 = 1_000_000_000;
-                    const UIP_HOLD_LENGTH: i64 = 8 * NANOSECONDS_PER_SECOND / 32768;
-                    timespec.tv_nsec >= (NANOSECONDS_PER_SECOND - UIP_HOLD_LENGTH)
                 };
                 match self.index {
                     0x00 => to_bcd(seconds as u8),
@@ -111,8 +102,6 @@ impl BusDevice for Cmos {
                     0x07 => to_bcd(day as u8),
                     0x08 => to_bcd(month as u8),
                     0x09 => to_bcd((year % 100) as u8),
-                    // Bit 5 for 32kHz clock. Bit 7 for Update in Progress
-                    0x0a => 1 << 5 | (update_in_progress as u8) << 7,
                     0x32 => to_bcd(((year + 1900) / 100) as u8),
                     _ => {
                         // self.index is always guaranteed to be in range via INDEX_MASK.

devices/src/legacy/fwdebug.rs

@@ -1,43 +0,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 LICENSE-BSD-3-Clause file.
-//
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-//
-
-use std::sync::{Arc, Barrier};
-use vm_device::BusDevice;
-
-/// Provides firmware debug output via I/O port controls
-#[derive(Default)]
-pub struct FwDebugDevice {}
-
-impl FwDebugDevice {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-/// FwDebugDevice sits on the I/O bus as 0x402 and receives ASCII characters
-impl BusDevice for FwDebugDevice {
-    /// Upon read return the magic value to indicate that there is a debug port
-    fn read(&mut self, _base: u64, _offset: u64, data: &mut [u8]) {
-        if data.len() == 1 {
-            data[0] = 0xe9
-        } else {
-            error!("Invalid read size on debug port: {}", data.len())
-        }
-    }
-
-    fn write(&mut self, _base: u64, _offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
-        if data.len() == 1 {
-            print!("{}", data[0] as char);
-        } else {
-            error!("Invalid write size on debug port: {}", data.len())
-        }
-
-        None
-    }
-}

devices/src/legacy/gpio_pl061.rs

@@ -1,454 +0,0 @@
-// Copyright 2021 Arm Limited (or its affiliates). All rights reserved.
-//
-// SPDX-License-Identifier: Apache-2.0
-
-//! ARM PrimeCell General Purpose Input/Output(PL061)
-//!
-//! This module implements an ARM PrimeCell General Purpose Input/Output(PL061) to support gracefully poweroff microvm from external.
-//!
-
-use crate::{read_le_u32, write_le_u32};
-use std::result;
-use std::sync::{Arc, Barrier};
-use std::{fmt, io};
-use vm_device::interrupt::InterruptSourceGroup;
-use vm_device::BusDevice;
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-
-const OFS_DATA: u64 = 0x400; // Data Register
-const GPIODIR: u64 = 0x400; // Direction Register
-const GPIOIS: u64 = 0x404; // Interrupt Sense Register
-const GPIOIBE: u64 = 0x408; // Interrupt Both Edges Register
-const GPIOIEV: u64 = 0x40c; // Interrupt Event Register
-const GPIOIE: u64 = 0x410; // Interrupt Mask Register
-const GPIORIE: u64 = 0x414; // Raw Interrupt Status Register
-const GPIOMIS: u64 = 0x418; // Masked Interrupt Status Register
-const GPIOIC: u64 = 0x41c; // Interrupt Clear Register
-const GPIOAFSEL: u64 = 0x420; // Mode Control Select Register
-                              // From 0x424 to 0xFDC => reserved space.
-                              // From 0xFE0 to 0xFFC => Peripheral and PrimeCell Identification Registers which are Read Only registers.
-                              // Thses registers can conceptually be treated as a 32-bit register, and PartNumber[11:0] is used to identify the peripheral.
-                              // We are putting the expected values (look at 'Reset value' column from above mentioned document) in an array.
-const GPIO_ID: [u8; 8] = [0x61, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1];
-// ID Margins
-const GPIO_ID_LOW: u64 = 0xfe0;
-const GPIO_ID_HIGH: u64 = 0x1000;
-
-const N_GPIOS: u32 = 8;
-
-#[derive(Debug)]
-pub enum Error {
-    BadWriteOffset(u64),
-    GpioInterruptDisabled,
-    GpioInterruptFailure(io::Error),
-    GpioTriggerKeyFailure(u32),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::BadWriteOffset(offset) => write!(f, "Bad Write Offset: {}", offset),
-            Error::GpioInterruptDisabled => write!(f, "GPIO interrupt disabled by guest driver.",),
-            Error::GpioInterruptFailure(ref e) => {
-                write!(f, "Could not trigger GPIO interrupt: {}.", e)
-            }
-            Error::GpioTriggerKeyFailure(key) => {
-                write!(f, "Invalid GPIO Input key triggerd: {}.", key)
-            }
-        }
-    }
-}
-
-type Result<T> = result::Result<T, Error>;
-
-/// A GPIO device following the PL061 specification.
-pub struct Gpio {
-    id: String,
-    // Data Register
-    data: u32,
-    old_in_data: u32,
-    // Direction Register
-    dir: u32,
-    // Interrupt Sense Register
-    isense: u32,
-    // Interrupt Both Edges Register
-    ibe: u32,
-    // Interrupt Event Register
-    iev: u32,
-    // Interrupt Mask Register
-    im: u32,
-    // Raw Interrupt Status Register
-    istate: u32,
-    // Mode Control Select Register
-    afsel: u32,
-    // GPIO irq_field
-    interrupt: Arc<Box<dyn InterruptSourceGroup>>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct GpioState {
-    data: u32,
-    old_in_data: u32,
-    dir: u32,
-    isense: u32,
-    ibe: u32,
-    iev: u32,
-    im: u32,
-    istate: u32,
-    afsel: u32,
-}
-
-impl Gpio {
-    /// Constructs an PL061 GPIO device.
-    pub fn new(id: String, interrupt: Arc<Box<dyn InterruptSourceGroup>>) -> Self {
-        Self {
-            id,
-            data: 0,
-            old_in_data: 0,
-            dir: 0,
-            isense: 0,
-            ibe: 0,
-            iev: 0,
-            im: 0,
-            istate: 0,
-            afsel: 0,
-            interrupt,
-        }
-    }
-
-    fn state(&self) -> GpioState {
-        GpioState {
-            data: self.data,
-            old_in_data: self.old_in_data,
-            dir: self.dir,
-            isense: self.isense,
-            ibe: self.ibe,
-            iev: self.iev,
-            im: self.im,
-            istate: self.istate,
-            afsel: self.afsel,
-        }
-    }
-
-    fn set_state(&mut self, state: &GpioState) {
-        self.data = state.data;
-        self.old_in_data = state.old_in_data;
-        self.dir = state.dir;
-        self.isense = state.isense;
-        self.ibe = state.ibe;
-        self.iev = state.iev;
-        self.im = state.im;
-        self.istate = state.istate;
-        self.afsel = state.afsel;
-    }
-
-    fn pl061_internal_update(&mut self) {
-        // FIXME:
-        //  Missing Output Interrupt Emulation.
-
-        // Input Edging Interrupt Emulation.
-        let changed = ((self.old_in_data ^ self.data) & !self.dir) as u32;
-        if changed > 0 {
-            self.old_in_data = self.data;
-            for i in 0..N_GPIOS {
-                let mask = (1 << i) as u32;
-                if (changed & mask) > 0 {
-                    // Bits set high in GPIOIS(Interrupt sense register) configure the corresponding
-                    // pins to detect levels, otherwise, detect edges.
-                    if (self.isense & mask) == 0 {
-                        if (self.ibe & mask) > 0 {
-                            // Bits set high in GPIOIBE(Interrupt both-edges register) configure the corresponding
-                            // pins to detect both falling and rising edges.
-                            // Clearing a bit configures the pin to be controlled by GPIOIEV.
-                            self.istate |= mask;
-                        } else {
-                            // Bits set to high in GPIOIEV(Interrupt event register) configure the
-                            // corresponding pin to detect rising edges, otherwise, detect falling edges.
-                            self.istate |= !(self.data ^ self.iev) & mask;
-                        }
-                    }
-                }
-            }
-        }
-
-        // Input Level Interrupt Emulation.
-        self.istate |= !(self.data ^ self.iev) & self.isense;
-    }
-
-    fn handle_write(&mut self, offset: u64, val: u32) -> Result<()> {
-        if offset < OFS_DATA {
-            // In order to write to data register, the corresponding bits in the mask, resulting
-            // from the offsite[9:2], must be HIGH. otherwise the bit values remain unchanged.
-            let mask = (offset >> 2) as u32 & self.dir;
-            self.data = (self.data & !mask) | (val & mask);
-        } else {
-            match offset {
-                GPIODIR => {
-                    /* Direction Register */
-                    self.dir = val & 0xff;
-                }
-                GPIOIS => {
-                    /* Interrupt Sense Register */
-                    self.isense = val & 0xff;
-                }
-                GPIOIBE => {
-                    /* Interrupt Both Edges Register */
-                    self.ibe = val & 0xff;
-                }
-                GPIOIEV => {
-                    /* Interrupt Event Register */
-                    self.iev = val & 0xff;
-                }
-                GPIOIE => {
-                    /* Interrupt Mask Register */
-                    self.im = val & 0xff;
-                }
-                GPIOIC => {
-                    /* Interrupt Clear Register */
-                    self.istate &= !val;
-                }
-                GPIOAFSEL => {
-                    /* Mode Control Select Register */
-                    self.afsel = val & 0xff;
-                }
-                o => {
-                    return Err(Error::BadWriteOffset(o));
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub fn trigger_key(&mut self, key: u32) -> Result<()> {
-        let mask = (1 << key) as u32;
-        if (!self.dir & mask) > 0 {
-            // emulate key event
-            // By default, Input Pin is configured to detect both rising and falling edges.
-            // So reverse the input pin data to generate a pulse.
-            self.data |= !(self.data & mask) & mask;
-            self.pl061_internal_update();
-
-            match self.trigger_gpio_interrupt() {
-                Ok(_) | Err(Error::GpioInterruptDisabled) => return Ok(()),
-                Err(e) => return Err(e),
-            }
-        }
-
-        Err(Error::GpioTriggerKeyFailure(key))
-    }
-
-    fn trigger_gpio_interrupt(&self) -> Result<()> {
-        // Bits set to high in GPIOIE(Interrupt mask register) allow the corresponding pins to
-        // trigger their individual interrupts and then the combined GPIOINTR line.
-        if (self.istate & self.im) == 0 {
-            warn!("Failed to trigger GPIO input interrupt (disabled by guest OS)");
-            return Err(Error::GpioInterruptDisabled);
-        }
-        self.interrupt
-            .trigger(0)
-            .map_err(Error::GpioInterruptFailure)?;
-        Ok(())
-    }
-}
-
-impl BusDevice for Gpio {
-    fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
-        let value;
-        let mut read_ok = true;
-
-        if (GPIO_ID_LOW..GPIO_ID_HIGH).contains(&offset) {
-            let index = ((offset - GPIO_ID_LOW) >> 2) as usize;
-            value = u32::from(GPIO_ID[index]);
-        } else if offset < OFS_DATA {
-            value = self.data & ((offset >> 2) as u32)
-        } else {
-            value = match offset {
-                GPIODIR => self.dir,
-                GPIOIS => self.isense,
-                GPIOIBE => self.ibe,
-                GPIOIEV => self.iev,
-                GPIOIE => self.im,
-                GPIORIE => self.istate,
-                GPIOMIS => self.istate & self.im,
-                GPIOAFSEL => self.afsel,
-                _ => {
-                    read_ok = false;
-                    0
-                }
-            };
-        }
-
-        if read_ok && data.len() <= 4 {
-            write_le_u32(data, value);
-        } else {
-            warn!(
-                "Invalid GPIO PL061 read: offset {}, data length {}",
-                offset,
-                data.len()
-            );
-        }
-    }
-
-    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
-        if data.len() <= 4 {
-            let value = read_le_u32(&data);
-            if let Err(e) = self.handle_write(offset, value) {
-                warn!("Failed to write to GPIO PL061 device: {}", e);
-            }
-        } else {
-            warn!(
-                "Invalid GPIO PL061 write: offset {}, data length {}",
-                offset,
-                data.len()
-            );
-        }
-
-        None
-    }
-}
-
-impl Snapshottable for Gpio {
-    fn id(&self) -> String {
-        self.id.clone()
-    }
-
-    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_state(&self.id, &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_state(&self.id)?);
-        Ok(())
-    }
-}
-
-impl Pausable for Gpio {}
-impl Transportable for Gpio {}
-impl Migratable for Gpio {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{read_le_u32, write_le_u32};
-    use std::sync::Arc;
-    use vm_device::interrupt::{InterruptIndex, InterruptSourceConfig};
-    use vmm_sys_util::eventfd::EventFd;
-
-    const GPIO_NAME: &str = "gpio";
-    const LEGACY_GPIO_MAPPED_IO_START: u64 = 0x0902_0000;
-
-    struct TestInterrupt {
-        event_fd: EventFd,
-    }
-
-    impl InterruptSourceGroup for TestInterrupt {
-        fn trigger(&self, _index: InterruptIndex) -> result::Result<(), std::io::Error> {
-            self.event_fd.write(1)
-        }
-
-        fn update(
-            &self,
-            _index: InterruptIndex,
-            _config: InterruptSourceConfig,
-        ) -> result::Result<(), std::io::Error> {
-            Ok(())
-        }
-
-        fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
-            Some(self.event_fd.try_clone().unwrap())
-        }
-    }
-
-    impl TestInterrupt {
-        fn new(event_fd: EventFd) -> Self {
-            TestInterrupt { event_fd }
-        }
-    }
-
-    #[test]
-    fn test_gpio_read_write_and_event() {
-        let intr_evt = EventFd::new(libc::EFD_NONBLOCK).unwrap();
-        let mut gpio = Gpio::new(
-            String::from(GPIO_NAME),
-            Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
-        );
-        let mut data = [0; 4];
-
-        // Read and write to the GPIODIR register.
-        // Set pin 0 output pin.
-        write_le_u32(&mut data, 1);
-        gpio.write(LEGACY_GPIO_MAPPED_IO_START, GPIODIR, &mut data);
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, GPIODIR, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 1);
-
-        // Read and write to the GPIODATA register.
-        write_le_u32(&mut data, 1);
-        // Set pin 0 high.
-        let offset = 0x00000004 as u64;
-        gpio.write(LEGACY_GPIO_MAPPED_IO_START, offset, &mut data);
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, offset, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 1);
-
-        // Read and write to the GPIOIS register.
-        // Configure pin 0 detecting level interrupt.
-        write_le_u32(&mut data, 1);
-        gpio.write(LEGACY_GPIO_MAPPED_IO_START, GPIOIS, &mut data);
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, GPIOIS, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 1);
-
-        // Read and write to the GPIOIBE register.
-        // Configure pin 1 detecting both falling and rising edges.
-        write_le_u32(&mut data, 2);
-        gpio.write(LEGACY_GPIO_MAPPED_IO_START, GPIOIBE, &mut data);
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, GPIOIBE, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 2);
-
-        // Read and write to the GPIOIEV register.
-        // Configure pin 2 detecting both falling and rising edges.
-        write_le_u32(&mut data, 4);
-        gpio.write(LEGACY_GPIO_MAPPED_IO_START, GPIOIEV, &mut data);
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, GPIOIEV, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 4);
-
-        // Read and write to the GPIOIE register.
-        // Configure pin 0...2 capable of triggering their individual interrupts
-        // and then the combined GPIOINTR line.
-        write_le_u32(&mut data, 7);
-        gpio.write(LEGACY_GPIO_MAPPED_IO_START, GPIOIE, &mut data);
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, GPIOIE, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 7);
-
-        let mask = 0x00000002 as u32;
-        // emulate an rising pulse in pin 1.
-        gpio.data |= !(gpio.data & mask) & mask;
-        gpio.pl061_internal_update();
-        // The interrupt line on pin 1 should be on.
-        // Read the GPIOMIS register.
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, GPIOMIS, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 2);
-
-        // Read and Write to the GPIOIC register.
-        // clear interrupt in pin 1.
-        write_le_u32(&mut data, 2);
-        gpio.write(LEGACY_GPIO_MAPPED_IO_START, GPIOIC, &mut data);
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, GPIOIC, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 2);
-
-        // Attempts to write beyond the writable space.
-        write_le_u32(&mut data, 0);
-        gpio.write(LEGACY_GPIO_MAPPED_IO_START, GPIO_ID_LOW, &mut data);
-
-        let mut data = [0; 4];
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, GPIO_ID_LOW, &mut data);
-        let index = GPIO_ID_LOW + 3;
-        assert_eq!(data[0], GPIO_ID[((index - GPIO_ID_LOW) >> 2) as usize]);
-    }
-}

devices/src/legacy/i8042.rs

@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
-use std::sync::{Arc, Barrier};
-use vm_device::BusDevice;
 use vmm_sys_util::eventfd::EventFd;
 
+use BusDevice;
+
 /// A i8042 PS/2 controller that emulates just enough to shutdown the machine.
 pub struct I8042Device {
     reset_evt: EventFd,
@@ -32,14 +32,12 @@ impl BusDevice for I8042Device {
         }
     }
 
-    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
+    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) {
         if data.len() == 1 && data[0] == 0xfe && offset == 3 {
             debug!("i8042 reset signalled");
             if let Err(e) = self.reset_evt.write(1) {
                 error!("Error triggering i8042 reset event: {}", e);
             }
         }
-
-        None
     }
 }

devices/src/legacy/mod.rs

@@ -7,29 +7,10 @@
 
 #[cfg(feature = "cmos")]
 mod cmos;
-#[cfg(feature = "fwdebug")]
-mod fwdebug;
-#[cfg(target_arch = "aarch64")]
-mod gpio_pl061;
 mod i8042;
-#[cfg(target_arch = "aarch64")]
-mod rtc_pl031;
 mod serial;
-#[cfg(target_arch = "aarch64")]
-mod uart_pl011;
 
 #[cfg(feature = "cmos")]
 pub use self::cmos::Cmos;
-#[cfg(feature = "fwdebug")]
-pub use self::fwdebug::FwDebugDevice;
 pub use self::i8042::I8042Device;
 pub use self::serial::Serial;
-
-#[cfg(target_arch = "aarch64")]
-pub use self::gpio_pl061::Error as GpioDeviceError;
-#[cfg(target_arch = "aarch64")]
-pub use self::gpio_pl061::Gpio;
-#[cfg(target_arch = "aarch64")]
-pub use self::rtc_pl031::Rtc;
-#[cfg(target_arch = "aarch64")]
-pub use self::uart_pl011::Pl011;

devices/src/legacy/rtc_pl031.rs

@@ -1,586 +0,0 @@
-// 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
-
-//! ARM PL031 Real Time Clock
-//!
-//! This module implements a PL031 Real Time Clock (RTC) that provides to provides long time base counter.
-//! This is achieved by generating an interrupt signal after counting for a programmed number of cycles of
-//! a real-time clock input.
-//!
-use crate::{read_le_u32, write_le_u32};
-use std::fmt;
-use std::sync::{Arc, Barrier};
-use std::time::Instant;
-use std::{io, result};
-use vm_device::interrupt::InterruptSourceGroup;
-use vm_device::BusDevice;
-
-// As you can see in https://static.docs.arm.com/ddi0224/c/real_time_clock_pl031_r1p3_technical_reference_manual_DDI0224C.pdf
-// at section 3.2 Summary of RTC registers, the total size occupied by this device is 0x000 -> 0xFFC + 4 = 0x1000.
-// From 0x0 to 0x1C we have following registers:
-const RTCDR: u64 = 0x0; // Data Register.
-const RTCMR: u64 = 0x4; // Match Register.
-const RTCLR: u64 = 0x8; // Load Register.
-const RTCCR: u64 = 0xc; // Control Register.
-const RTCIMSC: u64 = 0x10; // Interrupt Mask Set or Clear Register.
-const RTCRIS: u64 = 0x14; // Raw Interrupt Status.
-const RTCMIS: u64 = 0x18; // Masked Interrupt Status.
-const RTCICR: u64 = 0x1c; // Interrupt Clear Register.
-                          // From 0x020 to 0xFDC => reserved space.
-                          // From 0xFE0 to 0x1000 => Peripheral and PrimeCell Identification Registers which are Read Only registers.
-                          // AMBA standard devices have CIDs (Cell IDs) and PIDs (Peripheral IDs). The linux kernel will look for these in order to assert the identity
-                          // of these devices (i.e look at the `amba_device_try_add` function).
-                          // We are putting the expected values (look at 'Reset value' column from above mentioned document) in an array.
-const PL031_ID: [u8; 8] = [0x31, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1];
-// We are only interested in the margins.
-const AMBA_ID_LOW: u64 = 0xFE0;
-const AMBA_ID_HIGH: u64 = 0x1000;
-/// Constant to convert seconds to nanoseconds.
-pub const NANOS_PER_SECOND: u64 = 1_000_000_000;
-
-#[derive(Debug)]
-pub enum Error {
-    BadWriteOffset(u64),
-    InterruptFailure(io::Error),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::BadWriteOffset(offset) => write!(f, "Bad Write Offset: {}", offset),
-            Error::InterruptFailure(e) => write!(f, "Failed to trigger interrupt: {}", e),
-        }
-    }
-}
-
-type Result<T> = result::Result<T, Error>;
-
-/// Wrapper over `libc::clockid_t` to specify Linux Kernel clock source.
-pub enum ClockType {
-    /// Equivalent to `libc::CLOCK_MONOTONIC`.
-    Monotonic,
-    /// Equivalent to `libc::CLOCK_REALTIME`.
-    #[allow(dead_code)]
-    Real,
-    /// Equivalent to `libc::CLOCK_PROCESS_CPUTIME_ID`.
-    ProcessCpu,
-    /// Equivalent to `libc::CLOCK_THREAD_CPUTIME_ID`.
-    #[allow(dead_code)]
-    ThreadCpu,
-}
-
-impl From<ClockType> for libc::clockid_t {
-    fn from(ct: ClockType) -> libc::clockid_t {
-        match ct {
-            ClockType::Monotonic => libc::CLOCK_MONOTONIC,
-            ClockType::Real => libc::CLOCK_REALTIME,
-            ClockType::ProcessCpu => libc::CLOCK_PROCESS_CPUTIME_ID,
-            ClockType::ThreadCpu => libc::CLOCK_THREAD_CPUTIME_ID,
-        }
-    }
-}
-
-/// Structure representing the date in local time with nanosecond precision.
-pub struct LocalTime {
-    /// Seconds in current minute.
-    sec: i32,
-    /// Minutes in current hour.
-    min: i32,
-    /// Hours in current day, 24H format.
-    hour: i32,
-    /// Days in current month.
-    mday: i32,
-    /// Months in current year.
-    mon: i32,
-    /// Years passed since 1900 BC.
-    year: i32,
-    /// Nanoseconds in current second.
-    nsec: i64,
-}
-
-impl LocalTime {
-    /// Returns the [LocalTime](struct.LocalTime.html) structure for the calling moment.
-    #[allow(dead_code)]
-    pub fn now() -> LocalTime {
-        let mut timespec = libc::timespec {
-            tv_sec: 0,
-            tv_nsec: 0,
-        };
-        let mut tm: libc::tm = libc::tm {
-            tm_sec: 0,
-            tm_min: 0,
-            tm_hour: 0,
-            tm_mday: 0,
-            tm_mon: 0,
-            tm_year: 0,
-            tm_wday: 0,
-            tm_yday: 0,
-            tm_isdst: 0,
-            tm_gmtoff: 0,
-            tm_zone: std::ptr::null(),
-        };
-
-        // Safe because the parameters are valid.
-        unsafe {
-            libc::clock_gettime(libc::CLOCK_REALTIME, &mut timespec);
-            libc::localtime_r(&timespec.tv_sec, &mut tm);
-        }
-
-        LocalTime {
-            sec: tm.tm_sec,
-            min: tm.tm_min,
-            hour: tm.tm_hour,
-            mday: tm.tm_mday,
-            mon: tm.tm_mon,
-            year: tm.tm_year,
-            nsec: timespec.tv_nsec,
-        }
-    }
-}
-
-impl fmt::Display for LocalTime {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{}-{:02}-{:02}T{:02}:{:02}:{:02}.{:09}",
-            self.year + 1900,
-            self.mon + 1,
-            self.mday,
-            self.hour,
-            self.min,
-            self.sec,
-            self.nsec
-        )
-    }
-}
-
-/// Holds a micro-second resolution timestamp with both the real time and cpu time.
-#[derive(Clone)]
-pub struct TimestampUs {
-    /// Real time in microseconds.
-    pub time_us: u64,
-    /// Cpu time in microseconds.
-    pub cputime_us: u64,
-}
-
-impl Default for TimestampUs {
-    fn default() -> TimestampUs {
-        TimestampUs {
-            time_us: get_time(ClockType::Monotonic) / 1000,
-            cputime_us: get_time(ClockType::ProcessCpu) / 1000,
-        }
-    }
-}
-
-/// Returns a timestamp in nanoseconds from a monotonic clock.
-///
-/// Uses `_rdstc` on `x86_64` and [`get_time`](fn.get_time.html) on other architectures.
-#[allow(dead_code)]
-pub fn timestamp_cycles() -> u64 {
-    #[cfg(target_arch = "x86_64")]
-    // Safe because there's nothing that can go wrong with this call.
-    unsafe {
-        std::arch::x86_64::_rdtsc() as u64
-    }
-    #[cfg(not(target_arch = "x86_64"))]
-    {
-        get_time(ClockType::Monotonic)
-    }
-}
-
-/// Returns a timestamp in nanoseconds based on the provided clock type.
-///
-/// # Arguments
-///
-/// * `clock_type` - Identifier of the Linux Kernel clock on which to act.
-pub fn get_time(clock_type: ClockType) -> u64 {
-    let mut time_struct = libc::timespec {
-        tv_sec: 0,
-        tv_nsec: 0,
-    };
-    // Safe because the parameters are valid.
-    unsafe { libc::clock_gettime(clock_type.into(), &mut time_struct) };
-    seconds_to_nanoseconds(time_struct.tv_sec).unwrap() as u64 + (time_struct.tv_nsec as u64)
-}
-
-/// Converts a timestamp in seconds to an equivalent one in nanoseconds.
-/// Returns `None` if the conversion overflows.
-///
-/// # Arguments
-///
-/// * `value` - Timestamp in seconds.
-pub fn seconds_to_nanoseconds(value: i64) -> Option<i64> {
-    value.checked_mul(NANOS_PER_SECOND as i64)
-}
-
-/// A RTC device following the PL031 specification..
-pub struct Rtc {
-    previous_now: Instant,
-    tick_offset: i64,
-    // This is used for implementing the RTC alarm. However, in Firecracker we do not need it.
-    match_value: u32,
-    // Writes to this register load an update value into the RTC.
-    load: u32,
-    imsc: u32,
-    ris: u32,
-    interrupt: Arc<Box<dyn InterruptSourceGroup>>,
-}
-
-impl Rtc {
-    /// Constructs an AMBA PL031 RTC device.
-    pub fn new(interrupt: Arc<Box<dyn InterruptSourceGroup>>) -> Self {
-        Self {
-            // This is used only for duration measuring purposes.
-            previous_now: Instant::now(),
-            tick_offset: get_time(ClockType::Real) as i64,
-            match_value: 0,
-            load: 0,
-            imsc: 0,
-            ris: 0,
-            interrupt,
-        }
-    }
-
-    fn trigger_interrupt(&mut self) -> Result<()> {
-        self.interrupt.trigger(0).map_err(Error::InterruptFailure)?;
-        Ok(())
-    }
-
-    fn get_time(&self) -> u32 {
-        let ts = (self.tick_offset as i128)
-            + (Instant::now().duration_since(self.previous_now).as_nanos() as i128);
-        (ts / NANOS_PER_SECOND as i128) as u32
-    }
-
-    fn handle_write(&mut self, offset: u64, val: u32) -> Result<()> {
-        match offset {
-            RTCMR => {
-                // The MR register is used for implementing the RTC alarm. A real time clock alarm is
-                // a feature that can be used to allow a computer to 'wake up' after shut down to execute
-                // tasks every day or on a certain day. It can sometimes be found in the 'Power Management'
-                // section of a motherboard's BIOS setup. This is functionality that extends beyond
-                // Firecracker intended use. However, we increment a metric just in case.
-                self.match_value = val;
-            }
-            RTCLR => {
-                self.load = val;
-                self.previous_now = Instant::now();
-                // If the unwrap fails, then the internal value of the clock has been corrupted and
-                // we want to terminate the execution of the process.
-                self.tick_offset = seconds_to_nanoseconds(i64::from(val)).unwrap();
-            }
-            RTCIMSC => {
-                self.imsc = val & 1;
-                self.trigger_interrupt()?;
-            }
-            RTCICR => {
-                // As per above mentioned doc, the interrupt is cleared by writing any data value to
-                // the Interrupt Clear Register.
-                self.ris = 0;
-                self.trigger_interrupt()?;
-            }
-            RTCCR => (), // ignore attempts to turn off the timer.
-            o => {
-                return Err(Error::BadWriteOffset(o));
-            }
-        }
-        Ok(())
-    }
-}
-
-impl BusDevice for Rtc {
-    fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
-        let v;
-        let mut read_ok = true;
-
-        if (AMBA_ID_LOW..AMBA_ID_HIGH).contains(&offset) {
-            let index = ((offset - AMBA_ID_LOW) >> 2) as usize;
-            v = u32::from(PL031_ID[index]);
-        } else {
-            v = match offset {
-                RTCDR => self.get_time(),
-                RTCMR => {
-                    // Even though we are not implementing RTC alarm we return the last value
-                    self.match_value
-                }
-                RTCLR => self.load,
-                RTCCR => 1, // RTC is always enabled.
-                RTCIMSC => self.imsc,
-                RTCRIS => self.ris,
-                RTCMIS => self.ris & self.imsc,
-                _ => {
-                    read_ok = false;
-                    0
-                }
-            };
-        }
-        if read_ok && data.len() <= 4 {
-            write_le_u32(data, v);
-        } else {
-            warn!(
-                "Invalid RTC PL031 read: offset {}, data length {}",
-                offset,
-                data.len()
-            );
-        }
-    }
-
-    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
-        if data.len() <= 4 {
-            let v = read_le_u32(&data);
-            if let Err(e) = self.handle_write(offset, v) {
-                warn!("Failed to write to RTC PL031 device: {}", e);
-            }
-        } else {
-            warn!(
-                "Invalid RTC PL031 write: offset {}, data length {}",
-                offset,
-                data.len()
-            );
-        }
-
-        None
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{
-        read_be_u16, read_be_u32, read_le_i32, read_le_u16, read_le_u32, read_le_u64, write_be_u16,
-        write_be_u32, write_le_i32, write_le_u16, write_le_u32, write_le_u64,
-    };
-    use std::sync::Arc;
-    use vm_device::interrupt::{InterruptIndex, InterruptSourceConfig};
-    use vmm_sys_util::eventfd::EventFd;
-
-    const LEGACY_RTC_MAPPED_IO_START: u64 = 0x0901_0000;
-
-    #[test]
-    fn test_get_time() {
-        for _ in 0..1000 {
-            assert!(get_time(ClockType::Monotonic) <= get_time(ClockType::Monotonic));
-        }
-
-        for _ in 0..1000 {
-            assert!(get_time(ClockType::ProcessCpu) <= get_time(ClockType::ProcessCpu));
-        }
-
-        for _ in 0..1000 {
-            assert!(get_time(ClockType::ThreadCpu) <= get_time(ClockType::ThreadCpu));
-        }
-
-        assert_ne!(get_time(ClockType::Real), 0);
-    }
-
-    #[test]
-    fn test_local_time_display() {
-        let local_time = LocalTime {
-            sec: 30,
-            min: 15,
-            hour: 10,
-            mday: 4,
-            mon: 6,
-            year: 119,
-            nsec: 123_456_789,
-        };
-        assert_eq!(
-            String::from("2019-07-04T10:15:30.123456789"),
-            local_time.to_string()
-        );
-
-        let local_time = LocalTime {
-            sec: 5,
-            min: 5,
-            hour: 5,
-            mday: 23,
-            mon: 7,
-            year: 44,
-            nsec: 123,
-        };
-        assert_eq!(
-            String::from("1944-08-23T05:05:05.000000123"),
-            local_time.to_string()
-        );
-
-        let local_time = LocalTime::now();
-        assert!(local_time.mon >= 0 && local_time.mon <= 11);
-    }
-
-    #[test]
-    fn test_seconds_to_nanoseconds() {
-        assert_eq!(
-            seconds_to_nanoseconds(100).unwrap() as u64,
-            100 * NANOS_PER_SECOND
-        );
-
-        assert!(seconds_to_nanoseconds(9_223_372_037).is_none());
-    }
-
-    struct TestInterrupt {
-        event_fd: EventFd,
-    }
-
-    impl InterruptSourceGroup for TestInterrupt {
-        fn trigger(&self, _index: InterruptIndex) -> result::Result<(), std::io::Error> {
-            self.event_fd.write(1)
-        }
-
-        fn update(
-            &self,
-            _index: InterruptIndex,
-            _config: InterruptSourceConfig,
-        ) -> result::Result<(), std::io::Error> {
-            Ok(())
-        }
-
-        fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
-            Some(self.event_fd.try_clone().unwrap())
-        }
-    }
-
-    impl TestInterrupt {
-        fn new(event_fd: EventFd) -> Self {
-            TestInterrupt { event_fd }
-        }
-    }
-
-    #[test]
-    fn test_rtc_read_write_and_event() {
-        let intr_evt = EventFd::new(libc::EFD_NONBLOCK).unwrap();
-
-        let mut rtc = Rtc::new(Arc::new(Box::new(TestInterrupt::new(
-            intr_evt.try_clone().unwrap(),
-        ))));
-        let mut data = [0; 4];
-
-        // Read and write to the MR register.
-        write_le_u32(&mut data, 123);
-        rtc.write(LEGACY_RTC_MAPPED_IO_START, RTCMR, &mut data);
-        rtc.read(LEGACY_RTC_MAPPED_IO_START, RTCMR, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 123);
-
-        // Read and write to the LR register.
-        let v = get_time(ClockType::Real);
-        write_le_u32(&mut data, (v / NANOS_PER_SECOND) as u32);
-        let previous_now_before = rtc.previous_now;
-        rtc.write(LEGACY_RTC_MAPPED_IO_START, RTCLR, &mut data);
-
-        assert!(rtc.previous_now > previous_now_before);
-
-        rtc.read(LEGACY_RTC_MAPPED_IO_START, RTCLR, &mut data);
-        let v_read = read_le_u32(&data);
-        assert_eq!((v / NANOS_PER_SECOND) as u32, v_read);
-
-        // Read and write to IMSC register.
-        // Test with non zero value.
-        let non_zero = 1;
-        write_le_u32(&mut data, non_zero);
-        rtc.write(LEGACY_RTC_MAPPED_IO_START, RTCIMSC, &mut data);
-        // The interrupt line should be on.
-        assert!(rtc.interrupt.notifier(0).unwrap().read().unwrap() == 1);
-        rtc.read(LEGACY_RTC_MAPPED_IO_START, RTCIMSC, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(non_zero & 1, v);
-
-        // Now test with 0.
-        write_le_u32(&mut data, 0);
-        rtc.write(LEGACY_RTC_MAPPED_IO_START, RTCIMSC, &mut data);
-        rtc.read(LEGACY_RTC_MAPPED_IO_START, RTCIMSC, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(0, v);
-
-        // Read and write to the ICR register.
-        write_le_u32(&mut data, 1);
-        rtc.write(LEGACY_RTC_MAPPED_IO_START, RTCICR, &mut data);
-        // The interrupt line should be on.
-        assert!(rtc.interrupt.notifier(0).unwrap().read().unwrap() > 1);
-        let v_before = read_le_u32(&data);
-
-        rtc.read(LEGACY_RTC_MAPPED_IO_START, RTCICR, &mut data);
-        let v = read_le_u32(&data);
-        // ICR is a  write only register. Data received should stay equal to data sent.
-        assert_eq!(v, v_before);
-
-        // Attempts to turn off the RTC should not go through.
-        write_le_u32(&mut data, 0);
-        rtc.write(LEGACY_RTC_MAPPED_IO_START, RTCCR, &mut data);
-        rtc.read(LEGACY_RTC_MAPPED_IO_START, RTCCR, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 1);
-
-        // Attempts to write beyond the writable space. Using here the space used to read
-        // the CID and PID from.
-        write_le_u32(&mut data, 0);
-        rtc.write(LEGACY_RTC_MAPPED_IO_START, AMBA_ID_LOW, &mut data);
-        // However, reading from the AMBA_ID_LOW should succeed upon read.
-
-        let mut data = [0; 4];
-        rtc.read(LEGACY_RTC_MAPPED_IO_START, AMBA_ID_LOW, &mut data);
-        let index = AMBA_ID_LOW + 3;
-        assert_eq!(data[0], PL031_ID[((index - AMBA_ID_LOW) >> 2) as usize]);
-    }
-
-    macro_rules! byte_order_test_read_write {
-        ($test_name: ident, $write_fn_name: ident, $read_fn_name: ident, $is_be: expr, $data_type: ty) => {
-            #[test]
-            fn $test_name() {
-                #[allow(overflowing_literals)]
-                let test_cases = [
-                    (
-                        0x0123_4567_89AB_CDEF as u64,
-                        [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef],
-                    ),
-                    (
-                        0x0000_0000_0000_0000 as u64,
-                        [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
-                    ),
-                    (
-                        0x1923_2345_ABF3_CCD4 as u64,
-                        [0x19, 0x23, 0x23, 0x45, 0xAB, 0xF3, 0xCC, 0xD4],
-                    ),
-                    (
-                        0x0FF0_0FF0_0FF0_0FF0 as u64,
-                        [0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0],
-                    ),
-                    (
-                        0xFFFF_FFFF_FFFF_FFFF as u64,
-                        [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
-                    ),
-                    (
-                        0x89AB_12D4_C2D2_09BB as u64,
-                        [0x89, 0xAB, 0x12, 0xD4, 0xC2, 0xD2, 0x09, 0xBB],
-                    ),
-                ];
-
-                let type_size = std::mem::size_of::<$data_type>();
-                for (test_val, v_arr) in &test_cases {
-                    let v = *test_val as $data_type;
-                    let cmp_iter: Box<dyn Iterator<Item = _>> = if $is_be {
-                        Box::new(v_arr[(8 - type_size)..].iter())
-                    } else {
-                        Box::new(v_arr.iter().rev())
-                    };
-                    // test write
-                    let mut write_arr = vec![Default::default(); type_size];
-                    $write_fn_name(&mut write_arr, v);
-                    for (cmp, cur) in cmp_iter.zip(write_arr.iter()) {
-                        assert_eq!(*cmp, *cur as u8)
-                    }
-                    // test read
-                    let read_val = $read_fn_name(&write_arr);
-                    assert_eq!(v, read_val);
-                }
-            }
-        };
-    }
-
-    byte_order_test_read_write!(test_le_u16, write_le_u16, read_le_u16, false, u16);
-    byte_order_test_read_write!(test_le_u32, write_le_u32, read_le_u32, false, u32);
-    byte_order_test_read_write!(test_le_u64, write_le_u64, read_le_u64, false, u64);
-    byte_order_test_read_write!(test_le_i32, write_le_i32, read_le_i32, false, i32);
-    byte_order_test_read_write!(test_be_u16, write_be_u16, read_be_u16, true, u16);
-    byte_order_test_read_write!(test_be_u32, write_be_u32, read_be_u32, true, u32);
-}

devices/src/legacy/serial.rs

@@ -5,12 +5,11 @@
 // 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::BusDevice;
 use std::collections::VecDeque;
-use std::sync::{Arc, Barrier};
+use std::sync::Arc;
 use std::{io, result};
 use vm_device::interrupt::InterruptSourceGroup;
-use vm_device::BusDevice;
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
 use vmm_sys_util::errno::Result;
 
 const LOOP_SIZE: usize = 0x40;
@@ -56,7 +55,6 @@ const DEFAULT_BAUD_DIVISOR: u16 = 12; // 9600 bps
 /// This can optionally write the guest's output to a Write trait object. To send input to the
 /// guest, use `queue_input_bytes`.
 pub struct Serial {
-    id: String,
     interrupt_enable: u8,
     interrupt_identification: u8,
     interrupt: Arc<Box<dyn InterruptSourceGroup>>,
@@ -70,27 +68,12 @@ pub struct Serial {
     out: Option<Box<dyn io::Write + Send>>,
 }
 
-#[derive(Serialize, Deserialize)]
-pub struct SerialState {
-    interrupt_enable: u8,
-    interrupt_identification: u8,
-    line_control: u8,
-    line_status: u8,
-    modem_control: u8,
-    modem_status: u8,
-    scratch: u8,
-    baud_divisor: u16,
-    in_buffer: Vec<u8>,
-}
-
 impl Serial {
     pub fn new(
-        id: String,
         interrupt: Arc<Box<dyn InterruptSourceGroup>>,
         out: Option<Box<dyn io::Write + Send>>,
     ) -> Serial {
         Serial {
-            id,
             interrupt_enable: 0,
             interrupt_identification: DEFAULT_INTERRUPT_IDENTIFICATION,
             interrupt,
@@ -107,16 +90,15 @@ impl Serial {
 
     /// Constructs a Serial port ready for output.
     pub fn new_out(
-        id: String,
         interrupt: Arc<Box<dyn InterruptSourceGroup>>,
         out: Box<dyn io::Write + Send>,
     ) -> Serial {
-        Self::new(id, interrupt, Some(out))
+        Self::new(interrupt, Some(out))
     }
 
     /// Constructs a Serial port with no connected output.
-    pub fn new_sink(id: String, interrupt: Arc<Box<dyn InterruptSourceGroup>>) -> Serial {
-        Self::new(id, interrupt, None)
+    pub fn new_sink(interrupt: Arc<Box<dyn InterruptSourceGroup>>) -> Serial {
+        Self::new(interrupt, None)
     }
 
     /// Queues raw bytes for the guest to read and signals the interrupt if the line status would
@@ -212,32 +194,6 @@ impl Serial {
         }
         Ok(())
     }
-
-    fn state(&self) -> SerialState {
-        SerialState {
-            interrupt_enable: self.interrupt_enable,
-            interrupt_identification: self.interrupt_identification,
-            line_control: self.line_control,
-            line_status: self.line_status,
-            modem_control: self.modem_control,
-            modem_status: self.modem_status,
-            scratch: self.scratch,
-            baud_divisor: self.baud_divisor,
-            in_buffer: self.in_buffer.clone().into(),
-        }
-    }
-
-    fn set_state(&mut self, state: &SerialState) {
-        self.interrupt_enable = state.interrupt_enable;
-        self.interrupt_identification = state.interrupt_identification;
-        self.line_control = state.line_control;
-        self.line_status = state.line_status;
-        self.modem_control = state.modem_control;
-        self.modem_status = state.modem_status;
-        self.scratch = state.scratch;
-        self.baud_divisor = state.baud_divisor;
-        self.in_buffer = state.in_buffer.clone().into();
-    }
 }
 
 impl BusDevice for Serial {
@@ -271,36 +227,15 @@ impl BusDevice for Serial {
         };
     }
 
-    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
+    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) {
         if data.len() != 1 {
-            return None;
+            return;
         }
 
-        self.handle_write(offset as u8, data[0]).ok();
-
-        None
+        if let Err(_e) = self.handle_write(offset as u8, data[0]) {}
     }
 }
 
-impl Snapshottable for Serial {
-    fn id(&self) -> String {
-        self.id.clone()
-    }
-
-    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_state(&self.id, &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_state(&self.id)?);
-        Ok(())
-    }
-}
-
-impl Pausable for Serial {}
-impl Transportable for Serial {}
-impl Migratable for Serial {}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -309,8 +244,6 @@ mod tests {
     use vm_device::interrupt::{InterruptIndex, InterruptSourceConfig};
     use vmm_sys_util::eventfd::EventFd;
 
-    const SERIAL_NAME: &str = "serial";
-
     struct TestInterrupt {
         event_fd: EventFd,
     }
@@ -326,9 +259,6 @@ mod tests {
         ) -> result::Result<(), std::io::Error> {
             Ok(())
         }
-        fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
-            Some(self.event_fd.try_clone().unwrap())
-        }
     }
 
     impl TestInterrupt {
@@ -364,18 +294,17 @@ mod tests {
         let intr_evt = EventFd::new(0).unwrap();
         let serial_out = SharedBuffer::new();
         let mut serial = Serial::new_out(
-            String::from(SERIAL_NAME),
             Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
             Box::new(serial_out.clone()),
         );
 
-        serial.write(0, DATA as u64, &[b'x', b'y']);
-        serial.write(0, DATA as u64, &[b'a']);
-        serial.write(0, DATA as u64, &[b'b']);
-        serial.write(0, DATA as u64, &[b'c']);
+        serial.write(0, DATA as u64, &['x' as u8, 'y' as u8]);
+        serial.write(0, DATA as u64, &['a' as u8]);
+        serial.write(0, DATA as u64, &['b' as u8]);
+        serial.write(0, DATA as u64, &['c' as u8]);
         assert_eq!(
             serial_out.buf.lock().unwrap().as_slice(),
-            &[b'a', b'b', b'c']
+            &['a' as u8, 'b' as u8, 'c' as u8]
         );
     }
 
@@ -384,16 +313,17 @@ mod tests {
         let intr_evt = EventFd::new(0).unwrap();
         let serial_out = SharedBuffer::new();
         let mut serial = Serial::new_out(
-            String::from(SERIAL_NAME),
             Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
-            Box::new(serial_out),
+            Box::new(serial_out.clone()),
         );
 
         // write 1 to the interrupt event fd, so that read doesn't block in case the event fd
         // counter doesn't change (for 0 it blocks)
         assert!(intr_evt.write(1).is_ok());
         serial.write(0, IER as u64, &[IER_RECV_BIT]);
-        serial.queue_input_bytes(&[b'a', b'b', b'c']).unwrap();
+        serial
+            .queue_input_bytes(&['a' as u8, 'b' as u8, 'c' as u8])
+            .unwrap();
 
         assert_eq!(intr_evt.read().unwrap(), 2);
 
@@ -406,11 +336,11 @@ mod tests {
         serial.read(0, LSR as u64, &mut data[..]);
         assert_ne!(data[0] & LSR_DATA_BIT, 0);
         serial.read(0, DATA as u64, &mut data[..]);
-        assert_eq!(data[0], b'a');
+        assert_eq!(data[0], 'a' as u8);
         serial.read(0, DATA as u64, &mut data[..]);
-        assert_eq!(data[0], b'b');
+        assert_eq!(data[0], 'b' as u8);
         serial.read(0, DATA as u64, &mut data[..]);
-        assert_eq!(data[0], b'c');
+        assert_eq!(data[0], 'c' as u8);
 
         // check if reading from the largest u8 offset returns 0
         serial.read(0, 0xff, &mut data[..]);
@@ -420,16 +350,15 @@ mod tests {
     #[test]
     fn serial_thr() {
         let intr_evt = EventFd::new(0).unwrap();
-        let mut serial = Serial::new_sink(
-            String::from(SERIAL_NAME),
-            Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
-        );
+        let mut serial = Serial::new_sink(Arc::new(Box::new(TestInterrupt::new(
+            intr_evt.try_clone().unwrap(),
+        ))));
 
         // write 1 to the interrupt event fd, so that read doesn't block in case the event fd
         // counter doesn't change (for 0 it blocks)
         assert!(intr_evt.write(1).is_ok());
         serial.write(0, IER as u64, &[IER_THR_BIT]);
-        serial.write(0, DATA as u64, &[b'a']);
+        serial.write(0, DATA as u64, &['a' as u8]);
 
         assert_eq!(intr_evt.read().unwrap(), 2);
         let mut data = [0u8];
@@ -442,18 +371,17 @@ mod tests {
     #[test]
     fn serial_dlab() {
         let intr_evt = EventFd::new(0).unwrap();
-        let mut serial = Serial::new_sink(
-            String::from(SERIAL_NAME),
-            Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
-        );
+        let mut serial = Serial::new_sink(Arc::new(Box::new(TestInterrupt::new(
+            intr_evt.try_clone().unwrap(),
+        ))));
 
-        serial.write(0, LCR as u64, &[LCR_DLAB_BIT]);
-        serial.write(0, DLAB_LOW as u64, &[0x12]);
-        serial.write(0, DLAB_HIGH as u64, &[0x34]);
+        serial.write(0, LCR as u64, &[LCR_DLAB_BIT as u8]);
+        serial.write(0, DLAB_LOW as u64, &[0x12 as u8]);
+        serial.write(0, DLAB_HIGH as u64, &[0x34 as u8]);
 
         let mut data = [0u8];
         serial.read(0, LCR as u64, &mut data[..]);
-        assert_eq!(data[0], LCR_DLAB_BIT);
+        assert_eq!(data[0], LCR_DLAB_BIT as u8);
         serial.read(0, DLAB_LOW as u64, &mut data[..]);
         assert_eq!(data[0], 0x12);
         serial.read(0, DLAB_HIGH as u64, &mut data[..]);
@@ -463,41 +391,39 @@ mod tests {
     #[test]
     fn serial_modem() {
         let intr_evt = EventFd::new(0).unwrap();
-        let mut serial = Serial::new_sink(
-            String::from(SERIAL_NAME),
-            Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
-        );
+        let mut serial = Serial::new_sink(Arc::new(Box::new(TestInterrupt::new(
+            intr_evt.try_clone().unwrap(),
+        ))));
 
-        serial.write(0, MCR as u64, &[MCR_LOOP_BIT]);
-        serial.write(0, DATA as u64, &[b'a']);
-        serial.write(0, DATA as u64, &[b'b']);
-        serial.write(0, DATA as u64, &[b'c']);
+        serial.write(0, MCR as u64, &[MCR_LOOP_BIT as u8]);
+        serial.write(0, DATA as u64, &['a' as u8]);
+        serial.write(0, DATA as u64, &['b' as u8]);
+        serial.write(0, DATA as u64, &['c' as u8]);
 
         let mut data = [0u8];
         serial.read(0, MSR as u64, &mut data[..]);
-        assert_eq!(data[0], DEFAULT_MODEM_STATUS);
+        assert_eq!(data[0], DEFAULT_MODEM_STATUS as u8);
         serial.read(0, MCR as u64, &mut data[..]);
-        assert_eq!(data[0], MCR_LOOP_BIT);
+        assert_eq!(data[0], MCR_LOOP_BIT as u8);
         serial.read(0, DATA as u64, &mut data[..]);
-        assert_eq!(data[0], b'a');
+        assert_eq!(data[0], 'a' as u8);
         serial.read(0, DATA as u64, &mut data[..]);
-        assert_eq!(data[0], b'b');
+        assert_eq!(data[0], 'b' as u8);
         serial.read(0, DATA as u64, &mut data[..]);
-        assert_eq!(data[0], b'c');
+        assert_eq!(data[0], 'c' as u8);
     }
 
     #[test]
     fn serial_scratch() {
         let intr_evt = EventFd::new(0).unwrap();
-        let mut serial = Serial::new_sink(
-            String::from(SERIAL_NAME),
-            Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
-        );
+        let mut serial = Serial::new_sink(Arc::new(Box::new(TestInterrupt::new(
+            intr_evt.try_clone().unwrap(),
+        ))));
 
-        serial.write(0, SCR as u64, &[0x12]);
+        serial.write(0, SCR as u64, &[0x12 as u8]);
 
         let mut data = [0u8];
         serial.read(0, SCR as u64, &mut data[..]);
-        assert_eq!(data[0], 0x12);
+        assert_eq!(data[0], 0x12 as u8);
     }
 }

devices/src/legacy/uart_pl011.rs

@@ -1,476 +0,0 @@
-// Copyright 2021 Arm Limited (or its affiliates). All rights reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-//! ARM PrimeCell UART(PL011)
-//!
-//! This module implements an ARM PrimeCell UART(PL011).
-//!
-
-use crate::{read_le_u32, write_le_u32};
-use std::collections::VecDeque;
-use std::fmt;
-use std::sync::{Arc, Barrier};
-use std::{io, result};
-use vm_device::interrupt::InterruptSourceGroup;
-use vm_device::BusDevice;
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-
-/* Registers */
-const UARTDR: u64 = 0;
-const UARTRSR_UARTECR: u64 = 1;
-const UARTFR: u64 = 6;
-const UARTILPR: u64 = 8;
-const UARTIBRD: u64 = 9;
-const UARTFBRD: u64 = 10;
-const UARTLCR_H: u64 = 11;
-const UARTCR: u64 = 12;
-const UARTIFLS: u64 = 13;
-const UARTIMSC: u64 = 14;
-const UARTRIS: u64 = 15;
-const UARTMIS: u64 = 16;
-const UARTICR: u64 = 17;
-const UARTDMACR: u64 = 18;
-
-const PL011_INT_TX: u32 = 0x20;
-const PL011_INT_RX: u32 = 0x10;
-
-const PL011_FLAG_RXFF: u32 = 0x40;
-const PL011_FLAG_RXFE: u32 = 0x10;
-
-const PL011_ID: [u8; 8] = [0x11, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1];
-// We are only interested in the margins.
-const AMBA_ID_LOW: u64 = 0x3f8;
-const AMBA_ID_HIGH: u64 = 0x401;
-
-#[derive(Debug)]
-pub enum Error {
-    BadWriteOffset(u64),
-    DmaNotImplemented,
-    InterruptFailure(io::Error),
-    WriteAllFailure(io::Error),
-    FlushFailure(io::Error),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::BadWriteOffset(offset) => write!(f, "pl011_write: Bad Write Offset: {}", offset),
-            Error::DmaNotImplemented => write!(f, "pl011: DMA not implemented."),
-            Error::InterruptFailure(e) => write!(f, "Failed to trigger interrupt: {}", e),
-            Error::WriteAllFailure(e) => write!(f, "Failed to write: {}", e),
-            Error::FlushFailure(e) => write!(f, "Failed to flush: {}", e),
-        }
-    }
-}
-
-type Result<T> = result::Result<T, Error>;
-
-/// A PL011 device following the PL011 specification.
-pub struct Pl011 {
-    id: String,
-    flags: u32,
-    lcr: u32,
-    rsr: u32,
-    cr: u32,
-    dmacr: u32,
-    int_enabled: u32,
-    int_level: u32,
-    read_fifo: VecDeque<u8>,
-    ilpr: u32,
-    ibrd: u32,
-    fbrd: u32,
-    ifl: u32,
-    read_count: u32,
-    read_trigger: u32,
-    irq: Arc<Box<dyn InterruptSourceGroup>>,
-    out: Option<Box<dyn io::Write + Send>>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Pl011State {
-    flags: u32,
-    lcr: u32,
-    rsr: u32,
-    cr: u32,
-    dmacr: u32,
-    int_enabled: u32,
-    int_level: u32,
-    read_fifo: Vec<u8>,
-    ilpr: u32,
-    ibrd: u32,
-    fbrd: u32,
-    ifl: u32,
-    read_count: u32,
-    read_trigger: u32,
-}
-
-impl Pl011 {
-    /// Constructs an AMBA PL011 UART device.
-    pub fn new(
-        id: String,
-        irq: Arc<Box<dyn InterruptSourceGroup>>,
-        out: Option<Box<dyn io::Write + Send>>,
-    ) -> Self {
-        Self {
-            id,
-            flags: 0x90u32,
-            lcr: 0u32,
-            rsr: 0u32,
-            cr: 0x300u32,
-            dmacr: 0u32,
-            int_enabled: 0u32,
-            int_level: 0u32,
-            read_fifo: VecDeque::new(),
-            ilpr: 0u32,
-            ibrd: 0u32,
-            fbrd: 0u32,
-            ifl: 0x12u32,
-            read_count: 0u32,
-            read_trigger: 1u32,
-            irq,
-            out,
-        }
-    }
-
-    fn state(&self) -> Pl011State {
-        Pl011State {
-            flags: self.flags,
-            lcr: self.lcr,
-            rsr: self.rsr,
-            cr: self.cr,
-            dmacr: self.dmacr,
-            int_enabled: self.int_enabled,
-            int_level: self.int_level,
-            read_fifo: self.read_fifo.clone().into(),
-            ilpr: self.ilpr,
-            ibrd: self.ibrd,
-            fbrd: self.fbrd,
-            ifl: self.ifl,
-            read_count: self.read_count,
-            read_trigger: self.read_trigger,
-        }
-    }
-
-    fn set_state(&mut self, state: &Pl011State) {
-        self.flags = state.flags;
-        self.lcr = state.lcr;
-        self.rsr = state.rsr;
-        self.cr = state.cr;
-        self.dmacr = state.dmacr;
-        self.int_enabled = state.int_enabled;
-        self.int_level = state.int_level;
-        self.read_fifo = state.read_fifo.clone().into();
-        self.ilpr = state.ilpr;
-        self.ibrd = state.ibrd;
-        self.fbrd = state.fbrd;
-        self.ifl = state.ifl;
-        self.read_count = state.read_count;
-        self.read_trigger = state.read_trigger;
-    }
-
-    /// Queues raw bytes for the guest to read and signals the interrupt
-    pub fn queue_input_bytes(&mut self, c: &[u8]) -> vmm_sys_util::errno::Result<()> {
-        self.read_fifo.extend(c);
-        self.read_count += c.len() as u32;
-        self.flags &= !PL011_FLAG_RXFE;
-
-        if ((self.lcr & 0x10) == 0) || (self.read_count == 16) {
-            self.flags |= PL011_FLAG_RXFF;
-        }
-
-        if self.read_count >= self.read_trigger {
-            self.int_level |= PL011_INT_RX;
-            self.trigger_interrupt()?;
-        }
-
-        Ok(())
-    }
-
-    fn pl011_get_baudrate(&self) -> u32 {
-        if self.fbrd == 0 {
-            return 0;
-        }
-
-        let clk = 24_000_000; // We set the APB_PLCK to 24M in device tree
-        (clk / ((self.ibrd << 6) + self.fbrd)) << 2
-    }
-
-    fn pl011_trace_baudrate_change(&self) {
-        debug!(
-            "=== New baudrate: {:#?} (clk: {:#?}Hz, ibrd: {:#?}, fbrd: {:#?}) ===",
-            self.pl011_get_baudrate(),
-            24_000_000, // We set the APB_PLCK to 24M in device tree
-            self.ibrd,
-            self.fbrd
-        );
-    }
-
-    fn pl011_set_read_trigger(&mut self) {
-        self.read_trigger = 1;
-    }
-
-    fn handle_write(&mut self, offset: u64, val: u32) -> Result<()> {
-        match offset >> 2 {
-            UARTDR => {
-                self.int_level |= PL011_INT_TX;
-                if let Some(out) = self.out.as_mut() {
-                    out.write_all(&[val.to_le_bytes()[0]])
-                        .map_err(Error::WriteAllFailure)?;
-                    out.flush().map_err(Error::FlushFailure)?;
-                }
-            }
-            UARTRSR_UARTECR => {
-                self.rsr = 0;
-            }
-            UARTFR => { /* Writes to Flag register are ignored.*/ }
-            UARTILPR => {
-                self.ilpr = val;
-            }
-            UARTIBRD => {
-                self.ibrd = val;
-                self.pl011_trace_baudrate_change();
-            }
-            UARTFBRD => {
-                self.fbrd = val;
-                self.pl011_trace_baudrate_change();
-            }
-            UARTLCR_H => {
-                /* Reset the FIFO state on FIFO enable or disable */
-                if ((self.lcr ^ val) & 0x10) != 0 {
-                    self.read_count = 0;
-                }
-                self.lcr = val;
-                self.pl011_set_read_trigger();
-            }
-            UARTCR => {
-                self.cr = val;
-            }
-            UARTIFLS => {
-                self.ifl = val;
-                self.pl011_set_read_trigger();
-            }
-            UARTIMSC => {
-                self.int_enabled = val;
-                self.trigger_interrupt().map_err(Error::InterruptFailure)?;
-            }
-            UARTICR => {
-                self.int_level &= !val;
-                self.trigger_interrupt().map_err(Error::InterruptFailure)?;
-            }
-            UARTDMACR => {
-                self.dmacr = val;
-                if (val & 3) != 0 {
-                    return Err(Error::DmaNotImplemented);
-                }
-            }
-            off => {
-                return Err(Error::BadWriteOffset(off));
-            }
-        }
-        Ok(())
-    }
-
-    fn trigger_interrupt(&mut self) -> result::Result<(), io::Error> {
-        self.irq.trigger(0)
-    }
-}
-
-impl BusDevice for Pl011 {
-    fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
-        let v;
-        let mut read_ok = true;
-        if (AMBA_ID_LOW..AMBA_ID_HIGH).contains(&(offset >> 2)) {
-            let index = ((offset - 0xfe0) >> 2) as usize;
-            v = u32::from(PL011_ID[index]);
-        } else {
-            v = match offset >> 2 {
-                UARTDR => {
-                    let c: u32;
-                    let r: u32;
-
-                    self.flags &= !PL011_FLAG_RXFF;
-                    c = self.read_fifo.pop_front().unwrap_or_default().into();
-                    if self.read_count > 0 {
-                        self.read_count -= 1;
-                    }
-                    if self.read_count == 0 {
-                        self.flags |= PL011_FLAG_RXFE;
-                    }
-                    if self.read_count == (self.read_trigger - 1) {
-                        self.int_level &= !PL011_INT_RX;
-                    }
-                    self.rsr = c >> 8;
-                    r = c;
-                    r
-                }
-                UARTRSR_UARTECR => self.rsr,
-                UARTFR => self.flags,
-                UARTILPR => self.ilpr,
-                UARTIBRD => self.ibrd,
-                UARTFBRD => self.fbrd,
-                UARTLCR_H => self.lcr,
-                UARTCR => self.cr,
-                UARTIFLS => self.ifl,
-                UARTIMSC => self.int_enabled,
-                UARTRIS => self.int_level,
-                UARTMIS => (self.int_level & self.int_enabled),
-                UARTDMACR => self.dmacr,
-                _ => {
-                    read_ok = false;
-                    0
-                }
-            }
-        }
-
-        if read_ok && data.len() <= 4 {
-            write_le_u32(data, v);
-        } else {
-            warn!(
-                "Invalid PL011 read: offset {}, data length {}",
-                offset,
-                data.len()
-            );
-        }
-    }
-
-    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
-        if data.len() <= 4 {
-            let v = read_le_u32(&data);
-            if let Err(e) = self.handle_write(offset, v) {
-                warn!("Failed to write to PL011 device: {}", e);
-            }
-        } else {
-            warn!(
-                "Invalid PL011 write: offset {}, data length {}",
-                offset,
-                data.len()
-            );
-        }
-
-        None
-    }
-}
-
-impl Snapshottable for Pl011 {
-    fn id(&self) -> String {
-        self.id.clone()
-    }
-
-    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        Snapshot::new_from_state(&self.id, &self.state())
-    }
-
-    fn restore(&mut self, snapshot: Snapshot) -> std::result::Result<(), MigratableError> {
-        self.set_state(&snapshot.to_state(&self.id)?);
-        Ok(())
-    }
-}
-
-impl Pausable for Pl011 {}
-impl Transportable for Pl011 {}
-impl Migratable for Pl011 {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::io;
-    use std::sync::{Arc, Mutex};
-    use vm_device::interrupt::{InterruptIndex, InterruptSourceConfig};
-    use vmm_sys_util::eventfd::EventFd;
-
-    const SERIAL_NAME: &str = "serial";
-
-    struct TestInterrupt {
-        event_fd: EventFd,
-    }
-
-    impl InterruptSourceGroup for TestInterrupt {
-        fn trigger(&self, _index: InterruptIndex) -> result::Result<(), std::io::Error> {
-            self.event_fd.write(1)
-        }
-        fn update(
-            &self,
-            _index: InterruptIndex,
-            _config: InterruptSourceConfig,
-        ) -> result::Result<(), std::io::Error> {
-            Ok(())
-        }
-        fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
-            Some(self.event_fd.try_clone().unwrap())
-        }
-    }
-
-    impl TestInterrupt {
-        fn new(event_fd: EventFd) -> Self {
-            TestInterrupt { event_fd }
-        }
-    }
-
-    #[derive(Clone)]
-    struct SharedBuffer {
-        buf: Arc<Mutex<Vec<u8>>>,
-    }
-
-    impl SharedBuffer {
-        fn new() -> SharedBuffer {
-            SharedBuffer {
-                buf: Arc::new(Mutex::new(Vec::new())),
-            }
-        }
-    }
-
-    impl io::Write for SharedBuffer {
-        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-            self.buf.lock().unwrap().write(buf)
-        }
-        fn flush(&mut self) -> io::Result<()> {
-            self.buf.lock().unwrap().flush()
-        }
-    }
-
-    #[test]
-    fn pl011_output() {
-        let intr_evt = EventFd::new(0).unwrap();
-        let pl011_out = SharedBuffer::new();
-        let mut pl011 = Pl011::new(
-            String::from(SERIAL_NAME),
-            Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
-            Some(Box::new(pl011_out.clone())),
-        );
-
-        pl011.write(0, UARTDR as u64, &[b'x', b'y']);
-        pl011.write(0, UARTDR as u64, &[b'a']);
-        pl011.write(0, UARTDR as u64, &[b'b']);
-        pl011.write(0, UARTDR as u64, &[b'c']);
-        assert_eq!(
-            pl011_out.buf.lock().unwrap().as_slice(),
-            &[b'x', b'a', b'b', b'c']
-        );
-    }
-
-    #[test]
-    fn pl011_input() {
-        let intr_evt = EventFd::new(0).unwrap();
-        let pl011_out = SharedBuffer::new();
-        let mut pl011 = Pl011::new(
-            String::from(SERIAL_NAME),
-            Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
-            Some(Box::new(pl011_out)),
-        );
-
-        // write 1 to the interrupt event fd, so that read doesn't block in case the event fd
-        // counter doesn't change (for 0 it blocks)
-        assert!(intr_evt.write(1).is_ok());
-        pl011.queue_input_bytes(&[b'a', b'b', b'c']).unwrap();
-
-        assert_eq!(intr_evt.read().unwrap(), 2);
-
-        let mut data = [0u8];
-        pl011.read(0, UARTDR as u64, &mut data);
-        assert_eq!(data[0], b'a');
-        pl011.read(0, UARTDR as u64, &mut data);
-        assert_eq!(data[0], b'b');
-        pl011.read(0, UARTDR as u64, &mut data);
-        assert_eq!(data[0], b'c');
-    }
-}

devices/src/lib.rs

@@ -6,7 +6,6 @@
 // found in the LICENSE-BSD-3-Clause file.
 
 //! Emulates virtual and hardware devices.
-extern crate anyhow;
 #[macro_use]
 extern crate bitflags;
 extern crate byteorder;
@@ -14,95 +13,65 @@ extern crate epoll;
 extern crate libc;
 #[macro_use]
 extern crate log;
-#[cfg(feature = "acpi")]
-extern crate acpi_tables;
-extern crate serde;
 extern crate vm_device;
 extern crate vm_memory;
-extern crate vm_migration;
 extern crate vmm_sys_util;
-#[macro_use]
-extern crate serde_derive;
-extern crate serde_json;
+
+use std::fs::File;
+use std::io;
 
 #[cfg(feature = "acpi")]
-pub mod acpi;
-#[cfg(target_arch = "aarch64")]
-pub mod gic;
-pub mod interrupt_controller;
-#[cfg(target_arch = "x86_64")]
+mod acpi;
+mod bus;
 pub mod ioapic;
 pub mod legacy;
 
 #[cfg(feature = "acpi")]
-pub use self::acpi::{AcpiGedDevice, AcpiPmTimerDevice, AcpiShutdownDevice};
+pub use self::acpi::{AcpiGEDDevice, AcpiShutdownDevice};
+pub use self::bus::{Bus, BusDevice, Error as BusError};
+
+pub type DeviceEventT = u16;
+
+/// The payload is used to handle events where the internal state of the VirtIO device
+/// needs to be changed.
+pub enum EpollHandlerPayload {
+    /// DrivePayload(disk_image)
+    DrivePayload(File),
+    /// Events that do not need a payload.
+    Empty,
+}
+
+type Result<T> = std::result::Result<T, Error>;
+
+pub trait EpollHandler: Send {
+    fn handle_event(
+        &mut self,
+        device_event: DeviceEventT,
+        event_flags: u32,
+        payload: EpollHandlerPayload,
+    ) -> Result<()>;
+}
+
+#[derive(Debug)]
+pub enum Error {
+    FailedReadingQueue {
+        event_type: &'static str,
+        underlying: io::Error,
+    },
+    FailedReadTap,
+    FailedSignalingUsedQueue(io::Error),
+    PayloadExpected,
+    UnknownEvent {
+        device: &'static str,
+        event: DeviceEventT,
+    },
+    IoError(io::Error),
+}
 
 bitflags! {
-    pub struct AcpiNotificationFlags: u8 {
+    pub struct HotPlugNotificationFlags: u8 {
         const NO_DEVICES_CHANGED = 0;
         const CPU_DEVICES_CHANGED = 0b1;
         const MEMORY_DEVICES_CHANGED = 0b10;
-        const PCI_DEVICES_CHANGED = 0b100;
-        const POWER_BUTTON_CHANGED = 0b1000;
     }
 }
-
-#[allow(unused_macros)]
-#[cfg(target_arch = "aarch64")]
-macro_rules! generate_read_fn {
-    ($fn_name: ident, $data_type: ty, $byte_type: ty, $type_size: expr, $endian_type: ident) => {
-        #[allow(dead_code)]
-        pub fn $fn_name(input: &[$byte_type]) -> $data_type {
-            assert!($type_size == std::mem::size_of::<$data_type>());
-            let mut array = [0u8; $type_size];
-            for (byte, read) in array.iter_mut().zip(input.iter().cloned()) {
-                *byte = read as u8;
-            }
-            <$data_type>::$endian_type(array)
-        }
-    };
-}
-
-#[allow(unused_macros)]
-#[cfg(target_arch = "aarch64")]
-macro_rules! generate_write_fn {
-    ($fn_name: ident, $data_type: ty, $byte_type: ty, $endian_type: ident) => {
-        #[allow(dead_code)]
-        pub fn $fn_name(buf: &mut [$byte_type], n: $data_type) {
-            for (byte, read) in buf
-                .iter_mut()
-                .zip(<$data_type>::$endian_type(n).iter().cloned())
-            {
-                *byte = read as $byte_type;
-            }
-        }
-    };
-}
-
-#[cfg(target_arch = "aarch64")]
-generate_read_fn!(read_le_u16, u16, u8, 2, from_le_bytes);
-#[cfg(target_arch = "aarch64")]
-generate_read_fn!(read_le_u32, u32, u8, 4, from_le_bytes);
-#[cfg(target_arch = "aarch64")]
-generate_read_fn!(read_le_u64, u64, u8, 8, from_le_bytes);
-#[cfg(target_arch = "aarch64")]
-generate_read_fn!(read_le_i32, i32, i8, 4, from_le_bytes);
-
-#[cfg(target_arch = "aarch64")]
-generate_read_fn!(read_be_u16, u16, u8, 2, from_be_bytes);
-#[cfg(target_arch = "aarch64")]
-generate_read_fn!(read_be_u32, u32, u8, 4, from_be_bytes);
-
-#[cfg(target_arch = "aarch64")]
-generate_write_fn!(write_le_u16, u16, u8, to_le_bytes);
-#[cfg(target_arch = "aarch64")]
-generate_write_fn!(write_le_u32, u32, u8, to_le_bytes);
-#[cfg(target_arch = "aarch64")]
-generate_write_fn!(write_le_u64, u64, u8, to_le_bytes);
-#[cfg(target_arch = "aarch64")]
-generate_write_fn!(write_le_i32, i32, i8, to_le_bytes);
-
-#[cfg(target_arch = "aarch64")]
-generate_write_fn!(write_be_u16, u16, u8, to_be_bytes);
-#[cfg(target_arch = "aarch64")]
-generate_write_fn!(write_be_u32, u32, u8, to_be_bytes);

docs/api.md

@@ -12,7 +12,7 @@
         * [Reboot a Virtual Machine](#reboot-a-virtual-machine)
         * [Shut a Virtual Machine Down](#shut-a-virtual-machine-down)
     + [Command Line Interface](#command-line-interface)
-    + [REST API and CLI Architectural Relationship](#rest-api-and-cli-architectural-relationship)
+    + [REST API and CLI Architecural Relationship](#rest-api-and-cli-architectural-relationship)
   * [Internal API](#internal-api)
     + [Goals and Design](#goals-and-design)
   * [End to End Example](#end-to-end-example)
@@ -78,27 +78,18 @@ Shut the VMM down                   | `/vmm.shutdown` | N/A          | N/A
 
 #### Virtual Machine (VM) Actions
 
-Action                             | Endpoint            | Request Body              | Response Body            | Prerequisites
------------------------------------|---------------------|---------------------------|--------------------------|---------------------------
-Create the VM                      | `/vm.create`        | `/schemas/VmConfig`       | N/A                      | The VM is not created yet
-Delete the VM                      | `/vm.delete`        | N/A                       | N/A                      | N/A
-Boot the VM                        | `/vm.boot`          | N/A                       | N/A                      | The VM is created but not booted
-Shut the VM down                   | `/vm.shutdown`      | N/A                       | N/A                      | The VM is booted
-Reboot the VM                      | `/vm.reboot`        | N/A                       | N/A                      | The VM is booted
-Pause the VM                       | `/vm.pause`         | N/A                       | N/A                      | The VM is booted
-Resume the VM                      | `/vm.resume`        | N/A                       | N/A                      | The VM is paused
-Add/remove CPUs to/from the VM     | `/vm.resize`        | `/schemas/VmResize`       | N/A                      | The VM is booted
-Add/remove memory from the VM      | `/vm.resize`        | `/schemas/VmResize`       | N/A                      | The VM is booted
-Add/remove memory from a zone      | `/vm.resize-zone`   | `/schemas/VmResizeZone`   | N/A                      | The VM is booted
-Dump the VM information            | `/vm.info`          | N/A                       | `/schemas/VmInfo`        | The VM is created
-Add VFIO PCI device to the VM      | `/vm.add-device`    | `/schemas/VmAddDevice`    | `/schemas/PciDeviceInfo` | The VM is booted
-Add disk device to the VM          | `/vm.add-disk`      | `/schemas/DiskConfig`     | `/schemas/PciDeviceInfo` | The VM is booted
-Add fs device to the VM            | `/vm.add-fs`        | `/schemas/FsConfig`       | `/schemas/PciDeviceInfo` | The VM is booted
-Add pmem device to the VM          | `/vm.add-pmem`      | `/schemas/PmemConfig`     | `/schemas/PciDeviceInfo` | The VM is booted
-Add network device to the VM       | `/vm.add-net`       | `/schemas/NetConfig`      | `/schemas/PciDeviceInfo` | The VM is booted
-Add vsock device to the VM         | `/vm.add-vsock`     | `/schemas/VsockConfig`    | `/schemas/PciDeviceInfo` | The VM is booted
-Remove device from the VM          | `/vm.remove-device` | `/schemas/VmRemoveDevice` | N/A                      | The VM is booted
-Dump the VM counters               | `/vm.counters`      | N/A                       | `/schemas/VmCounters`    | The VM is booted
+Action                           | Endpoint       | Request Body        | Response Body     | Prerequisites
+---------------------------------|----------------|---------------------|-------------------|---------------------------
+Create the VM                    | `/vm.create`   | `/schemas/VmConfig` | N/A               | The VM is not created yet
+Delete the VM                    | `/vm.delete`   | N/A                 | N/A               | The VM is created but not booted
+Boot the VM                      | `/vm.boot`     | N/A                 | N/A               | The VM is created
+Shut the VM down                 | `/vm.shutdown` | N/A                 | N/A               | The VM is booted
+Reboot the VM                    | `/vm.reboot`   | N/A                 | N/A               | The VM is booted
+Pause the VM                     | `/vm.pause`    | N/A                 | N/A               | The VM is booted
+Resume the VM                    | `/vm.resume`   | N/A                 | N/A               | The VM is paused
+Add/remove CPUs to/from the VM   | `/vm.resize`   | `/schemas/VmResize` | N/A               | The VM is booted
+Remove memory from the VM        | `/vm.resize`   | `/schemas/VmResize` | N/A               | The VM is booted
+Dump the VM information          | `/vm.info`     | N/A                 | `/schemas/VmInfo` | The VM is created
 
 ### REST API Examples
 
@@ -123,10 +114,10 @@ We want to create a virtual machine with the following characteristics:
 * 4 vCPUs
 * 1 GB of RAM
 * 1 virtio based networking interface
-* Direct kernel boot from a custom 5.6.0-rc4 Linux kernel located at
+* Direct kernel boot from a custom 5.5.0 Linux kernel located at
   `/opt/clh/kernel/vmlinux-virtio-fs-virtio-iommu`
-* Using a Ubuntu image as its root filesystem, located at
-  `/opt/clh/images/focal-server-cloudimg-amd64.raw`
+* Using a Clear Linux image as its root filesystem, located at
+  `/opt/clh/images/clear-30080-kvm.img`
 
 ```shell
 #!/bin/bash
@@ -138,8 +129,8 @@ curl --unix-socket /tmp/cloud-hypervisor.sock -i \
      -d '{
          "cpus":{"boot_vcpus": 4, "max_vcpus": 4},
          "kernel":{"path":"/opt/clh/kernel/vmlinux-virtio-fs-virtio-iommu"},
-         "cmdline":{"args":"console=ttyS0 console=hvc0 root=/dev/vda1 rw"},
-         "disks":[{"path":"/opt/clh/images/focal-server-cloudimg-amd64.raw"}],
+         "cmdline":{"args":"console=hvc0 reboot=k panic=1 nomodules i8042.noaux i8042.nomux i8042.nopnp i8042.dumbkbd root=/dev/vda3"},
+         "disks":[{"path":"/opt/clh/images/clear-30080-kvm.img"}],
          "rng":{"src":"/dev/urandom"},
          "net":[{"ip":"192.168.10.10", "mask":"255.255.255.0", "mac":"12:34:56:78:90:01"}]
          }'
@@ -276,7 +267,7 @@ are received and processed by the VMM control loop.
 In order for the VMM control loop to respond to any internal API command, it
 must be able to send a response back to the MPSC sender. For that purpose, all
 internal API command payload carry the [Sender](https://doc.rust-lang.org/std/sync/mpsc/struct.Sender.html)
-end of an [MPSC](https://doc.rust-lang.org/std/sync/mpsc/) channel.
+end of an [MPSC](https://doc.rust-lang.org/std/sync/mpsc/) channel. 
 
 The sender of any internal API command is therefore responsible for:
 
@@ -306,8 +297,8 @@ APIs work together, let's look at a complete VM creation flow, from the
 		-d '{
 			"cpus":{"boot_vcpus": 4, "max_vcpus": 4},
 			"kernel":{"path":"/opt/clh/kernel/vmlinux-virtio-fs-virtio-iommu"},
-			"cmdline":{"args":"console=ttyS0 console=hvc0 root=/dev/vda1 rw"},
-			"disks":[{"path":"/opt/clh/images/focal-server-cloudimg-amd64.raw"}],
+			"cmdline":{"args":"console=hvc0 reboot=k panic=1 nomodules i8042.noaux i8042.nomux i8042.nopnp i8042.dumbkbd root=/dev/vda3"},
+			"disks":[{"path":"/opt/clh/images/clear-30080-kvm.img"}],
 			"rng":{"src":"/dev/urandom"},
 			"net":[{"ip":"192.168.10.10", "mask":"255.255.255.0", "mac":"12:34:56:78:90:01"}]
 			}'
@@ -356,7 +347,7 @@ APIs work together, let's look at a complete VM creation flow, from the
 		   } else {
 			   Err(ApiError::VmAlreadyCreated)
 		   };
-
+		   
 	       sender.send(response).map_err(Error::ApiResponseSend)?;
 	   }
    ```
@@ -377,3 +368,4 @@ APIs work together, let's look at a complete VM creation flow, from the
    user. This is abstracted by the
    [micro_http](https://github.com/firecracker-microvm/firecracker/tree/master/src/micro_http)
    crate.
+   

docs/arm64.md

@@ -1,58 +0,0 @@
-# How to build and run Cloud-hypervisor on AArch64
-
-Cloud-hypervisor is partially enabled on AArch64 architecture.
-Although all features are not ready yet, you can begin to test Cloud-hypervisor on a AArch64 host by following this guide.
-
-## Prerequisites
-
-On AArch64 machines, Cloud-hypervisor depends on an external library `libfdt-dev` for generating Flattened Device Tree (FDT).
-
-The long-term plan is to replace `libfdt-dev` with some pure-Rust component to get rid of such dependency.
-
-```bash
-sudo apt-get update
-sudo apt-get install libfdt-dev
-```
-
-## Build
-
-Using PCI devices requires GICv3-ITS for MSI messaging. GICv3-ITS is very common in modern servers.
-
-```bash
-cargo build --no-default-features --features kvm
-```
-
-## Image
-
-Download kernel binary and rootfs image from AWS.
-
-```bash
-wget https://s3.amazonaws.com/spec.ccfc.min/img/aarch64/ubuntu_with_ssh/fsfiles/xenial.rootfs.ext4 -O rootfs.ext4
-wget https://s3.amazonaws.com/spec.ccfc.min/img/aarch64/ubuntu_with_ssh/kernel/vmlinux.bin -O kernel.bin
-```
-
-## Containerized build
-
-If you want to build and test Cloud Hypervisor without having to install all the required dependencies, you can also turn to the development script: dev_cli.sh.
-
-To build the development container:
-
-```bash
-./scripts/dev_cli.sh build-container
-```
-
-To build Cloud-hypervisor in the container:
-
-```bash
-./scripts/dev_cli.sh build
-```
-
-## Run
-
-Assuming you have built Cloud-hypervisor with the development container, a VM can be started with command:
-
-```bash
-sudo build/cargo_target/aarch64-unknown-linux-gnu/debug/cloud-hypervisor --kernel kernel.bin --disk path=rootfs.ext4 --cmdline "keep_bootcon console=hvc0 reboot=k panic=1 root=/dev/vda rw" --cpus boot=4 --memory size=512M --serial file=serial.log --log-file log.log -vvv
-```
-
-If the build was done out of the container, replace the binary path with `target/debug/cloud-hypervisor`.

docs/custom-image.md

@@ -1,149 +1,96 @@
-# How to create a custom Ubuntu image
+# How to create a custom Clear Linux image
 
-In the context of adding more utilities to the Ubuntu cloud image being used
-for integration testing, this quick guide details how to achieve the proper
-modification of an official Ubuntu cloud image.
+In the context of adding more utility to the cloudguest image being used
+for integration testing, this is a quick guide on how to achieve the creation
+of your own Clear Linux image using the official Clear Linux tooling.
+
+## Prepare the environment
+
+From the host, the goal is run a Clear Linux VM that will allow us to build
+the custom image we want.
+
+```bash
+# Get latest CL version:
+IMG_VERSION=$(curl https://download.clearlinux.org/latest)
+# Get latest clear-kvm image:
+wget -P $HOME/workloads/ https://download.clearlinux.org/current/clear-${IMG_VERSION}-kvm.img.xz
+# Extract the image
+unxz $HOME/workloads/clear-${IMG_VERSION}-kvm.img.xz
+# Make sure cloud-hypervisor binary has CAP_NET_ADMIN capability set
+sudo setcap cap_net_admin+ep cloud-hypervisor
+# Boot cloud-hypervisor VM with the downloaded image
+./cloud-hypervisor -v --kernel $HOME/workloads/vmlinux --disk path=clear-${IMG_VERSION}-kvm.img --cmdline "console=ttyS0 console=hvc0 reboot=k panic=1 nomodules root=/dev/vda3 rw" --cpus 1 --memory size=4G --net tap=,mac=
+# Setup connectivity
+# First make sure to enable IP forwarding (disabled on Linux by default)
+sudo bash -c "echo 1 > /proc/sys/net/ipv4/ip_forward"
+# Retrieve the interface name and the gateway IP
+IFACE=$(ip route | grep default | awk -F 'dev' '{print $2}' | awk -F ' ' '{print $1}')
+GW=$(ip route | grep vmtap0 | awk -F ' ' '{print $1}')
+# Create a new masquerade rule to tag the packets going out
+sudo iptables -t nat -A POSTROUTING -s ${GW} -o ${IFACE} -j MASQUERADE
+```
 
 ## Create the image
 
-Let's go through the steps on how to extend an official Ubuntu image. These
-steps can be applied to other distributions (with a few changes regarding
-package management).
-
-### Get latest Ubuntu cloud image
+From the guest, we can now create the image.
 
 ```bash
-wget https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-amd64.img
+# Setup connectivity
+sudo ip addr add 192.168.249.2/24 dev enp0s3
+sudo ip route add default via 192.168.249.1
+# Install necessary bundles
+sudo swupd bundle-add clr-installer
+sudo swupd bundle-add os-installer
+# Download and update cloudguest image configuration
+wget https://download.clearlinux.org/current/config/image/cloudguest.yaml
+sed -i '/size: \"864M\"/d' cloudguest.yaml
+sed -i 's/\"800M\"/\"2G\"/g' cloudguest.yaml
+sed -i 's/bootloader,/bootloader,\n    iperf,/g' cloudguest.yaml
+sed -i 's/systemd-networkd-autostart/sysadmin-basic,\n    systemd-networkd-autostart/g' cloudguest.yaml
+# Create the custom cloudguest image
+clr-installer -c cloudguest.yaml
+# Make the guest accessible through ssh
+sudo mkdir -p /etc/ssh
+sudo bash -c "echo 'PermitRootLogin yes' >> /etc/ssh/sshd_config"
 ```
 
-### Check the file format is QCOW2
+### Retrieve the image
+
+Once the new image has been created and the guest is accessible through
+`ssh`, it is time to retrieve the image from the host.
 
 ```bash
-file focal-server-cloudimg-amd64.img
-focal-server-cloudimg-amd64.img: QEMU QCOW2 Image (v2), 2361393152 bytes
-```
-
-### Convert QCOW2 into RAW
-
-```bash
-qemu-img convert -p -f qcow2 -O raw focal-server-cloudimg-amd64.img focal-server-cloudimg-amd64.raw
-```
-
-### Identify the Linux partition
-
-The goal is to mount the image rootfs so that it can be modified as needed.
-That's why we need to identify where the Linux filesystem partition is located
-in the image.
-
-```bash
-sudo fdisk -l focal-server-cloudimg-amd64.raw
-Disk focal-server-cloudimg-amd64.raw: 2.2 GiB, 2361393152 bytes, 4612096 sectors
-Units: sectors of 1 * 512 = 512 bytes
-Sector size (logical/physical): 512 bytes / 512 bytes
-I/O size (minimum/optimal): 512 bytes / 512 bytes
-Disklabel type: gpt
-Disk identifier: A1171ABA-2BEA-4218-A467-1B2B607E5953
-
-Device                             Start     End Sectors  Size Type
-focal-server-cloudimg-amd64.raw1  227328 4612062 4384735  2.1G Linux filesystem
-focal-server-cloudimg-amd64.raw14   2048   10239    8192    4M BIOS boot
-focal-server-cloudimg-amd64.raw15  10240  227327  217088  106M EFI System
-
-Partition table entries are not in disk order.
-```
-
-### Mount the Linux partition
-
-```bash
-mkdir -p /mnt
-sudo mount -o loop,offset=$((227328 * 512)) focal-server-cloudimg-amd64.raw /mnt
-```
-
-### Change root directory
-
-Changing the root directory will allow us to install new packages to the rootfs
-contained by the cloud image.
-
-```bash
-sudo chroot /mnt
-mount -t proc proc /proc
-mount -t devpts devpts /dev/pts
-```
-
-### Install needed packages
-
-In the context Cloud-Hypervisor's integration tests, we need several utilities.
-Here is the way to install them for a Ubuntu image. This step is specific to
-Ubuntu distributions.
-
-```bash
-apt update
-apt install fio iperf iperf3 socat
-```
-
-### Remove counterproductive packages
-
-* snapd:
-
-This prevents snapd from trying to mount squashfs filesystem when the kernel
-might not support it. This might be the case when the image is used with direct
-kernel boot. This step is specific to Ubuntu distributions.
-
-* pollinate:
-
-Remove this package which can fail and lead to the SSH daemon failing to start.
-See #2113 for details.
-
-```bash
-apt remove --purge snapd pollinate
-```
-
-
-### Cleanup the image
-
-Leave no trace in the image before unmounting its content.
-
-```bash
-umount /dev/pts
-umount /proc
-history -c
-exit
-umount /mnt
-```
-
-### Rename the image
-
-Renaming is important to identify this is a modified image.
-
-```bash
-mv focal-server-cloudimg-amd64.raw focal-server-cloudimg-amd64-custom-$(date "+%Y%m%d")-0.raw
-```
-
-The `-0` is the revision and is only necessary to change if multiple images are
-updated on the same day.
-
-### Create QCOW2 from RAW
-
-Last step is to create the QCOW2 image back from the modified image.
-
-```bash
-qemu-img convert -p -f raw -O qcow2 focal-server-cloudimg-amd64-custom-$(date "+%Y%m%d")-0.raw focal-server-cloudimg-amd64-custom-$(date "+%Y%m%d")-0.qcow2
+# Retrieve new image (this is a raw image)
+scp root@192.168.249.2:cloudguest.img .
+mv cloudguest.img clear-cloudguest-raw.img
+# Create the QCOW image from the RAW image
+qemu-img convert -p -f raw -O qcow2 clear-cloudguest-raw.img clear-cloudguest.img
+# Compress the QCOW image
+xz -k -T $(nproc) clear-cloudguest.img
 ```
 
 ## Switch CI to use the new image
 
 ### Upload to Azure storage
 
-The next step is to update both images (QCOW2 and RAW) stored as part of the
-Azure storage account, replacing them with the newly created ones. This will
-make these new images available from the integration tests. This is usually
-achieved through the web interface.
+The next step is to update the image stored as part of the Azure storage
+account, replacing it with the newly created image. This will make this
+new image available from the integration tests.
+This is usually achieved through the web interface.
 
 ### Update integration tests
 
 Last step is about updating the integration tests to work with this new image.
-The key point is to identify where the Linux filesystem partition is located,
-as we might need to update the direct kernel boot command line, replacing
-`/dev/vda1` with the appropriate partition number.
+The key point is to identify the UUID of this new image so that it can be used
+directly from the tests.
 
-Update all references to the previous image name to the new one.
+Proceed as follow to determine this UUID:
+
+```bash
+# Mount the image
+sudo mount -o loop,offset=$((2048 * 512)) clear-cloudguest-raw.img /mnt/
+# Identify UUID
+sudo cat /mnt/loader/entries/Clear-linux-kvm-*.conf | grep "root=PARTUUID="
+# Unmount the image
+sudo umount /mnt
+```

docs/debug-port.md

@@ -43,7 +43,7 @@ to easily grep for the tracing logs (e.g.
 ```
 ./target/debug/cloud-hypervisor \
     --kernel ~/rust-hypervisor-firmware/target/target/release/hypervisor-fw \
-    --disk path=~/hypervisor/images/focal-server-cloudimg-amd64.raw \
+    --disk path=~/hypervisor/images/clear-30080-kvm.img \
     --cpus 4 \
     --memory size=1024M \
     --rng \

docs/device_model.md

@@ -28,13 +28,9 @@ This document describes the device model supported by `cloud-hypervisor`.
 ### Serial port
 
 Simple emulation of a serial port by reading and writing to specific port I/O
-addresses. The serial port can be very useful to gather early logs from the
-operating system booted inside the VM.
-
-For x86_64, The default serial port is from an emulated 16550A device. It can
-be used as the default console for Linux when booting with the option
-`console=ttyS0`. For AArch64, the default serial port is from an emulated
-PL011 UART device. The related command line for AArch64 is `console=ttyAMA0`.
+addresses. Used as the default console for Linux when booting with the option
+`console=ttyS0`, the serial port can be very useful to gather early logs from
+the operating system booted inside the VM.
 
 This device is always built-in, and it is disabled by default. It can be
 enabled with the `--serial` option, as long as its parameter is not `off`.
@@ -48,10 +44,6 @@ This device is built-in by default, but it can be compiled out with Rust
 features. When compiled in, it is always enabled, and cannot be disabled
 from the command line.
 
-For AArch64 machines, an ARM PrimeCell Real Time Clock(PL031) is implemented.
-This device is built-in by default for the AArch64 platform, and it is always
-enabled, and cannot be disabled from the command line.
-
 ### I/O APIC
 
 `cloud-hypervisor` supports a so-called split IRQ chip implementation by
@@ -73,11 +65,6 @@ enabled by default, the handling of reboot/shutdown goes through the dedicated
 ACPI device. In case ACPI is disabled, this device is enabled to bring to the
 VM some reboot/shutdown support.
 
-### ARM PrimeCell General Purpose Input/Output (PL061)
-
-Simplified ARM PrimeCell GPIO (PL061) implementation. Only supports key 3 to
-trigger a graceful shutdown of the AArch64 guest.
-
 ### ACPI device
 
 This is a dedicated device for handling ACPI shutdown and reboot when ACPI is
@@ -88,8 +75,12 @@ feature is enabled by default.
 
 ## Virtio devices
 
-For all virtio devices listed below, only `virtio-pci` transport layer is
-supported.
+For all virtio devices listed below, both `virtio-mmio` and `virtio-pci`
+transport layers are supported, `virtio-pci` being the default.
+
+Both `virtio-mmio` and `virtio-pci` can be compiled out. `virtio-pci` is
+built-in by default, and enabled by default. If both transport layers were
+built at the same time, `virtio-pci` would be the default transport layer.
 
 ### virtio-block
 
@@ -113,8 +104,9 @@ selecting `--serial tty --console off` from the command line.
 ### virtio-iommu
 
 As we want to improve our nested guests support, we added support for exposing
-a [paravirtualized IOMMU](iommu.md) device through virtio. This allows for a
-safer nested virtio and directly assigned devices support.
+a [paravirtualized IOMMU](https://github.com/cloud-hypervisor/cloud-hypervisor/blob/master/docs/iommu.md)
+device through virtio. This allows for a safer nested virtio and directly
+assigned devices support.
 
 This device is always built-in, and it is enabled based on the presence of the
 parameter `iommu=on` in any of the virtio or VFIO devices. If at least one of
@@ -183,8 +175,8 @@ This device is always built-in, and it is enabled when `vhost_user=true` and
 shared file system, allowing for an efficient and reliable way of sharing
 a filesystem between the host and the cloud-hypervisor guest.
 
-See our [filesystem sharing](fs.md) documentation for more details on how to
-use virtio-fs with cloud-hypervisor.
+See our [filesystem sharing](https://github.com/cloud-hypervisor/cloud-hypervisor/blob/master/docs/fs.md)
+documentation for more details on how to use virtio-fs with cloud-hypervisor.
 
 This device is always built-in, and it is enabled based on the presence of the
 flag `--fs`.
@@ -205,8 +197,9 @@ VFIO (Virtual Function I/O) is a kernel framework that exposes direct device
 access to userspace. `cloud-hypervisor` uses VFIO to directly assign host
 physical devices into its guest.
 
-See our [VFIO documentation](vfio.md) for more details on how to directly
-assign host devices to `cloud-hypervisor` guests.
+See our [VFIO documentation](https://github.com/cloud-hypervisor/cloud-hypervisor/blob/master/docs/vfio.md)
+for more details on how to directly assign host devices to `cloud-hypervisor`
+guests.
 
 Because VFIO implies `vfio-pci` in the `cloud-hypervisor` context, the VFIO
 support is built-in when the `pci` feature is selected. And because the `pci`

docs/fs.md

@@ -12,7 +12,7 @@ This virtual device relies on the _vhost-user_ protocol, which assumes the backe
 
 _Build virtiofsd_
 ```bash
-git clone --depth 1 "https://gitlab.com/virtio-fs/qemu.git" -b "qemu5.0-virtiofs-dax" $VIRTIOFSD_DIR
+git clone --depth 1 "https://github.com/sboeuf/qemu.git" -b "virtio-fs" $VIRTIOFSD_DIR
 cd $VIRTIOFSD_DIR
 ./configure --prefix=$PWD --target-list=x86_64-softmmu
 make virtiofsd -j `nproc`
@@ -35,42 +35,45 @@ The `cache=none` option should be the default when using `virtiofsd` with the __
 
 The `cache=always` option will allow for the guest page cache to be used, which will increase the memory footprint of the guest. This option should be used only for specific use cases where a single VM is going to be running on a host.
 
-### Kernel support
+### The kernel
 
-Modern Linux kernels starting (at least v5.10) have support for virtio-fs. Use
-of older kernels, with additional patches, are not supported.
+In order to leverage __virtio-fs__ support from within the guest, and because the code has not been merged in upstream Linux kernel yet, it is required to build a custom kernel embedding the patches.
+
+The following branch `virtio-fs-virtio-iommu` on the repository https://github.com/cloud-hypervisor/linux.git includes all the needed patches to support __virtio-fs__.
+
+Make sure to build a kernel out of this branch that can be then used to boot the VM.
 
 ## How to share directories with cloud-hypervisor
 
 ### Start the VM
 Once the daemon is running, the option `--fs` from __cloud-hypervisor__ needs to be used.
 
-Direct kernel boot is the preferred option, but we can boot from an EFI cloud image if it contains a recent enough kernel.
+Direct kernel boot option is preferred since we need to provide the custom kernel including the __virtio-fs__ patches. We could boot from `hypervisor-fw` if we had previously edited the image to replace the kernel binary.
 
-Because _vhost-user_ expects a dedicated process (__virtiofsd__ in this case) to be able to access the guest RAM to communicate through the _virtqueues_ with the driver running in the guest, `--memory` option needs to be slightly modified. It must specify `shared=on` to share the memory pages so that an external process can access them.
+Because _vhost-user_ expects a dedicated process (__virtiofsd__ in this case) to be able to access the guest RAM to communicate through the _virtqueues_ with the driver running in the guest, `--memory` option needs to be slightly modified. It needs to specify a backing file for the memory so that an external process can access it.
 
-Assuming you have `focal-server-cloudimg-amd64.raw` and `vmlinux` on your system, here is the __cloud-hypervisor__ command you need to run:
+Assuming you have `clear-kvm.img` and `custom-vmlinux.bin` on your system, here is the __cloud-hypervisor__ command you need to run:
 ```bash
 ./cloud-hypervisor \
-    --cpus boot=1 \
-    --memory size=1G,shared=on \
-    --disk path=focal-server-cloudimg-amd64.raw \
-    --kernel vmlinux \
-    --cmdline "console=hvc0 root=/dev/vda1 rw" \
-    --fs tag=myfs,socket=/tmp/virtiofs,num_queues=1,queue_size=512
+    --cpus 4 \
+    --memory "size=512,file=/dev/shm" \
+    --disk path=clear-kvm.img \
+    --kernel custom-vmlinux.bin \
+    --cmdline "console=ttyS0 reboot=k panic=1 nomodules root=/dev/vda3" \ 
+    --fs tag=myfs,sock=/tmp/virtiofs,num_queues=1,queue_size=512
 ```
 
 By default, DAX is enabled with a cache window of 8GiB. You can specify a custom size (let's say 4GiB for this example) for the cache by explicitly setting DAX and the cache size:
 
 ```bash
---fs tag=myfs,socket=/tmp/virtiofs,num_queues=1,queue_size=512,dax=on,cache_size=4G
+--fs tag=virtiofs,sock=/tmp/virtiofs,num_queues=1,queue_size=512,dax=on,cache_size=4G
 
 ```
 
 In case you don't want to use a shared window of cache to pass the shared files content, this means you will have to explicitly disable DAX with `dax=off`. Note that in this case, the `cache_size` parameter will be ignored.
 
 ```bash
---fs tag=myfs,socket=/tmp/virtiofs,num_queues=1,queue_size=512,dax=off
+--fs tag=virtiofs,sock=/tmp/virtiofs,num_queues=1,queue_size=512,dax=off
 
 ```
 

docs/fuzzing.md

@@ -1,35 +0,0 @@
-# Fuzzing in Cloud Hypervisor
-
-Cloud Hypervisor uses [cargo-fuzz](https://github.com/rust-fuzz/cargo-fuzz) for fuzzing individual components.
-
-The fuzzers are are in the `fuzz/fuzz_targets` directory
-
-## Preparation
-
-Switch to nightly: 
-
-````
-rustup override set nightly
-````
-
-Install `cargo fuzz`: 
-
-```
-cargo install cargo-fuzz
-```
-
-## Running the fuzzers
-
-e.g. To run the `qcow` fuzzer using all available CPUs:
-
-```
-cargo fuzz run qcow -j `nproc`
-```
-
-## Adding a new fuzzer
-
-```
-cargo fuzz add <new_fuzzer>
-```
-
-Inspiration for fuzzers can be found in [crosvm](https://chromium.googlesource.com/chromiumos/platform/crosvm/+/refs/heads/master/fuzz/)

docs/hotplug.md

@@ -5,7 +5,9 @@ Currently Cloud Hypervisor only support hot plugging of CPU devices.
 ## Kernel support
 
 For hotplug on Cloud Hypervisor ACPI GED support is needed. This can either be achieved by turning on `CONFIG_ACPI_REDUCED_HARDWARE_ONLY` 
-or by using this kernel patch (available in 5.5-rc1 and later): https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/patch/drivers/acpi/Makefile?id=ac36d37e943635fc072e9d4f47e40a48fbcdb3f0
+or by using this kernel patch (available in 5.5rc1 and later): https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/patch/drivers/acpi/Makefile?id=ac36d37e943635fc072e9d4f47e40a48fbcdb3f0
+
+This patch is integrated into the Clear Linux KVM and cloudguest images.
 
 ## CPU Hot Plug
 
@@ -20,14 +22,13 @@ To use CPU hotplug start the VM with the number of max vCPUs greater than the nu
 $ pushd $CLOUDH
 $ sudo setcap cap_net_admin+ep ./cloud-hypervisor/target/release/cloud-hypervisor
 $ ./cloud-hypervisor/target/release/cloud-hypervisor \
-	--kernel custom-vmlinux.bin \
-	--cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
-	--disk path=focal-server-cloudimg-amd64.raw \
+	--kernel ./hypervisor-fw \
+	--disk path=clear-31890-kvm.img \
 	--cpus boot=4,max=8 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask=" \
 	--rng \
-	--api-socket=/tmp/ch-socket
+    --api-socket=/tmp/ch-socket
 $ popd
 ```
 
@@ -36,7 +37,7 @@ Notice the addition of `--api-socket=/tmp/ch-socket` and a `max` parameter on `-
 To ask the VMM to add additional vCPUs then use the resize API:
 
 ```shell
-./ch-remote --api-socket=/tmp/ch-socket resize --cpus 8
+curl -H "Accept: application/json" -H "Content-Type: application/json" -i -XPUT --unix-socket /tmp/ch-socket -d "{ \"desired_vcpus\":8}" http://localhost/api/v1/vm.resize
 ```
 
 The extra vCPU threads will be created and advertised to the running kernel. The kernel does not bring up the CPUs immediately and instead the user must "online" them from inside the VM:
@@ -56,36 +57,31 @@ After a reboot the added CPUs will remain.
 Removing CPUs works similarly by reducing the number in the "desired_vcpus" field of the reisze API. The CPUs will be automatically offlined inside the guest so there is no need to run any commands inside the guest:
 
 ```shell
-./ch-remote --api-socket=/tmp/ch-socket resize --cpus 2
+curl -H "Accept: application/json" -H "Content-Type: application/json" -i -XPUT --unix-socket /tmp/ch-socket -d "{ \"desired_vcpus\":2}" http://localhost/api/v1/vm.resize
 ```
 
 As per adding CPUs to the guest, after a reboot the VM will be running with the reduced number of vCPUs.
 
 ## Memory Hot Plug
 
-### ACPI method
-
-Extra memory can be added from a running Cloud Hypervisor instance. This is controlled by two mechanisms:
+Extra memory can be added from a runing Cloud Hypervisor instance. This is controlled by two mechanisms:
 
 1. Allocating some of the guest physical address space for hotplug memory.
 2. Making a HTTP API request to the VMM to ask for a new amount of RAM to be assigned to the VM. In the case of expanding the memory for the VM the new memory will be hotplugged into the running VM, if reducing the size of the memory then change will take effect after the next reboot.
 
-To use memory hotplug start the VM specifying some size RAM in the `hotplug_size` parameter to the memory configuration. Not all the memory specified in this parameter will be available to hotplug as there are spacing and alignment requirements so it is recommended to make it larger than the hotplug RAM needed.
-
-Because the ACPI method is the default, there is no need to add the extra option `hotplug_method=acpi`.
+To use memory hotplug start the VM specifying some size RAM in the "hotplug_size" parameter to the memory configuration. Not all the memory specified in this parameter will be available to hotplug as there are spacing and alignment requirements so it is recommended to make it larger than the hotplug RAM needed.
 
 ```shell
 $ pushd $CLOUDH
 $ sudo setcap cap_net_admin+ep ./cloud-hypervisor/target/release/cloud-hypervisor
 $ ./cloud-hypervisor/target/release/cloud-hypervisor \
-	--kernel custom-vmlinux.bin \
-	--cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
-	--disk path=focal-server-cloudimg-amd64.raw \
+	--kernel ./hypervisor-fw \
+	--disk path=clear-31890-kvm.img \
 	--cpus boot=4,max=8 \
 	--memory size=1024M,hotplug_size=8192M \
 	--net "tap=,mac=,ip=,mask=" \
 	--rng \
-	--api-socket=/tmp/ch-socket
+    --api-socket=/tmp/ch-socket
 $ popd
 ```
 
@@ -95,10 +91,10 @@ Before issuing the API request it is necessary to run the following command insi
 root@ch-guest ~ # echo online | sudo tee /sys/devices/system/memory/auto_online_blocks
 ```
 
-To ask the VMM to expand the RAM for the VM:
+To ask the VMM to add expand the RAM for the VM:
 
 ```shell
-./ch-remote --api-socket=/tmp/ch-socket resize --memory 3G
+curl -H "Accept: application/json" -H "Content-Type: application/json" -i -XPUT --unix-socket /tmp/ch-socket -d "{ \"desired_vcpus\": 4, \"desired_ram\" : 3221225472}" http://localhost/api/v1/vm.resize
 ```
 
 The new memory is now available to use inside the VM:
@@ -114,135 +110,4 @@ Due to guest OS limitations is is necessary to ensure that amount of memory adde
 
 The same API can also be used to reduce the desired RAM for a VM but the change will not be applied until the VM is rebooted.
 
-Memory and CPU resizing can be combined together into the same HTTP API request.
-
-### virtio-mem method
-
-Extra memory can be added and removed from a running Cloud Hypervisor instance. This is controlled by two mechanisms:
-
-1. Allocating some of the guest physical address space for hotplug memory.
-2. Making a HTTP API request to the VMM to ask for a new amount of RAM to be assigned to the VM.
-
-To use memory hotplug start the VM specifying some size RAM in the `hotplug_size` parameter along with `hotplug_method=virtio-mem` to the memory configuration.
-
-```shell
-$ pushd $CLOUDH
-$ sudo setcap cap_net_admin+ep ./cloud-hypervisor/target/release/cloud-hypervisor
-$ ./cloud-hypervisor/target/release/cloud-hypervisor \
-	--kernel custom-vmlinux.bin \
-	--cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
-	--disk path=focal-server-cloudimg-amd64.raw \
-	--memory size=1024M,hotplug_size=8192M,hotplug_method=virtio-mem \
-	--net "tap=,mac=,ip=,mask=" \
-	--api-socket=/tmp/ch-socket
-$ popd
-```
-
-To ask the VMM to expand the RAM for the VM (request is in bytes):
-
-```shell
-./ch-remote --api-socket=/tmp/ch-socket resize --memory 3G
-```
-
-The new memory is now available to use inside the VM:
-
-```shell
-free -h
-              total        used        free      shared  buff/cache   available
-Mem:          3.0Gi        71Mi       2.8Gi       0.0Ki        47Mi       2.8Gi
-Swap:          32Mi          0B        32Mi
-```
-
-The same API can also be used to reduce the desired RAM for a VM. It is important to note that reducing RAM size might only partially work, as the guest might be using some of it.
-
-## PCI Device Hot Plug
-
-Extra PCI devices can be added and removed from a running Cloud Hypervisor instance. This is controlled by making a HTTP API request to the VMM to ask for the additional device to be added, or for the existing device to be removed.
-
-To use PCI device hotplug start the VM with the HTTP server.
-
-```shell
-$ sudo setcap cap_net_admin+ep ./cloud-hypervisor/target/release/cloud-hypervisor
-$ ./cloud-hypervisor/target/release/cloud-hypervisor \
-	--kernel custom-vmlinux.bin \
-	--cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
-	--disk path=focal-server-cloudimg-amd64.raw \
-	--cpus boot=4 \
-	--memory size=1024M \
-	--net "tap=,mac=,ip=,mask=" \
-	--api-socket=/tmp/ch-socket
-```
-
-Notice the addition of `--api-socket=/tmp/ch-socket`.
-
-### Add VFIO Device
-
-To ask the VMM to add additional VFIO device then use the `add-device` API.
-
-```shell
-./ch-remote --api-socket=/tmp/ch-socket add-device path=/sys/bus/pci/devices/0000:01:00.0/
-```
-
-### Add Disk Device
-
-To ask the VMM to add additional disk device then use the `add-disk` API.
-
-```shell
-./ch-remote --api-socket=/tmp/ch-socket add-disk path=/foo/bar/cloud.img
-```
-
-### Add Fs Device
-
-To ask the VMM to add additional fs device then use the `add-fs` API.
-
-```shell
-./ch-remote --api-socket=/tmp/ch-socket add-fs tag=myfs,socket=/foo/bar/virtiofs.sock
-```
-
-### Add Net Device
-
-To ask the VMM to add additional network device then use the `add-net` API.
-
-```shell
-./ch-remote --api-socket=/tmp/ch-socket add-net tap=chtap0
-```
-
-### Add Pmem Device
-
-To ask the VMM to add additional PMEM device then use the `add-pmem` API.
-
-```shell
-./ch-remote --api-socket=/tmp/ch-socket add-pmem file=/foo/bar.cloud.img
-```
-
-### Add Vsock Device
-
-To ask the VMM to add additional vsock device then use the `add-vsock` API.
-
-```shell
-./ch-remote --api-socket=/tmp/ch-socket add-vsock cid=3,socket=/foo/bar/vsock.sock
-```
-
-### Common Across All PCI Devices
-
-The extra PCI device will be created and advertised to the running kernel. The new device can be found by checking the list of PCI devices.
-
-```shell
-root@ch-guest ~ # lspci
-00:00.0 Host bridge: Intel Corporation Device 0d57
-00:01.0 Unassigned class [ffff]: Red Hat, Inc. Virtio console (rev 01)
-00:02.0 Mass storage controller: Red Hat, Inc. Virtio block device (rev 01)
-00:03.0 Unassigned class [ffff]: Red Hat, Inc. Virtio RNG (rev 01)
-```
-
-After a reboot the added PCI device will remain.
-
-### Remove PCI device
-
-Removing a PCI device works the same way for all kind of PCI devices. The unique identifier related to the device must be provided. This identifier can be provided by the user when adding the new device, or by default Cloud Hypervisor will assign one.
-
-```shell
-./ch-remote --api-socket=/tmp/ch-socket remove-device _disk0
-```
-
-As per adding a PCI device to the guest, after a reboot the VM will be running without the removed PCI device.
+Memory and CPU resizing can be combined together into the same HTTP API request.

docs/intel_sgx.md

@@ -1,55 +0,0 @@
-# Intel SGX
-
-Intel® Software Guard Extensions (Intel® SGX) is an Intel technology designed
-to increase the security of application code and data. Cloud-Hypervisor supports
-SGX virtualization through KVM. Because SGX is built on hardware features that
-cannot be emulated in software, virtualizing SGX requires support in KVM and in
-the host kernel. The required Linux and KVM changes can be found in the
-[KVM SGX Tree](https://github.com/intel/kvm-sgx).
-
-Utilizing SGX in the guest requires a kernel/OS with SGX support, e.g. a kernel
-built using the [SGX Linux Development Tree](https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-sgx.git)
-or the [KVM SGX Tree](https://github.com/intel/kvm-sgx). Running KVM SGX as the
-guest kernel allows nested virtualization of SGX.
-
-For more information about SGX, please refer to the [SGX Homepage](https://software.intel.com/sgx).
-
-For more information about SGX SDK and how to test SGX, please refer to the
-following [instructions](https://github.com/intel/linux-sgx).
-
-## Cloud-Hypervisor support
-
-Assuming the host exposes `/dev/sgx_virt_epc`, we can pass SGX enclaves through
-the guest.
-
-In order to use SGX enclaves within a Cloud-Hypervisor VM, we must define one
-or several Enclave Page Cache (EPC) sections. Here is an example of a VM being
-created with 2 EPC sections, the first one being 64MiB with pre-allocated
-memory, the second one being 32MiB with no pre-allocated memory.
-
-```bash
-./cloud-hypervisor \
-    --cpus boot=1 \
-    --memory size=1G \
-    --disk path=focal-server-cloudimg-amd64.raw \
-    --kernel vmlinux \
-    --cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
-    --sgx-epc size=64M,prefault=on size=32M,prefault=off
-```
-
-Once booted, and assuming your guest kernel contains the patches from the
-[KVM SGX Tree](https://github.com/intel/kvm-sgx), you can validate SGX devices
-have been correctly created under `/dev/sgx`:
-
-```bash
-ls /dev/sgx*
-/dev/sgx_enclave  /dev/sgx_provision  /dev/sgx_virt_epc
-```
-
-From this point, it is possible to run any SGX application from the guest, as
-it will access `/dev/sgx_enclave` device to create dedicated SGX enclaves.
-
-Note: There is only one contiguous SGX EPC region, which contains all SGX EPC
-sections. This region is exposed through ACPI and marked as reserved through
-the e820 table. It is treated yet as another device, which means it should
-appear at the end of the guest address space.

docs/io_throttling.md

@@ -1,44 +0,0 @@
-# I/O Throttling
-
-Cloud Hypervisor now supports I/O throttling on virtio-block and virtio-net
-devices. This support is based on the [`rate-limiter` module](https://github.com/firecracker-microvm/firecracker/tree/master/src/rate_limiter)
-from Firecracker. This document explains the user interface of this
-feature, and highlights some internal implementations that can help users
-better understand the expected behavior of I/O throttling in practice.
-
-Cloud Hypervisor allows to limit both the I/O bandwidth (e.g. bytes/s)
-and I/O operations (ops/s) independently. For virtio-net devices, while
-sharing the same "rate limit" from user inputs (on both bandwidth and
-operations), the RX and TX queues are throttled independently.
-To limit the I/O bandwidth, Cloud Hypervisor
-provides three user options, i.e., `bw_size` (bytes), `bw_one_time_burst`
-(bytes), and `bw_refill_time` (ms). Both `bw_size` and `bw_refill_time`
-are required, while `bw_one_time_burst` is optional.
-Internally, these options define a TokenBucket with a maximum capacity
-(`bw_size` bytes), an initial burst size (`bw_one_time_burst`) and an
-interval for refilling purposes (`bw_refill_time`). The "refill-rate" is
-`bw_size` bytes per `bw_refill_time` ms, and it is the constant rate at
-which the tokens replenish. The refill process only starts happening
-after the initial burst budget is consumed. Consumption from the token
-bucket is unbounded in speed which allows for bursts bound in size by
-the amount of tokens available. Once the token bucket is empty,
-consumption speed is bound by the "refill-rate". Similarly, Cloud
-Hypervisor provides another three options for limiting I/O operations,
-i.e., `ops_size` (I/O operations), `bw_one_time_burst` (I/O operations),
-and `bw_refill_time` (ms).
-
-One caveat in the I/O throttling is that every-time the bucket gets
-empty, it will stop I/O operations for a fixed amount of time
-(`cool_down_time`). The `cool_down_time` now is fixed at `100 ms`, it
-can have big implications to the actual rate limit (which can be a lot
-different the expected "refill-rate" derived from user inputs). For
-example, to have a 1000 IOPS limit on a virtio-blk device, users should
-be able to provide either of the following two options:
-`ops_size=1000,ops_refill_time=1000` or
-`ops_size=10,ops_refill_time=10`. However, the actual IOPS limits are
-likely to be ~1000 IOPS and ~100 IOPS respectively. The reason is the
-actual rate limit users get can be as low as
-`ops_size/(ops_refill_time+cool_down_time)`. As a result, it is
-generally advisable to keep `bw/ops_refill_time` larger than `100 ms`
-(`cool_down_time`) to make sure the actual rate limit is close to users'
-expectation ("refill-rate").

docs/iommu.md

@@ -86,11 +86,11 @@ virtual IOMMU:
 
 ```bash
 ./cloud-hypervisor \
-    --cpus boot=1 \
+    --cpus 1 \
     --memory size=512M \
-    --disk path=focal-server-cloudimg-amd64.raw,iommu=on \
-    --kernel custom-vmlinux \
-    --cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
+    --disk path=clear-kvm.img,iommu=on \
+    --kernel custom-bzImage \
+    --cmdline "console=ttyS0 root=/dev/vda3" \
 ```
 
 From a guest perspective, it is easy to verify if the device is protected by
@@ -163,11 +163,11 @@ be consumed.
 
 ```bash
 ./cloud-hypervisor \
-    --cpus boot=1 \
-    --memory size=8G,hugepages=on \
-    --disk path=focal-server-cloudimg-amd64.raw \
-    --kernel custom-vmlinux \
-    --cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw hugepagesz=2M hugepages=2048" \
+    --cpus 1 \
+    --memory size=8G,file=/dev/hugepages \
+    --disk path=clear-kvm.img \
+    --kernel custom-bzImage \
+    --cmdline "console=ttyS0 root=/dev/vda3 hugepagesz=2M hugepages=2048" \
     --net tap=,mac=,iommu=on
 ```
 
@@ -180,11 +180,11 @@ passing through is `0000:00:01.0`.
 
 ```bash
 ./cloud-hypervisor \
-    --cpus boot=1 \
-    --memory size=8G,hugepages=on \
-    --disk path=focal-server-cloudimg-amd64.raw \
-    --kernel custom-vmlinux \
-    --cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw kvm-intel.nested=1 vfio_iommu_type1.allow_unsafe_interrupts rw hugepagesz=2M hugepages=2048" \
+    --cpus 1 \
+    --memory size=8G,file=/dev/hugepages \
+    --disk path=clear-kvm.img \
+    --kernel custom-bzImage \
+    --cmdline "console=ttyS0 root=/dev/vda3 kvm-intel.nested=1 vfio_iommu_type1.allow_unsafe_interrupts rw hugepagesz=2M hugepages=2048" \
     --device path=/sys/bus/pci/devices/0000:00:01.0,iommu=on
 ```
 
@@ -194,17 +194,16 @@ guest, and bind it to VFIO (it should appear as `0000:00:04.0`).
 ```bash
 echo 0000:00:04.0 > /sys/bus/pci/devices/0000\:00\:04.0/driver/unbind
 echo 8086 1502 > /sys/bus/pci/drivers/vfio-pci/new_id
-echo 0000:00:04.0 > /sys/bus/pci/drivers/vfio-pci/bind
 ```
 
 Last thing is to start the L2 guest with the huge pages memory backend.
 
 ```bash
 ./cloud-hypervisor \
-    --cpus boot=1 \
-    --memory size=4G,hugepages=on \
-    --disk path=focal-server-cloudimg-amd64.raw \
-    --kernel custom-vmlinux \
-    --cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
+    --cpus 1 \
+    --memory size=4G,file=/dev/hugepages \
+    --disk path=clear-kvm.img \
+    --kernel custom-bzImage \
+    --cmdline "console=ttyS0 root=/dev/vda3" \
     --device path=/sys/bus/pci/devices/0000:00:04.0
 ```

docs/logging.md

@@ -1,43 +0,0 @@
-# Logging
-
-The target audience of this document is both:
-
-* Developers who want to understand what log level to use and when,
-* Users who want to debug issues with running their workloads in Cloud Hypervisor
-
-## Control
-
-The number of `-v` parameters passed to the `cloud-hypervisor` binary will determine the log level. Currenly the default is log messages up to `WARN:` (`warn!`) are included by default. The `--log-file` allows the log to be sent to a location other than `stderr`.
-
-## Levels
-
-### `error!()`
-
-For immediate, unrecoverable errors where it does not make sense for the execution to continue as the behaviour of the VM is considerablely impacted.
-
-Cloud Hypervisor should exit shortly after reporting this error (with a non-zero exit code). Generally this should be used during initial construction of the VM state before the virtual CPUs have begun running code.
-
-A typical situation where this might occur is when the user is using command line options that conflict with each other or is trying to use a file that is not present on the filesystem.
-
-Users should react to this error by checking their initial VM configuration.
-
-### `warn!()`
-
-A serious problem has occured but the execution of the VM can continue although some functionality might be impacted.
-
-A typical example of where this level of message should be generated is during an API call request that cannot be fulfilled.
-
-The user should investigate the meaning of this warning and take steps to ensure the correct functionality.
-
-
-### `info!()`
-
-Use `-v` to enable.
-
-This level is for the benefit of developers. It should be used for sporadic and infrequent messages. The same message should not "spam" the logs. The VM should be usable when this level of debugging is enabled and trying to use `stdin/stdout` and the logs are going to `stderr`.
-
-### `debug!()`
-
-Use `-vv` to enable.
-
-For the most verbose of logging messages. It is acceptable to "spam" the log with repeated invocations of the same message. This level of logging would be combined with `--log-file`.

docs/macvtap-bridge.md

@@ -1,32 +0,0 @@
-# Using MACVTAP to Bridge onto Host Network
-
-Cloud Hypervisor supports using a MACVTAP device which is derived from a MACVLAN. Full details of configuring MACVLAN or MACVTAP is out of scope of this document. However the example below indicates how to bridge the guest directly onto the the network the host is on. Due to the lack of hairpin mode it not usually possible to reach the guest directly from the host.
-
-```bash
-# The MAC address must be attached to the macvtap and be used inside the guest
-mac="c2:67:4f:53:29:cb"
-# Host network adapter to bridge the guest onto
-host_net="eno1"
-
-# Create the macvtap0 as a new virtual MAC associated with the host network
-sudo ip link add link "$host_net" name macvtap0 type macvtap
-sudo ip link set macvtap0 address "$mac" up
-sudo ip link show macvtap0
-
-# A new character device is created for this interface
-tapindex=$(< /sys/class/net/macvtap0/ifindex)
-tapdevice="/dev/tap$tapindex"
-
-# Ensure that we can access this device
-sudo chown "$UID.$UID" "$tapdevice"
-
-# Use --net fd=3 to point to fd 3 which the shell has opened to point to the /dev/tapN device
-target/debug/cloud-hypervisor \
-	--kernel ~/src/linux/vmlinux \
-	--disk path=~/workloads/focal.raw \
-	--cpus boot=1 --memory size=512M \
-	--cmdline "root=/dev/vda1 console=hvc0" \
-    --net fd=3,mac=$mac 3<>$"$tapdevice"
-```
-
-As the guest is now connected to the same L2 network as the host you can obtain an IP address based on your host network (potentially including via DHCP)

docs/memory.md

@@ -1,453 +0,0 @@
-# Memory
-
-Cloud-Hypervisor has many ways to expose memory to the guest VM. This document
-aims to explain what Cloud-Hypervisor is capable of and how it can be used to
-meet the needs of very different use cases.
-
-## Basic Parameters
-
-`MemoryConfig` or what is known as `--memory` from the CLI perspective is the
-easiest way to get started with Cloud-Hypervisor.
-
-```rust
-struct MemoryConfig {
-    size: u64,
-    mergeable: bool,
-    shared: bool,
-    hugepages: bool,
-    hugepage_size: Option<u64>,
-    hotplug_method: HotplugMethod,
-    hotplug_size: Option<u64>,
-    hotplugged_size: Option<u64>,
-    zones: Option<Vec<MemoryZoneConfig>>,
-}
-```
-
-```
---memory <memory>	Memory parameters "size=<guest_memory_size>,mergeable=on|off,shared=on|off,hugepages=on|off,hotplug_method=acpi|virtio-mem,hotplug_size=<hotpluggable_memory_size>,hotplugged_size=<hotplugged_memory_size>"
-```
-
-### `size`
-
-Size of the RAM in the guest VM.
-
-This option is mandatory when using the `--memory` parameter.
-
-Value is an unsigned integer of 64 bits.
-
-_Example_
-
-```
---memory size=1G
-```
-
-### `mergeable`
-
-Specifies if the pages from the guest RAM must be marked as _mergeable_. In
-case this option is `true` or `on`, the pages will be marked with `madvise(2)`
-to let the host kernel know which pages are eligible for being merged by the
-KSM daemon.
-
-This option can be used when trying to reach a higher density of VMs running
-on a single host, as it will reduce the amount of memory consumed by each VM.
-
-By default this option is turned off.
-
-_Example_
-
-```
---memory size=1G,mergeable=on
-```
-
-### `shared`
-
-Specifies if the memory must be `mmap(2)` with `MAP_SHARED` flag.
-
-By sharing a memory mapping, one can share the guest RAM with other processes
-running on the host. One can use this option when running vhost-user devices
-as part of the VM device model, as they will be driven by standalone daemons
-needing access to the guest RAM content.
-
-By default this option is turned off, which results in performing `mmap(2)`
-with `MAP_PRIVATE` flag.
-
-_Example_
-
-```
---memory size=1G,shared=on
-```
-
-### `hugepages` and `hugepage_size`
-
-Specifies if the memory must be created and `mmap(2)` with `MAP_HUGETLB` and size
-flags. This performs a memory mapping relying on the specified huge page size. If no huge page size is supplied the system's default huge page size is used.
-
-By using hugepages, one can improve the overall performance of the VM, assuming
-the guest will allocate hugepages as well. Another interesting use case is VFIO
-as it speeds up the VM's boot time since the amount of IOMMU mappings are
-reduced.
-
-The user is responsible for ensuring there are sufficient huge pages of the specified size for the VMM to use. Failure to do so may result in strange VMM behaviour.
-
-By default this option is turned off.
-
-_Example_
-
-```
---memory size=1G,hugepages=on,hugepage_size=2M
-```
-
-### `hotplug_method`
-
-Selects the way of adding and/or removing memory to/from a booted VM.
-
-Possible values are `acpi` and `virtio-mem`. Default value is `acpi`.
-
-_Example_
-
-```
---memory size=1G,hotplug_method=acpi
-```
-
-### `hotplug_size`
-
-Amount of memory that can be dynamically added to the VM.
-
-Value is an unsigned integer of 64 bits. A value of 0 is invalid.
-
-_Example_
-
-```
---memory size=1G,hotplug_size=1G
-```
-
-### `hotplugged_size`
-
-Amount of memory that will be dynamically added to the VM at boot. This option
-allows for starting a VM with a certain amount of memory that can be reduced
-during runtime.
-
-This is only valid when the `hotplug_method` is `virtio-mem` as it does not
-make sense for the `acpi` use case. When using ACPI, the memory can't be
-resized after it has been extended.
-
-This option is only valid when `hotplug_size` is specified, and its value can't
-exceed the value of `hotplug_size`.
-
-Value is an unsigned integer of 64 bits. A value of 0 is invalid.
-
-_Example_
-
-```
---memory size=1G,hotplug_method=virtio-mem,hotplug_size=1G,hotplugged_size=512M
-```
-
-## Advanced Parameters
-
-`MemoryZoneConfig` or what is known as `--memory-zone` from the CLI perspective
-is a power user parameter. It allows for a full description of the guest RAM,
-describing how every memory region is backed and exposed to the guest.
-
-```rust
-struct MemoryZoneConfig {
-    id: String,
-    size: u64,
-    file: Option<PathBuf>,
-    shared: bool,
-    hugepages: bool,
-    host_numa_node: Option<u32>,
-    hotplug_size: Option<u64>,
-    hotplugged_size: Option<u64>,
-}
-```
-
-```
---memory-zone <memory-zone>	User defined memory zone parameters "size=<guest_memory_region_size>,file=<backing_file>,shared=on|off,hugepages=on|off,host_numa_node=<node_id>,id=<zone_identifier>,hotplug_size=<hotpluggable_memory_size>,hotplugged_size=<hotplugged_memory_size>"
-```
-
-This parameter expects one or more occurences, allowing for a list of memory
-zones to be defined. It must be used with `--memory size=0`, clearly indicating
-that the memory will be described through advanced parameters.
-
-Each zone is given a list of options which we detail through the following
-sections.
-
-### `id`
-
-Memory zone identifier. This identifier must be unique, otherwise an error will
-be returned.
-
-This option is useful when referring to a memory zone previously created. In
-particular, the `--numa` parameter can associate a memory zone to a specific
-NUMA node based on the memory zone identifier.
-
-This option is mandatory when using the `--memory-zone` parameter.
-
-Value is a string.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G
-```
-
-### `size`
-
-Size of the memory zone.
-
-This option is mandatory when using the `--memory-zone` parameter.
-
-Value is an unsigned integer of 64 bits.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G
-```
-
-### `file`
-
-Path to the file backing the memory zone. This can be either a file or a
-directory. In case of a file, it will be opened and used as the backing file
-for the `mmap(2)` operation. In case of a directory, a temporary file with no
-hard link on the filesystem will be created. This file will be used as the
-backing file for the `mmap(2)` operation.
-
-This option can be particularly useful when trying to back a part of the guest
-RAM with a well known file. In the context of the snapshot/restore feature, and
-if the provided path is a file, the snapshot operation will not perform any
-copy of the guest RAM content for this specific memory zone since the user has
-access to it and it would duplicate data already stored on the current
-filesystem.
-
-Value is a string.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G,file=/foo/bar
-```
-
-### `shared`
-
-Specifies if the memory zone must be `mmap(2)` with `MAP_SHARED` flag.
-
-By sharing a memory zone mapping, one can share part of the guest RAM with
-other processes running on the host. One can use this option when running
-vhost-user devices as part of the VM device model, as they will be driven
-by standalone daemons needing access to the guest RAM content.
-
-By default this option is turned off, which result in performing `mmap(2)`
-with `MAP_PRIVATE` flag.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G,shared=on
-```
-
-### `hugepages`
-
-Specifies if the memory zone must be `mmap(2)` with `MAP_HUGETLB` and
-`MAP_HUGE_2MB` flags. This performs a memory zone mapping relying on 2MiB
-pages instead of the default 4kiB pages.
-
-By using hugepages, one can improve the overall performance of the VM, assuming
-the guest will allocate hugepages as well. Another interesting use case is VFIO
-as it speeds up the VM's boot time since the amount of IOMMU mappings are
-reduced.
-
-By default this option is turned off.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G,hugepages=on
-```
-
-### `host_numa_node`
-
-Node identifier of a node present on the host. This option will let the user
-pick a specific NUMA node from which the memory must be allocated. After the
-memory zone is `mmap(2)`, the NUMA policy for this memory mapping will be
-applied through `mbind(2)`, relying on the provided node identifier. If the
-node does not exist on the host, the call to `mbind(2)` will fail.
-
-This option is useful when trying to back a VM memory with a specific type of
-memory from the host. Assuming a host has two types of memory, with one slower
-than the other, each related to a distinct NUMA node, one could create a VM
-with slower memory accesses by backing the entire guest RAM from the furthest
-NUMA node on the host.
-
-This option also gives the opportunity to create a VM with non uniform memory
-accesses as one could define a first memory zone backed by fast memory, and a
-second memory zone backed by slow memory.
-
-Value is an unsigned integer of 32 bits.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G,host_numa_node=0
-```
-
-### `hotplug_size`
-
-Amount of memory that can be dynamically added to the memory zone. Since
-`virtio-mem` is the only way of resizing a memory zone, one must specify
-the `hotplug_method=virtio-mem` to the `--memory` parameter.
-
-Value is an unsigned integer of 64 bits. A value of 0 is invalid.
-
-_Example_
-
-```
---memory size=0,hotplug_method=virtio-mem
---memory-zone id=mem0,size=1G,hotplug_size=1G
-```
-
-### `hotplugged_size`
-
-Amount of memory that will be dynamically added to a memory zone at VM's boot.
-This option allows for starting a VM with a certain amount of memory that can
-be reduced during runtime.
-
-This is only valid when the `hotplug_method` is `virtio-mem` as it does not
-make sense for the `acpi` use case. When using ACPI, the memory can't be
-resized after it has been extended.
-
-This option is only valid when `hotplug_size` is specified, and its value can't
-exceed the value of `hotplug_size`.
-
-Value is an unsigned integer of 64 bits. A value of 0 is invalid.
-
-_Example_
-
-```
---memory size=0,hotplug_method=virtio-mem
---memory-zone id=mem0,size=1G,hotplug_size=1G,hotplugged_size=512M
-```
-
-## NUMA settings
-
-`NumaConfig` or what is known as `--numa` from the CLI perspective has been
-introduced to define a guest NUMA topology. It allows for a fine description
-about the CPUs and memory ranges associated with each NUMA node. Additionally
-it allows for specifying the distance between each NUMA node.
-
-```rust
-struct NumaConfig {
-    id: u32,
-    cpus: Option<Vec<u8>>,
-    distances: Option<Vec<NumaDistance>>,
-    memory_zones: Option<Vec<String>>,
-}
-```
-
-```
---numa <numa>	Settings related to a given NUMA node "id=<node_id>,cpus=<cpus_id>,distances=<list_of_distances_to_destination_nodes>,memory_zones=<list_of_memory_zones>"
-```
-
-### `guest_numa_id`
-
-Node identifier of a guest NUMA node. This identifier must be unique, otherwise
-an error will be returned.
-
-This option is mandatory when using the `--numa` parameter.
-
-Value is an unsigned integer of 32 bits.
-
-_Example_
-
-```
---numa guest_numa_id=0
-```
-
-### `cpus`
-
-List of virtual CPUs attached to the guest NUMA node identified by the
-`guest_numa_id` option. This allows for describing a list of CPUs which
-must be seen by the guest as belonging to the NUMA node `guest_numa_id`.
-
-One can use this option for a fine grained description of the NUMA topology
-regarding the CPUs associated with it, which might help the guest run more
-efficiently.
-
-Multiple values can be provided to define the list. Each value is an unsigned
-integer of 8 bits.
-
-For instance, if one needs to attach all CPUs from 0 to 4 to a specific node,
-the syntax using `-` will help define a contiguous range with `cpus=0-4`. The
-same example could also be described with `cpus=0:1:2:3:4`.
-
-A combination of both `-` and `:` separators is useful when one might need to
-describe a list containing all CPUs from 0 to 99 and the CPU 255, as it could
-simply be described with `cpus=0-99:255`.
-
-_Example_
-
-```
---cpus boot=8
---numa guest_numa_id=0,cpus=1-3:7
---numa guest_numa_id=1,cpus=0:4-6
-```
-
-### `distances`
-
-List of distances between the current NUMA node referred by `guest_numa_id`
-and the destination NUMA nodes listed along with distances. This option let
-the user choose the distances between guest NUMA nodes. This is important to
-provide an accurate description of the way non uniform memory accesses will
-perform in the guest.
-
-One or more tuple of two values must be provided through this option. The first
-value is an unsigned integer of 32 bits as it represents the destination NUMA
-node. The second value is an unsigned integer of 8 bits as it represents the
-distance between the current NUMA node and the destination NUMA node. The two
-values are separated by `@` (`value1@value2`), meaning the destination NUMA
-node `value1` is located at a distance of `value2`. Each tuple is separated
-from the others with `:` separator.
-
-For instance, if one wants to define 3 NUMA nodes, with each node located at
-different distances, it can be described with the following example.
-
-_Example_
-
-```
---numa guest_numa_id=0,distances=1@15:2@25
---numa guest_numa_id=1,distances=0@15:2@20
---numa guest_numa_id=2,distances=0@25:1@20
-```
-
-### `memory_zones`
-
-List of memory zones attached to the guest NUMA node identified by the
-`guest_numa_id` option. This allows for describing a list of memory ranges
-which must be seen by the guest as belonging to the NUMA node `guest_numa_id`.
-
-This option can be very useful and powerful when combined with `host_numa_node`
-option from `--memory-zone` parameter as it allows for creating a VM with non
-uniform memory accesses, and let the guest know about it. It allows for
-exposing memory zones through different NUMA nodes, which can help the guest
-workload run more efficiently.
-
-Multiple values can be provided to define the list. Each value is a string
-referring to an existing memory zone identifier. Values are separated from
-each other with the `:` separator.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G
---memory-zone id=mem1,size=1G
---memory-zone id=mem2,size=1G
---numa guest_numa_id=0,memory_zones=mem0:mem2
---numa guest_numa_id=1,memory_zones=mem1
-```

docs/networking.md

@@ -1,8 +1,8 @@
 # How to use networking
 
-cloud-hypervisor can emulate one or more virtual network interfaces, represented at the hypervisor host by [tap devices](https://www.kernel.org/doc/Documentation/networking/tuntap.txt). This guide briefly describes, in a manual and distribution neutral way, how to setup and use networking with cloud-hypervisor.
+cloud-hypervisor can emulate one or more virtual network interfaces, represented at the hypervisor host by [tap devices](https://www.kernel.org/doc/Documentation/networking/tuntap.txt). This guide briefly describes, in a manual and distribution neutral way, how to setup and use networking with cloud-hypevisor.
 
-## Multiple queue support for net devices
+## Multiple queue support for net devices ##
 
 While multiple vcpus defined for guest, to gain the benefit of vcpu scalable to improve performance, it suggests to define multiple queue pairs for net devices, one Tx/Rx queue pair per one vcpu, that means the number of queue pairs at least is equal to the vcpu count. In that case, after virtnet driver set cpu affinity for virtqueues in guest kernel, vcpus could handle interrupt from different virtqueue pairs in parallel.
 
@@ -14,7 +14,7 @@ Note:
 
 - Currently, it does not support to use ethtool to change the combined queue numbers in guest.
 - Multiple queue is enabled for vhost-user-net backend in cloud-hypervisor, however, multiple thread is not added to handle mq, thus, the performance for vhost-user-net backend is not supposed to be improved. The multiple thread will be added for backend later.
-- Performance test for vhost-user-net will be covered once vhost-user-net backend has multiple thread supported.
+- Performance test for vhost-user-net will be covered once vhost-user-net backend has mulitple thread supported.
 - Performance test for virtio-net is done by comparing 2 queue pairs with 1 queue pairs, that to run 2 iperf3 sessions in the same test environments, throughput is improved about 37%.
 
 ## Start cloud-hypervisor with net devices
@@ -23,25 +23,25 @@ Use one `--net` command-line argument from cloud-hypervisor to specify the emula
 
 ```bash
 ./cloud-hypervisor \
-    --cpus boot=4 \
+    --cpus 4 \
     --memory "size=512M" \
-    --disk path=focal-server-cloudimg-amd64.raw \
+    --disk path=my-root-disk.img \
     --kernel my-vmlinux.bin \
-    --cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
+    --cmdline "console=ttyS0 reboot=k panic=1 nomodules root=/dev/vda3" \
     --net tap=ich0,mac=a4:a1:c2:00:00:01,ip=192.168.4.2,mask=255.255.255.0,num_queues=2,queue_size=256 \
           tap=ich1,mac=a4:a1:c2:00:00:02,ip=10.0.1.2,mask=255.255.255.0,num_queues=2,queue_size=256
 ```
 
 The `--net` argument takes 1 or more space-separated strings of key value pairs containing the following 4 keys or fields:
 
-| Name       | Purpose                | Optional |
-| ---------- | ---------------------- | -------- |
-| tap        | tap device name        | Yes      |
-| mac        | vNIC mac address       | Yes      |
-| ip         | tap IP IP address      | yes      |
-| mask       | tap IP netmask         | Yes      |
-| num_queues | the number of queues   | yes      |
-| queue_size | the size of each queue | Yes      |
+| Name       | Purpose                    | Optional  |
+| -----------|----------------------------| ----------|
+| tap        | tap device name            | Yes       |
+| mac        | vNIC mac address           | Yes       |
+| ip         | tap IP IP address          | yes       |
+| mask       | tap IP netmask             | Yes       |
+| num_queues | the number of queues       | yes       |
+| queue_size | the size of each queue     | Yes       |
 
 num_queues is the total number of tx and rx queues, the default value is 2, and it could be increased by multiples of 2. Additionally, num_queues is suggested to be as 2 times of vcpu count. The default value for queue_size is 256.
 
@@ -51,11 +51,6 @@ If the tap device is pre-created on host before guest boot up. To use multiple q
 [root@localhost ~]# ip tuntap add name ich0 mode tap multi_queue
 ```
 
-And the `--net` device should specify support for multiple queues. `num_queues` must be a multiple of 2 starting at least from 4 since multiple queues really means multiple queue pairs. We need at least 2 pairs for this configuration to be correct:
-
-```bash
---net tap=ich0,mac=a4:a1:c2:00:00:01,ip=192.168.4.2,mask=255.255.255.0,num_queues=4,queue_size=256
-```
 
 ## Configure the tap devices
 
@@ -104,7 +99,6 @@ bridge name     bridge id               STP enabled     interfaces
 ich-dpl         8000.067afc1b9a67       no              ich1
 ich-int         8000.725412ffce6f       no              ich0
 ```
-
 This completes the layer 2 wiring: The cloud-hypervisor is now connected to the hypervisor host via the 2 linux bridges.
 
 ## IP (Layer 3) provisioning
@@ -117,7 +111,6 @@ On the hypervisor host add the network gateway IP address of each network to the
 root@host:~# ip addr add 192.168.4.1/24 dev ich-int
 root@host:~# ip addr add 10.0.1.1/24 dev ich-dpl
 ```
-
 The routing table of the hypervisor host should now also have corresponding routing entries:
 
 ```bash
@@ -129,10 +122,9 @@ Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
 192.168.4.0     0.0.0.0         255.255.255.0   U     0      0        0 ich-int
 192.168.178.0   0.0.0.0         255.255.255.0   U     600    0        0 wlan1
 ```
-
 ### Virtual Machine
 
-Within the virtual machine set the vNIC's to up state and provision the corresponding IP addresses on the 2 vNIC's. The steps outlined below use the ip command as an example. Alternative distribution specific procedures can also apply.
+Within the virtual machine set the vNIC's to up state and provision the corresponding IP addresses on the 2 vNIC's. The steps outlined below use the ip command as an example. Alternative distribution specific procedures can also apply.   
 
 ```bash
 root@guest:~# ip link set up enp0s2
@@ -168,7 +160,7 @@ root@192.168.4.2's password:
 Linux cloud-hypervisor 5.2.0 #2 SMP Thu Jul 11 08:08:16 CEST 2019 x86_64
 
 Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
-permitted by applicable law.
+permitted by applicable law.                                                         
 
 
 Last login: Fri Jul 12 13:27:56 2019 from 192.168.4.1
@@ -192,7 +184,7 @@ nameserver 192.168.178.1
 make sure that the default gateway of the hypervisor host (in this example host 192.168.178.1 which is an adsl router) has an entry in the routing table for the 192.168.4.0/24 network otherwise IP connectivity will not work.
 
 ```bash
-root@guest:~# nslookup  ftp.nl.debian.org
+root@guest:~# nslookup  ftp.nl.debian.org       
 Server:         192.168.178.1
 Address:        192.168.178.1#53
 

docs/profiling.md

@@ -1,45 +0,0 @@
-# Profiling
-
-`perf` can be used to profile the `cloud-hypervisor` binary but it is necessary to make some modifications to the the build in order to produce a binary that gives useful results.
-
-## Building a suitable binary
-
-Modify the `Cargo.toml` file to add `debug = 1` to the `[profile.release]` block. It should look like this:
-
-```
-[profile.release]
-lto = true
-debug = 1
-```
-
-This adds the symbol information to the release binary but does not otherwise affect the performance.
-
-The binary must also be built with frame pointers included so that the call graph can be captured by the profiler.
-
-```
-$ cargo clean && RUSTFLAGS='-C force-frame-pointers=y' cargo build --release
-```
-
-## Profiling
-
-`perf` may then be used in the usual manner:
-
-e.g.
-
-```
-$ perf record -g target/release/cloud-hypervisor \
-        --kernel ~/src/linux/vmlinux \
-        --pmem file=~/workloads/focal.raw \
-        --cpus boot=1 --memory size=1G \
-        --cmdline "root=/dev/pmem0p1 console=ttyS0" \
-        --serial tty --console off \
-        --api-socket=/tmp/api1
-```
-
-For analysing the samples:
-
-```
-$ perf report -g
-```
-
-If profiling with a network device attached either the TAP device must be already created and configured or the profiling must be done as root so that the TAP device can be created.

docs/seccomp.md

@@ -1,68 +0,0 @@
-# Seccomp filtering
-
-As a means to harden Cloud Hypervisor's security, the project leverages seccomp
-filtering.
-
-## What is seccomp filtering
-
-A seccomp filter is a way for a process to tell the kernel which system calls
-are authorized.
-In case this process calls into a prohibited system call, the kernel will kill
-the process right away.
-
-## How does it apply to Cloud Hypervisor
-
-Cloud Hypervisor is a multi threaded application. It spawns dedicated threads
-for virtual CPUs, virtio devices and HTTP server, along with the main thread
-representing the VMM.
-
-Each of these threads has a limited scope of what it is expected to perform,
-which is why different filters are applied to each of them.
-
-By default, Cloud Hypervisor enables seccomp filtering as the project believes
-that security should not be an option.
-
-For development and debugging purposes, one might want to disable this feature
-or log the faulty system call.
-
-### Disabling seccomp filters
-
-Append `--seccomp false` to Cloud Hypervisor's command line to prevent seccomp
-filtering from being applied.
-
-### Logging prohibited system calls
-
-In the context of debug, one alternative to disabling seccomp filtering is to
-log faulty system calls that would have caused the application to be killed by
-the kernel.
-
-Append `--seccomp log` to Cloud Hypervisor's command line to enable faulty
-system calls to be logged.
-
-The kernel running on the host machine must have the `audit` parameter enabled.
-If this is not the case, update kernel boot options by appending `audit=1`.
-
-Unauthorized system calls will be logged to the journal similarly to the
-following example
-
-```
-type=SECCOMP msg=audit(1423263412.694:7878): auid=1000 uid=1000 gid=1000 ses=3 subj=unconfined_u:unconfined_r:cloud_hypervisor:s0-s0:c0.c1023 pid=1193 comm="cloud-hypervisor" exe="/usr/bin/cloud-hypervisor" sig=0 arch=c000003e syscall=47 compat=0 ip=0x7f4f63982604 code=0x50000
-```
-
-Provided `ausyscall` has been installed on the host, the system call can be
-identified with
-
-```
-$ ausyscall 47
-recvmsg
-```
-
-### Further debug with `strace`
-
-One more way of debugging seccomp related issues is to use the `strace` tool as
-it will log every system call issued by the process. It is important to use
-`-f` option in order to trace each and every thread belonging to the process.
-
-```
-strace -f ./cloud-hypervisor ...
-```

docs/snapshot_restore.md

@@ -1,112 +0,0 @@
-# Snapshot and Restore
-
-The goal for the snapshot/restore feature is to provide the user with the
-ability to take a snapshot of a previously paused virtual machine. This
-snapshot can be used as the base for creating new identical virtual machines,
-without the need to boot them from scratch. The restore codepath takes the
-snapshot and creates the exact same virtual machine, restoring the previously
-saved states. The new virtual machine is restored in a paused state, as it was
-before the snapshot was performed.
-
-This feature is important for the project as it establishes the first step
-towards the support for live migration.
-
-## Snapshot a Cloud-Hypervisor VM
-
-First thing, we must run a Cloud-Hypervisor VM:
-
-```bash
-./cloud-hypervisor \
-    --api-socket /tmp/cloud-hypervisor.sock \
-    --cpus boot=4 \
-    --memory size=4G \
-    --kernel vmlinux \
-    --cmdline "root=/dev/vda1 console=hvc0 rw" \
-    --disk path=focal-server-cloudimg-amd64.raw
-```
-
-At any point in time when the VM is running, one might choose to pause it:
-
-```bash
-./ch-remote --api-socket=/tmp/cloud-hypervisor.sock pause
-```
-
-Once paused, the VM can be safely snapshot into the specified directory and
-using the following command:
-
-```bash
-./ch-remote --api-socket=/tmp/cloud-hypervisor.sock snapshot file:///home/foo/snapshot
-```
-
-Given the directory was present on the system, the snapshot will succeed and
-it should contain the following files:
-
-```bash
-ll /home/foo/snapshot/
-total 4194536
-drwxrwxr-x  2 foo bar       4096 Jul 22 11:50 ./
-drwxr-xr-x 47 foo bar       4096 Jul 22 11:47 ../
--rw-------  1 foo bar 3221225472 Jul 22 11:19 memory-region-0
--rw-------  1 foo bar 1073741824 Jul 22 11:19 memory-region-1
--rw-------  1 foo bar     217853 Jul 22 11:19 vm.json
-```
-
-In this particular example, we can observe that 2 memory region files were
-created. That is explained by the size of the guest RAM, which is 4GiB in this
-case. Because it exceeds 3GiB (which is where we can find a ~1GiB memory hole),
-Cloud-Hypervisor needs 2 distinct memory regions to be created. Each memory
-region's content is stored through a dedicated file, which explains why we end
-up with 2 different files, the first one containing the guest RAM range 0-3GiB
-and the second one containing the guest RAM range 3-4GiB.
-
-`vm.json` gathers all information related to the virtual machine configuration
-and state. The configuration bits are used to create a similar virtual machine
-with the correct amount of CPUs, RAM, and other expected devices. The state
-bits are used to restore each component in the state it was left before the
-snapshot occurred.
-
-## Restore a Cloud-Hypervisor VM
-
-Given that one has access to an existing snapshot in `/home/foo/snapshot`,
-it is possible to create a new VM based on this snapshot with the following 
-command:
-
-```bash
-./cloud-hypervisor \
-    --api-socket /tmp/cloud-hypervisor.sock \
-    --restore source_url=file:///home/foo/snapshot
-```
-
-Or using two different commands from two terminals:
-
-```bash
-# First terminal
-./cloud-hypervisor --api-socket /tmp/cloud-hypervisor.sock
-
-# Second terminal
-./ch-remote --api-socket=/tmp/cloud-hypervisor.sock restore source_url=file:///home/foo/snapshot
-```
-
-Remember the VM is restored in a `paused` state, which was the VM's state when
-it was snapshot. For this reason, one must explicitly `resume` the VM before to
-start using it.
-
-```bash
-./ch-remote --api-socket=/tmp/cloud-hypervisor.sock resume
-```
-
-At this point, the VM is fully restored and is identical to the VM which was
-snapshot earlier.
-
-## Limitations
-
-The support of snapshot/restore feature is still experimental, meaning one
-might still find some bugs associated with it.
-
-Additionally, some devices and features don't support to be snapshot and
-restored yet:
-- `vhost-user` devices
-- `virtio-mem`
-- Intel SGX
-
-VFIO devices are out of scope.

docs/uefi.md

@@ -1,75 +0,0 @@
-# UEFI Boot
-
-Cloud Hypervisor supports UEFI boot through the utilization of the EDK II based UEFI firmware. 
-
-## Building UEFI Firmware
-
-To avoid any unnecessary issues, it is recommended to use Ubuntu 18.04 and its default toolset. Any other compatible Linux distribution is otherwise suitable, however it is suggested to use a temporary Docker container with Ubuntu 18.04 for a quick build on an existing Linux machine.
-
-The commands below will compile an OVMF firmware suitable for Cloud Hypervisor.
-
-```shell
-sudo apt-get update
-sudo apt-get install uuid-dev nasm iasl build-essential python3-distutils git
-
-git clone https://github.com/cloud-hypervisor/edk2 -b ch
-cd edk2
-. edksetup.sh
-git submodule update --init
-
-echo "ACTIVE_PLATFORM=OvmfPkg/OvmfCh.dsc" >> Conf/target.txt
-echo "TARGET_ARCH=X64" >> Conf/target.txt
-echo "TOOL_CHAIN_TAG=GCC5" >> Conf/target.txt
-
-make -C ./BaseTools
-build
-```
-
-After the successful build, the resulting firmware binaries are available under `Build/OvmfCh/DEBUG_GCC5/FV` underneath the edk2 checkout.
-
-## Using OVMF Binaries
-
-Any UEFI capable image can be booted using the Cloud Hypervisor specific firmware. Windows guests under Cloud Hypervisor only support UEFI boot, therefore OVMF is mandatory there.
-
-To make Cloud Hypervisor use UEFI boot, pass the `OVMF.fd` file path as an argument to the `--kernel` option. The firmware file will be opened in read only mode.
-
-The same firmware can be used with Cloud Hypervisor or with QEMU. This is particularly useful if using QEMU for the preparation phase.
-
-## Building UEFI Firmware with Compatibility Support Module (CSM)
-
-CSM is a module that allows to boot legacy operating systems using the OVMF firmware. OVMF can embed a CSM build of SeaBIOS. To build the SeaBIOS with CSM support, add `CONFIG_CSM=y` to `.config` before the build. The outcome `out/Csm16.bin` is to be moved into `OvmfPkg/Csm/Csm16/Csm16.bin` before OVMF is built. Then, the OVMF build will have to be passed the `-D CSM_ENABLE` option in order to generate a legacy aware UEFI firmware. At the current stage, all the necessary patches are included in the Cloud Hypervisor specific [SeaBIOS branch](https://github.com/cloud-hypervisor/seabios/tree/ch). Taking into account the previous instructions, the modified command sequence to compile an OVMF binary with CSM support is the following one:
-
-```shell
-sudo apt-get update
-sudo apt-get install uuid-dev nasm iasl build-essential python3-distutils git
-
-git checkout https://github.com/cloud-hypervisor/seabios -b ch
-cd seabios
-make menuconfig
-# Enable `CONFIG_CSM` and `CONFIG_QEMU_HARDWARE`
-make CONFIG_CSM=y CONFIG_QEMU_HARDWARE=y
-cd ..
-
-git clone https://github.com/cloud-hypervisor/edk2 -b ch
-cd edk2
-. edksetup.sh
-git submodule update --init
-cp ../seabios/out/Csm16.bin OvmfPkg/Csm/Csm16/
-
-echo "ACTIVE_PLATFORM=OvmfPkg/OvmfCh.dsc" >> Conf/target.txt
-echo "TARGET_ARCH=X64" >> Conf/target.txt
-echo "TOOL_CHAIN_TAG=GCC5" >> Conf/target.txt
-
-make -C ./BaseTools
-build
-
-```
-
-Please note, that the CSM support has currently only been tested with Linux guests. There are no plans to provide legacy support for other OSes (e.g. Windows).
-
-# Links
-
-- [OVMF wiki](https://github.com/tianocore/tianocore.github.io/wiki/OVMF) 
-- [Cloud Hypervisor specific tree](https://github.com/cloud-hypervisor/edk2/tree/ch)
-- [Redhat OVMF Status Report](https://access.redhat.com/sites/default/files/attachments/ovmf-whtepaper-031815.pdf)
-- [SeaBIOS Build Overview](https://www.seabios.org/Build_overview#Build_as_a_UEFI_Compatibility_Support_Module_.28CSM.29)

docs/vfio.md

@@ -54,7 +54,6 @@ $ lspci -n -s 01:00.0
 01:00.0 ff00: 10ec:525a (rev 01)
 
 $ echo 10ec 525a > /sys/bus/pci/drivers/vfio-pci/new_id
-$ echo 0000:01:00.0 > /sys/bus/pci/drivers/vfio-pci/bind
 ```
 
 Now the device is managed by the VFIO framework.
@@ -67,10 +66,10 @@ takes the device's sysfs path as an argument. In our example it is
 ```
 ./target/debug/cloud-hypervisor \
     --kernel ~/vmlinux \
-    --disk path=~/focal-server-cloudimg-amd64.raw \
+    --disk path=~/clear-29160-kvm.img \
     --console off \
     --serial tty \
-    --cmdline "console=ttyS0 root=/dev/vda1 rw" \
+    --cmdline "console=ttyS0 reboot=k panic=1 nomodules i8042.noaux i8042.nomux i8042.nopnp i8042.dumbkbd root=/dev/vda3" \
     --cpus 4 \
     --memory size=512M \
     --device path=/sys/bus/pci/devices/0000:01:00.0/
@@ -79,3 +78,5 @@ takes the device's sysfs path as an argument. In our example it is
 The guest kernel will then detect the card reader on its PCI bus and provided
 that support for this device is enabled, it will probe and enable it for the
 guest to use.
+
+

docs/vhost-user-blk-testing.md

@@ -1,104 +0,0 @@
-# How to test vhost-user-blk with SPDK
-
-The purpose of this document is to illustrate how to test vhost-user-blk in Cloud Hypervisor with SPDK as the backend.
-
-## Framework
-
-It's a simple test to validate the block read/write between VM and block backend.
-```
-             +----+----------+          +-------------+-----------+
-             |    |          |          |             |           |
-             |    |vhost-user|----------| vhost-user  |    dpdk   |
-             |    |blk device|          | port 1      |           |
-             |    |          |          |             |           |
-             |    +----------+          +-------------+-----------+
-             |               |          |                         |
-             |      vm       |          |           spdk          |
-             |               |          |                         |
-          +--+----------------------------------------------------+--+
-          |  |                  hugepages                         |  |
-          |  +----------------------------------------------------+  |
-          |                                                          |
-          |                       host                               |
-          |                                                          |
-          +----------------------------------------------------------+
-```
-## Prerequisites
-
-Prior to running the test, the following steps need to be performed.
-- Enable hugepages
-- Install SPDK
-
-Here are some good references for detailing them.
-- spdk
-	* https://spdk.io/doc/
-
-## Test environment
-
-The below test environment is based on ubuntu release(16.04.1 LTS), as for other system, please check related document.
-The test runs with multiple queue (MQ) support enabled, using 4 queues defined for both SPDK and the virtual machine.
-Here are the details on how the test can be run.
-
-### The hugepages settings in host linux
-Add "default_hugepagesz=1G hugepagesz=1G hugepages=2" into host linux cmdline.
-As for how to change Ubuntu linux cmdline in grub file, please ref below link:
-https://www.ostechnix.com/configure-grub-2-boot-loader-settings-ubuntu-16-04/
-reboot Ubuntu
-sudo mount -t hugetlbfs -o pagesize=1G none /dev/hugepages
-
-### Download the SPDK code
-git clone https://github.com/spdk/spdk
-cd spdk
-git submodule update --init
-
-### Create the build dep
-./scripts/pkgdep.sh
-
-### Build spdk
-./configure
-make
-
-### Set the SPDk environment
-sudo HUGEMEM=2048 scripts/setup.sh
-sudo ./app/vhost/vhost -S /var/tmp -s 1024 -m 0x3 &
-
-### Create 512M block device
-sudo scripts/rpc.py bdev_malloc_create 512 512 -b Malloc0
-sudo scripts/rpc.py vhost_create_blk_controller --cpumask 0x1 vhost.1 Malloc0
-
-_Launch the VM_
-
-VMs run in client mode. They connect to the socket created by the `dpdkvhostuser` in the SPDK backend.
-```bash
-# From the test terminal. We need to create one vhost-user-blk device for the --disk.
-./cloud-hypervisor \
-        --cpus boot=4 \
-        --memory size=1024M,hugepages=on,shared=true \
-        --kernel linux/arch/x86/boot/compressed/vmlinux.bin \
-        --cmdline "console=ttyS0 root=/dev/vda1 rw iommu=off" \
-        --disk path=images/focal-server-cloudimg-amd64.raw vhost_user=true,socket=/var/tmp/vhost.1,num_queues=4,queue_size=128 \
-        --console off \
-        --serial tty \
-        --rng
-```
-
-```bash
-# How to test the vhost-user-blk device with SPDK backend
-login in guest
-
-# Use lsblk command to find out vhost-user-blk device
-lsblk
-NAME    MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
-vda     252:0    0  2.2G  0 disk 
-├─vda1  252:1    0  2.1G  0 part /
-├─vda14 252:14   0    4M  0 part 
-└─vda15 252:15   0  106M  0 part /boot/efi
-vdb    253:16   0  512M  0 disk
-
-The vhost-user-blk device is /dev/vdb
-
-# How to do simple read/write test
-dd if=/dev/vdb of=/dev/null bs=2M iflag=direct
-dd of=/dev/vdb if=/dev/zero bs=2M oflag=direct count=256
-
-If you want to do fio test, please install fio binary into guest. The detailed info is not listed here.

docs/vhost-user-net-testing.md

@@ -1,132 +0,0 @@
-# How to test Vhost-user net with OpenVSwitch/DPDK
-
-The purpose of this document is to illustrate how to test vhost-user-net in cloud-hypervisor with OVS/DPDK as the backend.
-
-## Framework
-
-It's a simple test to validate the communication between two virtual machine, connecting them to vhost-user ports respectively provided by `OVS/DPDK`.
-```
-             +----+----------+          +-------------+-----------+-------------+          +----------+----+  
-             |    |          |          |             |           |             |          |          |    | 
-             |    |vhost-user|----------| vhost-user  |   ovs     | vhost-user  |----------|vhost-user|    |           
-             |    |net device|          | port 1      |           | port 2      |          |net device|    |           
-             |    |          |          |             |           |             |          |          |    |           
-             |    +----------+          +-------------+-----------+-------------+          +----------+    |           
-             |               |          |                                       |          |               |           
-             |vm1            |          |                  dpdk                 |          |           vm2 |           
-             |               |          |                                       |          |               |           
-          +--+---------------------------------------------------------------------------------------------+--+        
-          |  |                                       hugepages                                             |  |        
-          |  +---------------------------------------------------------------------------------------------+  |        
-          |                                                                                                   |        
-          |                                              host                                                 |        
-          |                                                                                                   |  
-          +---------------------------------------------------------------------------------------------------+        
-```
-## Prerequisites
-
-Prior to running the test, the following steps need to be performed.
-- Enable hugepages
-- Install DPDK
-- Install OVS
-
-Here are some good references for detailing them.
-- Red Hat
-	* https://wiki.qemu.org/Documentation/vhost-user-ovs-dpdk
-- Ubuntu server
-	* https://help.ubuntu.com/lts/serverguide/DPDK.html
-	* https://software.intel.com/en-us/articles/set-up-open-vswitch-with-dpdk-on-ubuntu-server
-
-## Test
-The test runs with multiple queue (MQ) support enabled, using 2 pairs of TX/RX queues defined for both OVS and the virtual machine. Here are the details on how the test can be run.
-
-_Setup OVS_
-
-`ovs_test.sh` is created to setup and start OVS. OVS will provide the `dpdkvhostuser` backend running in server mode.
-```bash
-mkdir -p /var/run/openvswitch
-modprobe openvswitch
-killall ovsdb-server ovs-vswitchd
-rm -f /var/run/openvswitch/vhost-user*
-rm -f /etc/openvswitch/conf.db
-export DB_SOCK=/var/run/openvswitch/db.sock
-ovsdb-tool create /etc/openvswitch/conf.db /usr/share/openvswitch/vswitch.ovsschema
-ovsdb-server --remote=punix:$DB_SOCK --remote=db:Open_vSwitch,Open_vSwitch,manager_options --pidfile --detach
-ovs-vsctl --no-wait init
-ovs-vsctl --no-wait set Open_vSwitch . other_config:dpdk-lcore-mask=0xf
-ovs-vsctl --no-wait set Open_vSwitch . other_config:dpdk-socket-mem=1024
-ovs-vsctl --no-wait set Open_vSwitch . other_config:dpdk-init=true
-ovs-vsctl --no-wait set Open_vSwitch . other_config:pmd-cpu-mask=0xf
-ovs-vswitchd unix:$DB_SOCK --pidfile --detach --log-file=/var/log/openvswitch/ovs-vswitchd.log
-ovs-vsctl add-br ovsbr0 -- set bridge ovsbr0 datapath_type=netdev
-ovs-vsctl add-port ovsbr0 vhost-user1 -- set Interface vhost-user1 type=dpdkvhostuser
-ovs-vsctl add-port ovsbr0 vhost-user2 -- set Interface vhost-user2 type=dpdkvhostuser
-ovs-vsctl set Interface vhost-user1 options:n_rxq=2
-ovs-vsctl set Interface vhost-user2 options:n_rxq=2
-```
-_Run ovs_test.sh_
-```bash
-./ovs_test.sh
-```
-
-_Launch the VMs_
-
-VMs run in client mode. They connect to the socket created by the `dpdkvhostuser` backend.
-```bash
-# From one terminal. We need to give the cloud-hypervisor binary the NET_ADMIN capabilities for it to set TAP interfaces up on the host.
-./cloud-hypervisor \
-        --cpus boot=2 \
-        --memory size=512M,hugepages=on,shared=true \
-        --kernel vmlinux \
-        --cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
-        --disk path=focal-server-cloudimg-amd64.raw   \
-        --net mac=52:54:00:02:d9:01,vhost_user=true,socket=/var/run/openvswitch/vhost-user1,num_queues=4
-
-# From another terminal. We need to give the cloud-hypervisor binary the NET_ADMIN capabilities for it to set TAP interfaces up on the host.
-./cloud-hypervisor \
-        --cpus boot=2 \
-        --memory size=512M,hugepages=on,shared=true \
-        --kernel vmlinux \
-        --cmdline "console=ttyS0 console=hvc0 root=/dev/vda1 rw" \
-        --disk path=focal-server-cloudimg-amd64.raw   \
-        --net "mac=52:54:20:11:C5:02,vhost_user=true,socket=/var/run/openvswitch/vhost-user2,num_queues=4"
-```
-
-_Setup VM1_
-```bash
-# From inside the guest
-sudo ip addr add 172.100.0.1/24 dev enp0s3
-```
-
-_Setup VM2_
-```bash
-# From inside the guest
-sudo ip addr add 172.100.0.2/24 dev enp0s3
-```
-
-_Ping VM1 from VM2_
-```bash
-# From inside the guest
-sudo ping 172.100.0.1
-```
-
-_Ping VM2 from VM1_
-```bash
-# From inside the guest
-sudo ping 172.100.0.2
-```
-
-__Result:__ At this point, VM1 and VM2 can ping each other successfully. We can now run `iperf3` test.
-
-_Run VM1 as server_
-```bash
-# From inside the guest
-iperf3 -s -p 4444
-```
-
-_Run VM2 as client_
-```bash
-# From inside the guest
-iperf3 -c 172.100.0.1 -t 30 -p 4444 &
-```
-

docs/virtiofs-root.md

@@ -1,92 +0,0 @@
-# HOWTO VirtioFS rootfs
-
-A quick guide for using virtiofs as a cloud-hypervisor guest's rootfs (i.e.
-with no root block device). This document is a quick getting started guide.
-There are many more steps to take to make this a production ready, secure
-setup.
-
-## Prerequisites
-
-1. virtiofsd from the qemu project
-   * We are using the Qemu version for now
-   * There is a Rust version being worked on that may be a better option in the future
-   * Part of the qemu-system-common package on Ubuntu
-   * Part of the qemu-common package on Fedora
-2. cloud-hypervisor - the newer the better, but I tested with 0.12
-3. a rootfs - This howto uses an alpine rootfs available here:
-   * https://dl-cdn.alpinelinux.org/alpine/v3.13/releases/x86_64/alpine-minirootfs-3.13.2-x86_64.tar.gz
-   * Others should work
-
-## To create the VM rootfs
-
-```bash
-mkdir rootfs/
-cd rootfs
-# this needs sudo to be able to set root permissions on fs components
-sudo tar -xf /path/to/alpine-minirootfs-3.13.1-x86_64.tar.gz
-# this will get created when the VM actually boots by the dhcp client
-# but we need it in the chroot to download packages
-sudo cp /etc/resolv.conf etc/
-# the alpine mini rootfs is meant for docker containers, we need a few extra
-# things for a working rootfs
-sudo chroot $PWD apk add openrc busybox-initscripts
-# we are using the paravirt console in cloud-hypervisor, so enable it in init
-# append it after the other console since it doesn't work just appending it
-sudo sed -i '/vt100/a \n# paravirt console\nhvc0::respawn:/sbin/getty -L hvc0 115200 vt100' etc/inittab
-# set no password for root user... you obviously don't want to do this for
-# any sort of production setup
-sudo sed -i 's/root:!::0:::::/root:::0:::::/' etc/shadow
-# set up init scripts
-for i in acpid crond
-    sudo ln -sf /etc/init.d/$i etc/runlevels/default/$i
-end
-for i in bootmisc hostname hwclock loadkmap modules networking swap sysctl syslog urandom
-    sudo ln -sf /etc/init.d/$i etc/runlevels/boot/$i
-end
-
-for i in killprocs mount-ro savecache
-    sudo ln -sf /etc/init.d/$i etc/runlevels/shutdown/$i
-end
-
-for i in devfs dmesg hwdrivers mdev
-    sudo ln -sf /etc/init.d/$i etc/runlevels/sysinit/$i
-end
-# setup network config
-echo 'auto lo
-iface lo inet loopback
-
-auto eth0
-iface eth0 inet dhcp
-' | sudo tee etc/network/interfaces
-
-```
-
-## To run the VM
-
-```bash
-# starting in the directory above rootfs
-sudo virtiofsd --socket-path=$PWD/virtiofs-rootfs.sock -o source=$PWD/rootfs -o cache=none &
-sudo cloud-hypervisor \
-    --cpus boot=1,max=1 \
-    --kernel vmlinux \
-    --fs tag=/dev/root,socket=$PWD/virtiofs-rootfs.sock \
-    --memory size=2G,shared=on \
-    --cmdline "console=hvc0 rootfstype=virtiofs root=/dev/root ro debug" \
-    --api-socket $PWD/ch.sock \
-    --rng \
-    --net ...
-```
-
-Note: an important part of the above is the `tag=/dev/root` and
-`root=/dev/root` parts. For whatever reason, it would only work with that as
-the tag.
-
-Note: another important bit is that the memory is shared. This is required for
-virtiofs
-
-## Message from the author
-
-If you find any issues or have suggestions, feel free to reach out to @iggy on
-the cloud-hypervisor slack. Also if this works for you, I'd like to know as
-well. It would also be nice to get steps for preparing other distribution root
-filesystems.

docs/windows.md

@@ -1,345 +0,0 @@
-# Windows Support
-
-Starting with the release version [0.10.0](https://github.com/cloud-hypervisor/cloud-hypervisor/releases/tag/v0.10.0), Cloud Hypervisor supports Windows guests.
-
-__Requirements__
-
-- Host with KVM enabled 
-- [UEFI](uefi.md) capable Windows guest image with Virtio drivers integrated
-
-Any modern Windows Server version is compatible. Cloud Hypervisor has been successfully tested with Windows Server 2019 and Windows Server Core 2004.
-
-At the current stage, only UEFI capable Windows images are supported. This implies the presence of the OVMF firmware during the Windows installation and in any subsequent usage. BIOS boot is not supported.
-
-The subsequent sections will tell, in detail, how to prepare an appropriate Windows image.
-
-## Image Preparation
-
-### Installation using the stock Windows ISO
-
-__Prerequisites__
-
-- QEMU, version >=5.0.0 is recommended.
-- Windows installation ISO. Obtained through MSDN, Visual Studio subscription, evaluation center, etc. 
-- [VirtIO driver ISO](https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/)
-- Suitable [OVMF](uefi.md) firmware 
-- With the suggested image size of 30G, there should be enough free disk space to hold the installation ISO and any other necessary files
-
-This step currently requires QEMU to install Windows onto the guest. QEMU is only used at the preparation stage, the resulting image is then fully functional with Cloud Hypervisor.
-
-Preparing several command parts as these will be used in the follow up sections as well.
-
-```shell
-IMG_FILE=windows-disk.qcow
-WIN_ISO_FILE=en_windows_server_version_2004_updated_may_2020_x64_dvd_1e7f1cfa.iso
-VIRTIO_ISO_FILE=virtio-win-0.1.185.iso
-OVMF_DIR=./FV
-```
-
-Create an empty image file, `qcow` or `raw` is supported.
-```shell
-qemu-img create -f qcow2 $IMG_FILE 30G
-```
-
-Begin the Windows installation process under QEMU
-```shell
-qemu-system-x86_64 \
-	-machine q35,accel=kvm \
-	-cpu host \
-	-m 4G \
-	-bios ./$OVMF_DIR/OVMF_CODE.fd \
-	-cdrom ./$WIN_ISO_FILE \
-	-drive file=./$VIRTIO_ISO_FILE,index=0,media=cdrom
-	-drive if=none,id=root,file=./$IMG_FILE \
-	-device virtio-blk-pci,drive=root,disable-legacy=on \
-	-device virtio-net-pci,netdev=mynet0,disable-legacy=on \
-	-netdev user,id=mynet0 \
-	-vga std
-```
-
-Before the installation can proceed, point the Windows installation program to the VirtIO disk and install the necessary storage controller drivers. After that, the attached hard drive will become visible and the actual installation can commence.
-
-After the installation has completed, proceed further to the configuration section. QEMU will be needed at least once more to enable the Windows Special Administration Console (SAC) and to possibly install extra device drivers.
-
-## Image Usage
-
-The basic command to boot a Windows image. The configuration section should be checked before executing it for the first time.
-
-```shell
-cloud-hypervisor \
-	--kernel ./$OVMF_DIR/OVMF.fd \
-	--disk path=./$IMG_FILE \
-	--cpus boot=1,kvm_hyperv=on \
-	--memory size=4G \
-	--serial tty \
-	--console off \
-	--net tap=
-```
-
-It is necessary to always:
-
-- Carry the OVMF firmware in the `--kernel` option
-- Add `kvm_hyperv=on` to the `--cpus` option
-
-In cases where the host processor supports address space > 39 bits, it might be necessary to limit the address space. It can be done by appending the option `max_phys_bits=X` to the `--cpus` parameter, where `X` is the number of bits to be supported. Windows was tested to support at least 39-bit address space.
-
-To daemonize the Cloud Hypervisor process, `nohup` can be used. Some STDIO redirections might need to be done. In a simple case it is sufficient to just redirect all the output to `/dev/null`.
-
-## Image Configuration
-
-### Device Drivers
-
-After the Windows installation has finished under QEMU, there might be still devices with no drivers installed. This might happen for example, when a device was not used during the installation. In particular it is important to ensure that the VirtIO network device is setup correctly because further steps for the configuration and the usage require network in most case.
-
-Boot once more under QEMU and use the [Device Manager](https://support.microsoft.com/en-in/help/4028443/windows-10-update-drivers), to ensure all the device drivers, and especially the network card, are installed correctly. Also, as Cloud Hypervisor can introduce new devices, it is advisable to repeat the procedure while booted under Cloud Hypervisor, when the RDP access to the image is functional.
-
-### Windows Special Administration Console (SAC) enablement
-
-SAC provides a text based console access to the Windows guest. As Cloud Hypervisor doesn't implement a VGA adaptor, SAC is an important instrument for the Windows guest management.
-
-Boot the Windows image under QEMU and execute the below commands to permanently enable SAC
-
-```cmd
-bcdedit /emssettings emsport:1 emsbaudrate:115200
-bcdedit /ems on
-bcdedit /bootems on
-```
-
-Once SAC is enabled, the image can be booted under Cloud Hypervisor. The SAC prompt will show up 
-
-<pre>
-Computer is booting, SAC started and initialized.                               
-                                                                                
-Use the "ch -?" command for information about using channels.                   
-Use the "?" command for general help.                                           
-                                                                                
-                                                                                
-SAC>
-</pre>
-
-To open a console on the guest, the command sequence below can be used
-<pre>
-SAC>cmd
-The Command Prompt session was successfully launched.
-SAC>
-EVENT:   A new channel has been created.  Use "ch -?" for channel help.
-Channel: Cmd0001
-SAC>ch -si 1
-</pre>
-
-See also the [links](#Links) section for a more extended SAC documentation.
-
-## Network
-
-This section illustrates the Windows specific corner points for the VM network configuration. For the extended networking guide, including bridging for multiple VMs, follow [networking.md](networking.md).
-
-### Basic Networking
-
-As the simplest option, using `--net tap=` in the Cloud Hypervisor command line will create a `vmtapX` device on the host with the default IPv4 adress `192.168.249.1`. After SAC becomes available, the guest configuration can be set with
-
-<pre>
-SAC>i 10 192.168.249.2 255.255.255.0 192.168.249.1
-</pre> 
-
-Where `10` is the device index as shown by the `i` command.
-
-### Guest Internet Connectivity
-
-Additional steps are necessary to provide the guest with internet access.
-
-- On the guest, add the DNS server either by using `netsh` or by opening `Network and Connectivity Center` and editing the adapter properties.
-- On the host, configure the traffic forwarding. Replace the `NET_DEV` with the name of your network device.
-```shell
-NET_DEV=wlp3s0
-sysctl -w net.ipv4.ip_forward=1
-iptables -t nat -A POSTROUTING -o $NET_DEV -j MASQUERADE
-```
-
-### Remote Desktop Protocol (RDP) enablement
-
-#### Using QEMU
-  - Execute `SystemPropertiesRemote`
-  - In the properties window, choose "Allow remote connections to this computer"
-  - Click "Select Users" and add some user to the allow list
-#### Using powershell
-```powershell
-Set-ItemProperty "HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server\" -Name "fDenyTSConnections" -Value 0
-Enable-NetFirewallRule -DisplayGroup "Remote Desktop"
-Add-LocalGroupMember -Group "Remote Desktop Users" -Member someuser
-```
- 
-Administrators can always RDP, non administrator users have to be explicitly enabled. 
-
-Once the configuration is set, RDP clients can connect to `192.168.249.2`.
-
-### SSH
-
-#### Enable using powershell
-
-```powershell
-Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0
-Start-Service sshd
-Set-Service -Name sshd -StartupType ‘Automatic’
-```
-
-This allows for SSH login from a remote machine, for example through the `administrator` user: `ssh administrator@192.168.249.2`. For a more detailed OpenSSH guide, please follow the MSDN article from the [links](#links) section.
-
-## Hotplug capability
-
-CPU hotplug is supported. The VM operating system needs to support hotplug and be appropriately licensed. SKU limitations like constraints on the number of cores are to be taken into consideration. Note, that Windows doesn't support CPU hot-remove. When `ch-remote` is invoked to reduce the number of CPUs, the result will be visible after the OS reboot within the same hypervisor instance.
-
-RAM hotplug is supported. Note, that while the `pnpmem.sys` driver in use supports RAM hot-remove, the RAM being unplugged has to be not in use and have no reserved pages. In most cases it means, hot-remove won't work. Same as with the CPU hot-remove, when `ch-remote` is invoked to reduce the RAM size, the result will be visible after the OS reboot.
-
-Network device hotplug and hot-remove are supported.
-
-## Debugging
-
-The Windows guest debugging process relies heavily on QEMU and [socat](http://www.dest-unreach.org/socat/). The procedure requires two Windows VMs:
-
-- A debugger VM running under QEMU.
-- A debuggee, a Windows VM that has been created in the previous steps, running under Cloud Hypervisor or QEMU.
-
-The connection between both guests happens over TCP, whereby on the guest side it is automatically translated to a COM port. Because the VMs are connected through TCP, the debugging infrastructure can be distributed over the network. The serial port, while slowly transferring data, is common enough to support a wide range of cases and tools.
-
-In this excercise, [WinDbg](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/) is used. Any other debugger of choice with the ability to use serial connection can be used instead. 
-
-### Debugger and Debuggee
-
-#### WinDbg VM
-
-For simplicity, the debugger VM is supposed to be only running under QEMU. It will require VGA and doesn't neccessarily depend on UEFI. As an OS, it can carry any supported Windows OS where the debugger of choice can be installed. The simplest way is to follow the image preparation instructions from the previous chapter, but avoid using the OVMF firmware. It is also not required to use VirtIO drivers, whereby it might be useful in some case. Though, while creating the image file for the debugger VM, be sure to choose a sufficient disk size that counts in the need to save the corresponding debug symbols and sources.
-
-To create the debugger Windows VM, the following command can be used:
-
-```shell
-qemu-system-x86_64 \
-	-machine q35,accel=kvm \
-	-cpu host \
-	-smp 1 \
-	-m 4G \
-	-cdrom ./$WIN_ISO_FILE \
-	-drive file=./$VIRTIO_ISO_FILE,index=0,media=cdrom
-	-drive if=none,id=root,file=./windbg-disk.qcow \
-	-device virtio-blk-pci,drive=root,disable-legacy=on \
-	-device virtio-net-pci,netdev=mynet0,disable-legacy=on \
-	-netdev user,id=mynet0,net=192.168.178.0/24,host=192.168.178.1,dhcpstart=192.168.178.64,hostname=windbg-host \
-	-vga std
-```
-
-A non server Windows OS like Windows 10 can be used to carry the debugging tools in the debugger VM.
-
-#### Debuggee VM
-
-The debuggee VM is the one that we've learned to configure and run in the first section. There might be various reasons to debug. For example, there could be an issue in the Windows guest with an emulated device or an included driver. Or, we might want to develop a custom feature like a kernel driver to be available in the guest.
-
-Note, that there are several ways to debug Windows, not all of them need to be enabled at the same time. For example, if developing a kernel module, the only useful options would be to configure for the serial debugging and enable the kernel debug. In that case, any crash or misbehavior in the boot loader or kernel would be ignored. The commands below must be run as administrator on the debuggee guest VM.
-
-##### Turn On Serial Debugging
-
-This will configure the debugging to be enabled and instruct to use the serial port for it.
-
-```cmd
-bcdedit /dbgsettings serial debugport:1 baudrate:115200
-```
-
-##### Turn On Kernel Debuging
-
-```cmd
-bcdedit /debug on
-```
-
-##### Turn On Boot Loader Debug
-
-```cmd
-bcdedit /bootdebug on
-```
-
-##### Turn on boot manager debug 
-
-```cmd
-bcdedit /set {bootmgr} bootdebug on
-```
-
-##### Disable Recovery Screen On Boot Failure
-
-There could be a situation, where a crash is debugged. In such cases, the guest could be left in an inconsistent state. The default Windows behavior would be to boot into the recovery screen, however in some cases it might be not desired. To make Windows ignore failures and always proceed to booting the OS, use the command below:
-
-```cmd
-bcdedit /set {default} bootstatuspolicy ignoreallfailures
-```
-
-### Debugging Process
-
-#### Invoke the WinDbg VM
-
-```shell
-qemu-system-x86_64 \
-	-machine q35,accel=kvm \
-	-cpu host \
-	-smp 1 \
-	-m 4G \
-	-drive if=none,id=root,file=./windbg-disk.qcow \
-	-device virtio-blk-pci,drive=root,disable-legacy=on \
-	-serial tcp::4445,server,nowait \
-	-device virtio-net-pci,netdev=mynet0,disable-legacy=on \
-	-netdev user,id=mynet0,net=192.168.178.0/24,host=192.168.178.1,dhcpstart=192.168.178.64,hostname=windbg-host \
-	-vga std
-```
-
-Note, this VM has the networking enabled. It is needed, because symbols and sources might need to be fetched from a network location.
-
-Also, notice the `-serial` parameter - that's what does the magic on exposing the serial port to the guest while connecting the debugger VM with a client VM through the network. SAC/EMS needs to be disabled in the debugger VM, as otherwise the COM device might be blocked.
-
-Hereafter, WinDbg can be started using a command below:
-
-```cmd
-set _NT_DEBUG_PORT=com1
-set _NT_DEBUG_BAUD_RATE=115200
-
-windbg -v -d -k
-```
-
-Once started, WinDbg will wait for an incoming connection which is going to be initialized by the debuggee VM started in the next section.
-
-#### Invoke the Debuggee VM
-
-##### Under QEMU
-
-Essentially it would be the command like depicted in the guest preparation sections, with a few modifications:
-```shell
-qemu-system-x86_64 \
-	-machine q35,accel=kvm \
-	-cpu host \
-	-m 4G \
-	-bios ./$OVMF_DIR/OVMF_CODE.fd \
-	-cdrom ./$WIN_ISO_FILE \
-	-drive file=./$VIRTIO_ISO_FILE,index=0,media=cdrom
-	-drive if=none,id=root,file=./$IMG_FILE \
-	-device virtio-blk-pci,drive=root,disable-legacy=on \
-	-device virtio-net-pci,netdev=mynet0,disable-legacy=on \
-	-netdev user,id=mynet0 \
-	-serial tcp:127.0.0.1:4445 \
-	-vga std
-```
-
-It is to see, that `-serial` parameter is used here, to establish the connection with the debugger VM.
-
-To disable HPET, attach `--no-hpet`. To enable hypervisor reference timer, use `-cpu host,hv-time`. These and other options can be used to achieve better [Hyper-V compatibility](https://archive.fosdem.org/2019/schedule/event/vai_enlightening_kvm/attachments/slides/2860/export/events/attachments/vai_enlightening_kvm/slides/2860/vkuznets_fosdem2019_enlightening_kvm.pdf).
-
-##### Cloud Hypervisor
-
-The `socat` tool is used to establish the QEMU compatible behavior. Here as well, the Cloud Hypervisor command used to run the Windows guest is to be used. Put the command into a shell script:
-
-`socat SYSTEM:"./ch-script",openpty,raw,echo=0 TCP:localhost:4445`
-
-The reason to pack the command into the shell script is that the command might contain a comma. When using SYSTEM, the shell command can't contain `,` or `!!`.
-
-## Links
-
-- [Fedora VirtIO guide for Windows](https://docs.fedoraproject.org/en-US/quick-docs/creating-windows-virtual-machines-using-virtio-drivers/)
-- [VirtIO driver binaries](https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/)
-- [VirtIO driver sources](https://github.com/virtio-win/kvm-guest-drivers-windows)
-- [Emergency Management Services](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc787940(v=ws.10))
-- [OpenSSH server/client configuration](https://docs.microsoft.com/en-us/windows-server/administration/openssh/openssh_install_firstuse)
-- [Windows guest debugging under KVM](https://www.linux-kvm.org/page/WindowsGuestDrivers/GuestDebugging)
-- ["ENLIGHTENING" KVM](https://archive.fosdem.org/2019/schedule/event/vai_enlightening_kvm/attachments/slides/2860/export/events/attachments/vai_enlightening_kvm/slides/2860/vkuznets_fosdem2019_enlightening_kvm.pdf)

event_monitor/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "event_monitor"
-version = "0.1.0"
-authors = ["The Cloud Hypervisor Authors"]
-edition = "2018"
-
-[dependencies]
-libc = "0.2.94"
-serde = {version = ">=1.0.27", features = ["rc"] }
-serde_derive = ">=1.0.27"
-serde_json = ">=1.0.9"

event_monitor/src/lib.rs

@@ -1,77 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-#[macro_use]
-extern crate serde_derive;
-
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::fs::File;
-use std::os::unix::io::AsRawFd;
-use std::time::{Duration, Instant};
-
-static mut MONITOR: Option<(File, Instant)> = None;
-
-/// This function must only be called once from the main process before any threads
-/// are created to avoid race conditions
-pub fn set_monitor(file: File) -> Result<(), std::io::Error> {
-    assert!(unsafe { MONITOR.is_none() });
-    let fd = file.as_raw_fd();
-    let ret = unsafe {
-        let mut flags = libc::fcntl(fd, libc::F_GETFL);
-        flags |= libc::O_NONBLOCK;
-        libc::fcntl(fd, libc::F_SETFL, flags)
-    };
-    if ret < 0 {
-        return Err(std::io::Error::last_os_error());
-    }
-    unsafe {
-        MONITOR = Some((file, Instant::now()));
-    };
-    Ok(())
-}
-
-#[derive(Serialize)]
-struct Event<'a> {
-    timestamp: Duration,
-    source: &'a str,
-    event: &'a str,
-    properties: Option<&'a HashMap<Cow<'a, str>, Cow<'a, str>>>,
-}
-
-pub fn event_log(source: &str, event: &str, properties: Option<&HashMap<Cow<str>, Cow<str>>>) {
-    if let Some((file, start)) = unsafe { MONITOR.as_ref() } {
-        let e = Event {
-            timestamp: start.elapsed(),
-            source,
-            event,
-            properties,
-        };
-        serde_json::to_writer_pretty(file, &e).ok();
-    }
-}
-
-/*
-    Through the use of Cow<'a, str> it is possible to use String as well as
-    &str as the parameters:
-    e.g.
-    event!("cpu_manager", "create_vcpu", "id", cpu_id.to_string());
-*/
-#[macro_export]
-macro_rules! event {
-    ($source:expr, $event:expr) => {
-        $crate::event_log($source, $event, None)
-    };
-    ($source:expr, $event:expr, $($key:expr, $value:expr),*) => {
-        {
-            let mut properties = ::std::collections::HashMap::new();
-            $(
-                properties.insert($key.into(), $value.into());
-            )+
-            $crate::event_log($source, $event, Some(&properties))
-        }
-     };
-
-}

fuzz/.gitignore

@@ -1,4 +0,0 @@
-
-target
-corpus
-artifacts

fuzz/Cargo.lock

@@ -1,777 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "acpi_tables"
-version = "0.1.0"
-dependencies = [
- "vm-memory",
-]
-
-[[package]]
-name = "ansi_term"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "anyhow"
-version = "1.0.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28b2cd92db5cbd74e8e5028f7e27dd7aa3090e89e4f2a197cc7c8dfb69c7063b"
-
-[[package]]
-name = "api_client"
-version = "0.1.0"
-
-[[package]]
-name = "arbitrary"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "698b65a961a9d730fb45b6b0327e20207810c9f61ee421b082b27ba003f49e2b"
-
-[[package]]
-name = "arc-swap"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d7d63395147b81a9e570bcc6243aaf71c017bd666d4909cfef0085bdda8d73"
-
-[[package]]
-name = "arch"
-version = "0.1.0"
-dependencies = [
- "acpi_tables",
- "anyhow",
- "arch_gen",
- "byteorder",
- "hypervisor",
- "libc",
- "linux-loader",
- "log",
- "serde",
- "serde_derive",
- "serde_json",
- "thiserror",
- "vm-memory",
- "vm-migration",
-]
-
-[[package]]
-name = "arch_gen"
-version = "0.1.0"
-
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "bitflags"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
-
-[[package]]
-name = "block_util"
-version = "0.1.0"
-dependencies = [
- "io-uring",
- "libc",
- "log",
- "qcow",
- "serde",
- "serde_derive",
- "serde_json",
- "thiserror",
- "virtio-bindings",
- "vm-memory",
- "vm-virtio",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
-[[package]]
-name = "cc"
-version = "1.0.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "clap"
-version = "2.33.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
-dependencies = [
- "ansi_term",
- "atty",
- "bitflags",
- "strsim",
- "term_size",
- "textwrap",
- "unicode-width",
- "vec_map",
-]
-
-[[package]]
-name = "cloud-hypervisor"
-version = "0.14.0"
-dependencies = [
- "anyhow",
- "api_client",
- "clap",
- "epoll",
- "event_monitor",
- "hypervisor",
- "libc",
- "log",
- "option_parser",
- "seccomp",
- "serde_json",
- "signal-hook",
- "thiserror",
- "vm-memory",
- "vmm",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "cloud-hypervisor-fuzz"
-version = "0.0.0"
-dependencies = [
- "block_util",
- "cloud-hypervisor",
- "libc",
- "libfuzzer-sys",
- "qcow",
- "seccomp",
- "virtio-devices",
- "vm-memory",
- "vm-virtio",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "devices"
-version = "0.1.0"
-dependencies = [
- "acpi_tables",
- "anyhow",
- "bitflags",
- "byteorder",
- "epoll",
- "libc",
- "log",
- "serde",
- "serde_derive",
- "serde_json",
- "vm-device",
- "vm-memory",
- "vm-migration",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "epoll"
-version = "4.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20df693c700404f7e19d4d6fae6b15215d2913c27955d2b9d6f2c0f537511cd0"
-dependencies = [
- "bitflags",
- "libc",
-]
-
-[[package]]
-name = "event_monitor"
-version = "0.1.0"
-dependencies = [
- "libc",
- "serde",
- "serde_derive",
- "serde_json",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.1.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "hypervisor"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "epoll",
- "iced-x86",
- "kvm-bindings",
- "kvm-ioctls",
- "libc",
- "log",
- "serde",
- "serde_derive",
- "serde_json",
- "thiserror",
- "vm-memory",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "iced-x86"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b85a147f5dcb22ece887da5b99187954cc046939f22416e953dd7c336e85a1"
-dependencies = [
- "lazy_static",
- "static_assertions",
-]
-
-[[package]]
-name = "io-uring"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb82832e05cc4ca298f198a8db108837b4f7b7b1248e3cba8e48f151aece80cf"
-dependencies = [
- "bitflags",
- "libc",
-]
-
-[[package]]
-name = "itoa"
-version = "0.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
-
-[[package]]
-name = "kvm-bindings"
-version = "0.4.0"
-source = "git+https://github.com/cloud-hypervisor/kvm-bindings?branch=ch-v0.4.0#1a68725639283e622f4bb64584885b30bfe8be44"
-dependencies = [
- "serde",
- "serde_derive",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "kvm-ioctls"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74058b16912c6723db02d4ca3ec919b73cd41512ccd3b6202cf91ae8d6c9dce5"
-dependencies = [
- "kvm-bindings",
- "libc",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "libc"
-version = "0.2.94"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18794a8ad5b29321f790b55d93dfba91e125cb1a9edbd4f8e3150acc771c1a5e"
-
-[[package]]
-name = "libfuzzer-sys"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86c975d637bc2a2f99440932b731491fc34c7f785d239e38af3addd3c2fd0e46"
-dependencies = [
- "arbitrary",
- "cc",
-]
-
-[[package]]
-name = "linux-loader"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c819cc8275b0f2c1ed9feec455ca288b45d82932384a6a5f7a86812ee3427459"
-dependencies = [
- "vm-memory",
-]
-
-[[package]]
-name = "log"
-version = "0.4.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "micro_http"
-version = "0.1.0"
-source = "git+https://github.com/firecracker-microvm/micro-http?branch=main#9b605a8b61df602cda62076d30d9f70307ea336f"
-dependencies = [
- "libc",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "net_gen"
-version = "0.1.0"
-dependencies = [
- "vmm-sys-util",
-]
-
-[[package]]
-name = "net_util"
-version = "0.1.0"
-dependencies = [
- "epoll",
- "libc",
- "log",
- "net_gen",
- "rate_limiter",
- "serde",
- "virtio-bindings",
- "vm-memory",
- "vm-virtio",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "option_parser"
-version = "0.1.0"
-
-[[package]]
-name = "pci"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "byteorder",
- "hypervisor",
- "libc",
- "log",
- "serde",
- "serde_derive",
- "serde_json",
- "vfio-bindings",
- "vfio-ioctls",
- "vm-allocator",
- "vm-device",
- "vm-memory",
- "vm-migration",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec"
-dependencies = [
- "unicode-xid",
-]
-
-[[package]]
-name = "qcow"
-version = "0.1.0"
-dependencies = [
- "byteorder",
- "libc",
- "log",
- "remain",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rate_limiter"
-version = "0.1.0"
-dependencies = [
- "libc",
- "log",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "remain"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ba1e78fa68412cb93ef642fd4d20b9a941be49ee9333875ebaf13112673ea7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
-
-[[package]]
-name = "seccomp"
-version = "0.1.0"
-source = "git+https://github.com/firecracker-microvm/firecracker?tag=v0.24.2#5ba819d7b7a684107f5434bcbd1617bc94565478"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.125"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "558dc50e1a5a5fa7112ca2ce4effcb321b0300c0d4ccf0776a9f60cd89031171"
-
-[[package]]
-name = "serde_derive"
-version = "1.0.125"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b093b7a2bb58203b5da3056c05b4ec1fed827dcfdb37347a8841695263b3d06d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.64"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "799e97dc9fdae36a5c8b8f2cae9ce2ee9fdce2058c57a93e6099d919fd982f79"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "signal-hook"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef33d6d0cd06e0840fba9985aab098c147e67e05cee14d412d3345ed14ff30ac"
-dependencies = [
- "libc",
- "signal-hook-registry",
-]
-
-[[package]]
-name = "signal-hook-registry"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16f1d0fef1604ba8f7a073c7e701f213e056707210e9020af4528e0101ce11a6"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "strsim"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
-
-[[package]]
-name = "syn"
-version = "1.0.71"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad184cc9470f9117b2ac6817bfe297307418819ba40552f9b3846f05c33d5373"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "term_size"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e4129646ca0ed8f45d09b929036bafad5377103edd06e50bf574b353d2b08d9"
-dependencies = [
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "textwrap"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
-dependencies = [
- "term_size",
- "unicode-width",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0f4a65597094d4483ddaed134f409b2cb7c1beccf25201a9f73c719254fa98e"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7765189610d8241a44529806d6fd1f2e0a08734313a35d5b3a556f92b381f3c0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "unicode-width"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
-
-[[package]]
-name = "vec_map"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
-
-[[package]]
-name = "vfio-bindings"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a21f546f2bda37f5a8cfb138c87f95b8e34d2d78d6a7a92ba3785f4e08604a7"
-dependencies = [
- "vmm-sys-util",
-]
-
-[[package]]
-name = "vfio-ioctls"
-version = "0.1.0"
-source = "git+https://github.com/rust-vmm/vfio-ioctls?branch=master#a87b13bdec026e8144b91f30f35451a966d8c1ca"
-dependencies = [
- "byteorder",
- "kvm-bindings",
- "kvm-ioctls",
- "log",
- "vfio-bindings",
- "vm-memory",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "vhost"
-version = "0.1.0"
-source = "git+https://github.com/rust-vmm/vhost?branch=master#ee3e8722706c984b3dfe12d3a130e92101b78e8f"
-dependencies = [
- "bitflags",
- "libc",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "virtio-bindings"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ff512178285488516ed85f15b5d0113a7cdb89e9e8a760b269ae4f02b84bd6b"
-
-[[package]]
-name = "virtio-devices"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "arc-swap",
- "block_util",
- "byteorder",
- "epoll",
- "event_monitor",
- "io-uring",
- "libc",
- "log",
- "net_gen",
- "net_util",
- "pci",
- "rate_limiter",
- "seccomp",
- "serde",
- "serde_derive",
- "serde_json",
- "vhost",
- "virtio-bindings",
- "vm-allocator",
- "vm-device",
- "vm-memory",
- "vm-migration",
- "vm-virtio",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "vm-allocator"
-version = "0.1.0"
-dependencies = [
- "arch",
- "libc",
- "vm-memory",
-]
-
-[[package]]
-name = "vm-device"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "serde",
- "serde_derive",
- "serde_json",
- "thiserror",
- "vfio-ioctls",
- "vm-memory",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "vm-memory"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "625f401b1b8b3ac3d43f53903cd138cfe840bd985f8581e553027b31d2bb8ae8"
-dependencies = [
- "arc-swap",
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "vm-migration"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "serde",
- "serde_derive",
- "serde_json",
- "thiserror",
- "vm-memory",
-]
-
-[[package]]
-name = "vm-virtio"
-version = "0.1.0"
-dependencies = [
- "log",
- "serde",
- "serde_derive",
- "serde_json",
- "virtio-bindings",
- "vm-memory",
-]
-
-[[package]]
-name = "vmm"
-version = "0.1.0"
-dependencies = [
- "acpi_tables",
- "anyhow",
- "arc-swap",
- "arch",
- "bitflags",
- "block_util",
- "clap",
- "devices",
- "epoll",
- "event_monitor",
- "hypervisor",
- "lazy_static",
- "libc",
- "linux-loader",
- "log",
- "micro_http",
- "net_util",
- "option_parser",
- "pci",
- "qcow",
- "seccomp",
- "serde",
- "serde_derive",
- "serde_json",
- "signal-hook",
- "thiserror",
- "vfio-ioctls",
- "virtio-devices",
- "vm-allocator",
- "vm-device",
- "vm-memory",
- "vm-migration",
- "vm-virtio",
- "vmm-sys-util",
-]
-
-[[package]]
-name = "vmm-sys-util"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01cf11afbc4ebc0d5c7a7748a77d19e2042677fc15faa2f4ccccb27c18a60605"
-dependencies = [
- "bitflags",
- "libc",
- "serde",
- "serde_derive",
-]
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

fuzz/Cargo.toml

@@ -1,42 +0,0 @@
-[package]
-name = "cloud-hypervisor-fuzz"
-version = "0.0.0"
-authors = ["Automatically generated"]
-publish = false
-edition = "2018"
-
-[package.metadata]
-cargo-fuzz = true
-
-[dependencies]
-block_util = { path = "../block_util" }
-libc = "0.2.94"
-libfuzzer-sys = "0.4"
-qcow = { path = "../qcow" }
-seccomp = { git = "https://github.com/firecracker-microvm/firecracker", tag = "v0.24.2" }
-virtio-devices = { path = "../virtio-devices" }
-vmm-sys-util = "0.8.0"
-vm-virtio = { path = "../vm-virtio" }
-vm-memory = "0.5.0"
-
-[patch.crates-io]
-kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.4.0", features = ["with-serde", "fam-wrappers"] }
-
-[dependencies.cloud-hypervisor]
-path = ".."
-
-# Prevent this from interfering with workspaces
-[workspace]
-members = ["."]
-
-[[bin]]
-name = "qcow"
-path = "fuzz_targets/qcow.rs"
-test = false
-doc = false
-
-[[bin]]
-name = "block"
-path = "fuzz_targets/block.rs"
-test = false
-doc = false

fuzz/fuzz_targets/block.rs

@@ -1,140 +0,0 @@
-// Copyright 2018 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#![no_main]
-
-use block_util::{async_io::DiskFile, qcow_sync::QcowDiskSync};
-use libfuzzer_sys::fuzz_target;
-use seccomp::SeccompAction;
-use std::ffi;
-use std::fs::File;
-use std::io::{self, Cursor, Read, Seek, SeekFrom};
-use std::mem::size_of;
-use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
-use std::path::PathBuf;
-use std::sync::Arc;
-use virtio_devices::{Block, VirtioDevice, VirtioInterrupt, VirtioInterruptType};
-use vm_memory::{Bytes, GuestAddress, GuestMemoryAtomic, GuestMemoryMmap};
-use vm_virtio::Queue;
-use vmm_sys_util::eventfd::EventFd;
-
-const MEM_SIZE: u64 = 256 * 1024 * 1024;
-const DESC_SIZE: u64 = 16; // Bytes in one virtio descriptor.
-const QUEUE_SIZE: u16 = 16; // Max entries in the queue.
-const CMD_SIZE: usize = 16; // Bytes in the command.
-
-fuzz_target!(|bytes| {
-    let size_u64 = size_of::<u64>();
-    let mem = GuestMemoryMmap::from_ranges(&[(GuestAddress(0), MEM_SIZE as usize)]).unwrap();
-
-    // The fuzz data is interpreted as:
-    // starting index 8 bytes
-    // command location 8 bytes
-    // command 16 bytes
-    // descriptors circular buffer 16 bytes * 3
-    if bytes.len() < 4 * size_u64 {
-        // Need an index to start.
-        return;
-    }
-
-    let mut data_image = Cursor::new(bytes);
-
-    let first_index = read_u64(&mut data_image);
-    if first_index > MEM_SIZE / DESC_SIZE {
-        return;
-    }
-    let first_offset = first_index * DESC_SIZE;
-    if first_offset as usize + size_u64 > bytes.len() {
-        return;
-    }
-
-    let command_addr = read_u64(&mut data_image);
-    if command_addr > MEM_SIZE - CMD_SIZE as u64 {
-        return;
-    }
-    if mem
-        .write_slice(
-            &bytes[2 * size_u64..(2 * size_u64) + CMD_SIZE],
-            GuestAddress(command_addr as u64),
-        )
-        .is_err()
-    {
-        return;
-    }
-
-    data_image.seek(SeekFrom::Start(first_offset)).unwrap();
-    let desc_table = read_u64(&mut data_image);
-
-    if mem
-        .write_slice(&bytes[32..], GuestAddress(desc_table as u64))
-        .is_err()
-    {
-        return;
-    }
-
-    let mut q = Queue::new(QUEUE_SIZE);
-    q.ready = true;
-    q.size = QUEUE_SIZE / 2;
-    q.max_size = QUEUE_SIZE;
-
-    let queue_evts: Vec<EventFd> = vec![EventFd::new(0).unwrap()];
-    let queue_fd = queue_evts[0].as_raw_fd();
-    let queue_evt = unsafe { EventFd::from_raw_fd(libc::dup(queue_fd)) };
-
-    let shm = memfd_create(&ffi::CString::new("fuzz").unwrap(), 0).unwrap();
-    let disk_file: File = unsafe { File::from_raw_fd(shm) };
-    let qcow_disk = Box::new(QcowDiskSync::new(disk_file, false)) as Box<dyn DiskFile>;
-
-    let mut block = Block::new(
-        "tmp".to_owned(),
-        qcow_disk,
-        PathBuf::from(""),
-        false,
-        false,
-        2,
-        256,
-        SeccompAction::Allow,
-        None,
-    )
-    .unwrap();
-
-    block
-        .activate(
-            GuestMemoryAtomic::new(mem),
-            Arc::new(NoopVirtioInterrupt {}),
-            vec![q],
-            queue_evts,
-        )
-        .ok();
-
-    queue_evt.write(77).unwrap(); // Rings the doorbell, any byte will do.
-});
-
-fn read_u64<T: Read>(readable: &mut T) -> u64 {
-    let mut buf = [0u8; size_of::<u64>()];
-    readable.read_exact(&mut buf[..]).unwrap();
-    u64::from_le_bytes(buf)
-}
-
-fn memfd_create(name: &ffi::CStr, flags: u32) -> Result<RawFd, io::Error> {
-    let res = unsafe { libc::syscall(libc::SYS_memfd_create, name.as_ptr(), flags) };
-
-    if res < 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(res as RawFd)
-    }
-}
-
-pub struct NoopVirtioInterrupt {}
-
-impl VirtioInterrupt for NoopVirtioInterrupt {
-    fn trigger(
-        &self,
-        _int_type: &VirtioInterruptType,
-        _queue: Option<&Queue>,
-    ) -> std::result::Result<(), std::io::Error> {
-        Ok(())
-    }
-}