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/dependabot.yml

@@ -1,18 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: cargo
-  directory: "/"
-  schedule:
-    interval: daily
-  open-pull-requests-limit: 1
-  allow:
-  - dependency-type: direct
-  - dependency-type: indirect
-- package-ecosystem: cargo
-  directory: "/fuzz"
-  schedule:
-    interval: daily
-  open-pull-requests-limit: 1
-  allow:
-  - dependency-type: direct
-  - dependency-type: indirect

.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,58 +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
-          - "1.62"
-        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 musl-gcc
-        run: sudo apt install -y musl-tools
-
-      - name: Install Rust toolchain (${{ matrix.rust }})
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.rust }}
-          target: ${{ matrix.target }}
-          override: true
-
-      - name: Build (default features)
-        run: cargo rustc --locked --bin cloud-hypervisor -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Build (kvm)
-        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "kvm"  -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Build (default features + tdx)
-        run: cargo rustc --locked --bin cloud-hypervisor --features "tdx" -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Build (default features + guest_debug)
-        run: cargo rustc --locked --bin cloud-hypervisor --features "guest_debug" -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Build (mshv)
-        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "mshv"  -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Build (mshv + kvm)
-        run: cargo rustc --locked --bin cloud-hypervisor --no-default-features --features "mshv,kvm"  -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Release Build (default features)
-        run: cargo build --locked --all --release --target=${{ matrix.target }}
-
-      - name: Check build did not modify any files
-        run: test -z "$(git status --porcelain)"

.github/workflows/dco.yaml

@@ -1,18 +0,0 @@
-name: DCO
-on:
-  pull_request:
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python 3.x
-      uses: actions/setup-python@v1
-      with:
-        python-version: '3.x'
-    - name: Check DCO
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: |
-        pip3 install -U dco-check
-        dco-check -e "49699333+dependabot[bot]@users.noreply.github.com"

.github/workflows/docker-image.yaml

@@ -1,63 +0,0 @@
-name: Cloud Hypervisor's Docker image update
-
-on:
-  push:
-    branches: main
-    paths: resources/Dockerfile
-  pull_request:
-    paths: resources/Dockerfile
-
-env:
-  REGISTRY: ghcr.io
-  IMAGE_NAME: ${{ github.repository }}
-
-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 ghcr
-        uses: docker/login-action@v2
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v4
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-          # generate Docker tags based on the following events/attributes
-          tags: |
-            type=raw,value={{date 'YYYYMMDD'}}-0
-            type=sha
-
-      - name: Build and push
-        if: ${{ github.event_name == 'push' }}
-        uses: docker/build-push-action@v2
-        with:
-          file: ./resources/Dockerfile
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-
-      - name: Build only
-        if: ${{ github.event_name == 'pull_request' }}
-        uses: docker/build-push-action@v2
-        with:
-          file: ./resources/Dockerfile
-          platforms: linux/amd64,linux/arm64
-          tags: ${{ steps.meta.outputs.tags }}
-
-      - name: Image digest
-        run: echo ${{ steps.docker_build.outputs.digest }}

.github/workflows/fuzz-build.yaml

@@ -1,29 +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
-        # Temporary fix for cargo-fuzz on latest nightly: https://github.com/rust-fuzz/cargo-fuzz/issues/276
-        #run: cargo install cargo-fuzz
-        run: cargo install --git https://github.com/rust-fuzz/cargo-fuzz --rev b4df3e58f767b5cad8d1aa6753961003f56f3609
-      - name: Cargo Fuzz Build
-        run: cargo fuzz build

.github/workflows/quality.yaml

@@ -1,113 +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
-          - aarch64-unknown-linux-musl
-          - x86_64-unknown-linux-gnu
-          - x86_64-unknown-linux-musl
-
-        experimental: [false]
-        include:
-          - rust: beta
-            target: aarch64-unknown-linux-gnu
-            experimental: true
-          - rust: beta
-            target: aarch64-unknown-linux-musl
-            experimental: true
-          - rust: beta
-            target: x86_64-unknown-linux-gnu
-            experimental: true
-          - rust: beta
-            target: x86_64-unknown-linux-musl
-            experimental: true
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Install Rust toolchain (${{ matrix.rust }})
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.rust }}
-          target: ${{ matrix.target }}
-          override: true
-          components: rustfmt, clippy
-
-      - name: Debug Check (default features)
-        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
-        run: |
-          set -e
-          commits=$(git rev-list origin/${{ github.base_ref }}..${{ github.sha }})
-          for commit in $commits; do git checkout $commit; cargo check --tests --examples --all --target=${{ matrix.target }}; done
-          git checkout ${{ github.sha }}
-
-      - name: Formatting (rustfmt)
-        run: cargo fmt -- --check
-
-      - name: Clippy (kvm)
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
-          command: clippy
-          args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --examples --features "kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Clippy (default features)
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
-          command: clippy
-          args: --target=${{ matrix.target }} --locked --all --all-targets --tests --examples -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Clippy (default features + guest_debug)
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
-          command: clippy
-          args: --target=${{ matrix.target }} --locked --all --all-targets --tests --examples --features "guest_debug" -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Clippy (default features + tracing)
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
-          command: clippy
-          args: --target=${{ matrix.target }} --locked --all --all-targets --tests --examples --features "tracing" -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Clippy (mshv)
-        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
-          command: clippy
-          args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --examples --features "mshv" -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Clippy (mshv + kvm)
-        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
-          command: clippy
-          args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --examples --features "mshv,kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Clippy (kvm + tdx)
-        if: ${{ matrix.target == 'x86_64-unknown-linux-gnu' }}
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.target != 'x86_64-unknown-linux-gnu' }}
-          command: clippy
-          args: --target=${{ matrix.target }} --locked --all --all-targets --no-default-features --tests --examples --features "tdx,kvm" -- -D warnings -D clippy::undocumented_unsafe_blocks
-
-      - name: Check build did not modify any files
-        run: test -z "$(git status --porcelain)"

.github/workflows/release.yaml

@@ -1,151 +0,0 @@
-name: Cloud Hypervisor Release
-on: [pull_request, create]
-
-jobs:
-  release:
-    if: (github.event_name == 'create' && github.event.ref_type == 'tag') || github.event_name == 'pull_request'
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@v2
-      - name: Install musl-gcc
-        run: sudo apt install -y musl-tools
-      - name: Create release directory
-        run: rsync -rv --exclude=.git . ../cloud-hypervisor-${{ github.event.ref }}
-      - name: Install Rust toolchain (x86_64-unknown-linux-gnu)
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: "1.67.1"
-          target: x86_64-unknown-linux-gnu
-      - name: Install Rust toolchain (x86_64-unknown-linux-musl)
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: "1.67.1"
-          target: x86_64-unknown-linux-musl
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          toolchain: "1.67.1"
-          command: build
-          args: --all --release --no-default-features --features "kvm,mshv" --target=x86_64-unknown-linux-gnu
-      - name: Static Build
-        uses: actions-rs/cargo@v1
-        with:
-          toolchain: "1.67.1"
-          command: build
-          args: --all --release --no-default-features --features "kvm,mshv" --target=x86_64-unknown-linux-musl
-      - name: Install Rust toolchain (aarch64-unknown-linux-musl)
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: "1.67.1"
-          target: aarch64-unknown-linux-musl
-          override: true
-      - name: Create Release
-        if: github.event_name == 'create' && github.event.ref_type == 'tag'
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: ${{ github.ref }}
-          draft: true
-          prerelease: true
-      - name: Upload cloud-hypervisor
-        if: github.event_name == 'create' && github.event.ref_type == 'tag'
-        id: upload-release-cloud-hypervisor
-        uses: actions/upload-release-asset@v1
-        env:
-          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
-        if: github.event_name == 'create' && github.event.ref_type == 'tag'
-        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
-        if: github.event_name == 'create' && github.event.ref_type == 'tag'
-        id: upload-release-ch-remote
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/x86_64-unknown-linux-gnu/release/ch-remote
-          asset_name: ch-remote
-          asset_content_type: application/octet-stream
-      - name: Upload static-ch-remote
-        if: github.event_name == 'create' && github.event.ref_type == 'tag'
-        id: upload-release-static-ch-remote
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/x86_64-unknown-linux-musl/release/ch-remote
-          asset_name: ch-remote-static
-          asset_content_type: application/octet-stream
-      - name: Clean build tree ahead of cross build
-        uses: actions-rs/cargo@v1
-        with:
-          command: clean
-      - name: Static Build (AArch64)
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: build
-          args: --all --release --target=aarch64-unknown-linux-musl
-      - name: Upload static AArch64 cloud-hypervisor
-        if: github.event_name == 'create' && github.event.ref_type == 'tag'
-        id: upload-release-static-aarch64-cloud-hypervisor
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/aarch64-unknown-linux-musl/release/cloud-hypervisor
-          asset_name: cloud-hypervisor-static-aarch64
-          asset_content_type: application/octet-stream
-      - name: Upload static AArch64 ch-remote
-        if: github.event_name == 'create' && github.event.ref_type == 'tag'
-        id: upload-release-static-aarch64-ch-remote
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: target/aarch64-unknown-linux-musl/release/ch-remote
-          asset_name: ch-remote-static-aarch64
-          asset_content_type: application/octet-stream
-      - name: Vendor
-        working-directory: ../cloud-hypervisor-${{ github.event.ref }}
-        run: |
-          mkdir ../vendor-cargo-home
-          export CARGO_HOME=$(realpath ../vendor-cargo-home)
-          mkdir .cargo
-          cargo vendor > .cargo/config.toml
-      - name: Create vendored source archive
-        working-directory: ../
-        run: tar cJf cloud-hypervisor-${{ github.event.ref }}.tar.xz cloud-hypervisor-${{ github.event.ref }}
-      - name: Upload cloud-hypervisor vendored source archive
-        if: github.event_name == 'create' && github.event.ref_type == 'tag'
-        id: upload-release-cloud-hypervisor-vendored-sources
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ../cloud-hypervisor-${{ github.event.ref }}.tar.xz
-          asset_name: cloud-hypervisor-${{ github.event.ref }}.tar.xz
-          asset_content_type: application/x-xz

.gitignore

@@ -1,8 +1,4 @@
-/build
-/.cargo
 /target
 **/*.rs.bk
 **/Cargo.lock
 **/rusty-tags.vi
-/rpm/SOURCES
-/.vscode

.rustfmt.toml

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

.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

CODEOWNERS

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

CONTRIBUTING.md

@@ -1,15 +1,6 @@
 # Contributing to Cloud Hypervisor
 
-Cloud Hypervisor is an open source project licensed under the [Apache v2
-License](https://opensource.org/licenses/Apache-2.0) and the [BSD 3
-Clause](https://opensource.org/licenses/BSD-3-Clause) license. Individual files
-contain details of their licensing and changes to that file are under the same
-license unless the contribution changes the license of the file. When importing
-code from a third party project (e.g. Firecracker or CrosVM) please respect the
-license of those projects.
-
-New code should be under the [Apache v2
-License](https://opensource.org/licenses/Apache-2.0).
+Cloud Hypervisor is an open source project licensed under the [Apache v2 License](https://opensource.org/licenses/Apache-2.0) and the [BSD 3 Clause](https://opensource.org/licenses/BSD-3-Clause) license.
 
 ## Coding Style
 
@@ -17,23 +8,6 @@ We follow the [Rust Style](https://github.com/rust-dev-tools/fmt-rfcs/blob/maste
 convention and enforce it through the Continuous Integration (CI) process calling into `rustfmt`
 for each submitted Pull Request (PR).
 
-## Basic Checks
-
-Please consider creating the following hook as `.git/hooks/pre-commit` in order
-to ensure basic correctness of your code. You can extend this further if you
-have specific features that you regularly develop against.
-
-```sh
-#!/bin/sh
-
-cargo fmt -- --check || exit 1
-cargo check --locked --all --all-targets --tests || exit 1
-cargo clippy --locked --all --all-targets --tests -- -D warnings || exit 1
-```
-
-You will need to `chmod +x .git/hooks/pre-commit` to have it run on every
-commit you make.
-
 ## Certificate of Origin
 
 In order to get a clear contribution chain of trust we use the [signed-off-by language](https://01.org/community/signed-process)
@@ -81,10 +55,12 @@ you want to merge your changes to `cloud-hypervisor`:
    into your github organization.
 2. Within your fork, create a branch for your contribution.
 3. [Create a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/)
-   against the main branch of the Cloud Hypervisor repository.
-4. To update your pull request amend existing commits whenever applicable and
+   against the master branch of the Cloud Hypervisor repository.
+4. Add reviewers to your pull request and then work with your reviewers to address
+   any comments and obtain minimum of 2 [maintainers](MAINTAINERS.md) approvals.
+   To update your pull request amend existing commits whenever applicable and
    then push the new changes to your pull request branch.
-5. Once the pull request is approved it can be integrated.
+5. Once the pull request is approved, one of the maintainers will merge it.
 
 ## Issue tracking
 
@@ -112,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,102 +1,68 @@
 [package]
 name = "cloud-hypervisor"
-version = "32.1.0"
+version = "0.5.1"
 authors = ["The Cloud Hypervisor Authors"]
-edition = "2021"
+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"
-# Minimum buildable version:
-# Keep in sync with version in .github/workflows/build.yaml
-# Policy on MSRV (see #4318):
-# Can only be bumped by:
-# a.) A dependency requires it,
-# b.) If we want to use a new feature and that MSRV is at least 6 months old,
-# c.) There is a security issue that is addressed by the toolchain update.
-rust-version = "1.62"
-
-[profile.release]
-lto = true
-codegen-units = 1
-opt-level = "s"
-strip = true
-
-[profile.profiling]
-inherits = "release"
-strip = false
-debug = true
 
 [dependencies]
-anyhow = "1.0.70"
-api_client = { path = "api_client" }
-argh = "0.1.9"
-dhat = { version = "0.3.2", optional = true }
-epoll = "4.3.1"
-event_monitor = { path = "event_monitor" }
-hypervisor = { path = "hypervisor" }
-libc = "0.2.139"
-log = { version = "0.4.17", features = ["std"] }
-option_parser = { path = "option_parser" }
-seccompiler = "0.3.0"
-serde_json = "1.0.96"
-signal-hook = "0.3.15"
-thiserror = "1.0.39"
-tpm = { path = "tpm"}
-tracer = { path = "tracer" }
+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.11.0"
-vm-memory = "0.10.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" }
 
-# List of patched crates
-[patch.crates-io]
-kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.6.0-tdx" }
-kvm-ioctls = { git = "https://github.com/rust-vmm/kvm-ioctls", branch = "main" }
-versionize_derive = { git = "https://github.com/cloud-hypervisor/versionize_derive", branch = "ch" }
+[dependencies.vhost_rs]
+path = "vhost_rs"
+features = ["vhost-user-slave"]
 
 [dev-dependencies]
-dirs = "5.0.0"
-net_util = { path = "net_util" }
-once_cell = "1.17.1"
-serde_json = "1.0.96"
-test_infra = { path = "test_infra" }
-wait-timeout = "0.2.0"
+ssh2 = "0.7.1"
+dirs = "2.0.2"
+credibility = "0.1.3"
+tempdir= "0.3.7"
+lazy_static= "1.4.0"
+serde_json = "1.0.48"
 
 [features]
-default = ["kvm"]
-dhat-heap = ["dhat"] # For heap profiling
-guest_debug = ["vmm/guest_debug"]
-kvm = ["vmm/kvm"]
-mshv = ["vmm/mshv"]
-tdx = ["vmm/tdx"]
-tracing = ["vmm/tracing", "tracer/tracing"]
+default = ["acpi", "pci", "cmos"]
+acpi = ["vmm/acpi"]
+pci = ["vmm/pci_support"]
+mmio = ["vmm/mmio_support"]
+cmos = ["vmm/cmos"]
+
+# Integration tests require a special environment to run in
+integration_tests = []
 
 [workspace]
 members = [
-    "api_client",
     "arch",
-    "block_util",
     "devices",
-    "event_monitor",
-    "hypervisor",
-    "net_gen",
-    "net_util",
-    "option_parser",
-    "pci",
-    "performance-metrics",
+    "vhost_rs",
     "qcow",
-    "rate_limiter",
-    "serial_buffer",
-    "test_infra",
-    "tracer",
-    "vhdx",
-    "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",
 ]

Jenkinsfile

@@ -1,452 +1,85 @@
-def runWorkers = true
-pipeline {
-    agent none
-    options {
-        timeout(time: 4, unit: 'HOURS')
-    }
-    stages {
-        stage('Early checks') {
-            agent { node { label 'built-in' } }
-            stages {
-                stage('Checkout') {
-                    steps {
-                        checkout scm
-                    }
-                }
-                stage('Check if worker build can be skipped') {
-                    when {
-                        expression {
-                            return skipWorkerBuild()
-                        }
-                    }
-                    steps {
-                        script {
-                            runWorkers = false
-                            echo 'No changes requring a build'
-                        }
-                    }
-                }
-                stage('Check for RFC/WIP builds') {
-                    when {
-                        changeRequest comparator: 'REGEXP', title: '.*(rfc|RFC|wip|WIP).*'
-                        beforeAgent true
-                    }
-                    steps {
-                        error('Failing as this is marked as a WIP or RFC PR.')
-                    }
-                }
-                stage('Cancel older builds') {
-                    when { not { branch 'main' } }
-                    steps {
-                        cancelPreviousBuilds()
-                    }
-                }
-            }
-        }
-        stage('Build') {
-            parallel {
-                stage('Worker build') {
-                    agent { node { label 'jammy' } }
-                    when {
-                        beforeAgent true
-                        expression {
-                            return runWorkers
-                        }
-                    }
-                    stages {
-                        stage('Checkout') {
-                            steps {
-                                checkout scm
-                            }
-                        }
-                        stage('Prepare environment') {
-                            steps {
-                                sh 'scripts/prepare_vdpa.sh'
-                            }
-                        }
-                        stage('Run OpenAPI tests') {
-                            steps {
-                                sh 'scripts/run_openapi_tests.sh'
-                            }
-                        }
-                        stage('Run unit tests') {
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --unit'
-                            }
-                        }
-                        stage('Run integration tests') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'sudo modprobe openvswitch'
-                                sh 'scripts/dev_cli.sh tests --integration'
-                            }
-                        }
-                        stage('Run live-migration integration tests') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'sudo modprobe openvswitch'
-                                sh 'scripts/dev_cli.sh tests --integration-live-migration'
-                            }
-                        }
-                        stage('Run unit tests for musl') {
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --unit --libc musl'
-                            }
-                        }
-                        stage('Run integration tests for musl') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'sudo modprobe openvswitch'
-                                sh 'scripts/dev_cli.sh tests --integration --libc musl'
-                            }
-                        }
-                        stage('Run live-migration integration tests for musl') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'sudo modprobe openvswitch'
-                                sh 'scripts/dev_cli.sh tests --integration-live-migration --libc musl'
-                            }
-                        }
-                    }
-                }
-                stage('AArch64 worker build') {
-                    agent { node { label 'bionic-arm64' } }
-                    when {
-                        beforeAgent true
-                        expression {
-                            return runWorkers
-                        }
-                    }
-                    environment {
-                            AZURE_CONNECTION_STRING = credentials('46b4e7d6-315f-4cc1-8333-b58780863b9b')
-                    }
-                    stages {
-                        stage('Checkout') {
-                            steps {
-                                checkout scm
-                            }
-                        }
-                        stage('Run unit tests') {
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --unit --libc musl'
-                            }
-                        }
-                        stage('Run integration tests') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'sudo modprobe openvswitch'
-                                sh 'scripts/dev_cli.sh tests --integration --libc musl'
-                            }
-                        }
-                        stage('Install azure-cli') {
-                            steps {
-                                installAzureCli('bionic', 'arm64')
-                            }
-                        }
-                        stage('Download Windows image') {
-                            steps {
-                                sh '''#!/bin/bash -x
-                                    IMG_BASENAME=windows-11-iot-enterprise-aarch64.raw
-                                    IMG_PATH=$HOME/workloads/$IMG_BASENAME
-                                    IMG_GZ_PATH=$HOME/workloads/$IMG_BASENAME.gz
-                                    IMG_GZ_BLOB_NAME=windows-11-iot-enterprise-aarch64-9-min.raw.gz
-                                    cp "scripts/$IMG_BASENAME.sha1" "$HOME/workloads/"
-                                    pushd "$HOME/workloads"
-                                    if sha1sum "$IMG_BASENAME.sha1" --check; then
-                                        exit
-                                    fi
-                                    popd
-                                    mkdir -p "$HOME/workloads"
-                                    az storage blob download \
-                                        --container-name private-images \
-                                        --file "$IMG_GZ_PATH" \
-                                        --name "$IMG_GZ_BLOB_NAME" \
-                                        --connection-string "$AZURE_CONNECTION_STRING"
-                                    gzip -d $IMG_GZ_PATH
-                                '''
-                            }
-                        }
-                        stage('Run Windows guest integration tests') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --integration-windows --libc musl'
-                            }
-                        }
-                    }
-                    post {
-                        always {
-                            sh "sudo chown -R jenkins.jenkins ${WORKSPACE}"
-                            deleteDir()
-                        }
-                    }
-                }
-                // stage('Worker build - Windows guest') {
-                //     agent { node { label 'jammy' } }
-                //     when {
-                //         beforeAgent true
-                //         expression {
-                //             return runWorkers
-                //         }
-                //     }
-                //     environment {
-                //             AZURE_CONNECTION_STRING = credentials('46b4e7d6-315f-4cc1-8333-b58780863b9b')
-                //     }
-                //     stages {
-                //         stage('Checkout') {
-                //             steps {
-                //                 checkout scm
-                //             }
-                //         }
-                //         stage('Install azure-cli') {
-                //             steps {
-                //                 installAzureCli('jammy', 'amd64')
-                //             }
-                //         }
-                //         stage('Download assets') {
-                //             steps {
-                //                 sh "mkdir ${env.HOME}/workloads"
-                //                 sh 'az storage blob download --container-name private-images --file "$HOME/workloads/windows-server-2022-amd64-2.raw" --name windows-server-2022-amd64-2.raw --connection-string "$AZURE_CONNECTION_STRING"'
-                //             }
-                //         }
-                //         stage('Run Windows guest integration tests') {
-                //             options {
-                //                 timeout(time: 1, unit: 'HOURS')
-                //             }
-                //             steps {
-                //                 sh 'scripts/dev_cli.sh tests --integration-windows'
-                //             }
-                //         }
-                //         stage('Run Windows guest integration tests for musl') {
-                //             options {
-                //                 timeout(time: 1, unit: 'HOURS')
-                //             }
-                //             steps {
-                //                 sh 'scripts/dev_cli.sh tests --integration-windows --libc musl'
-                //             }
-                //         }
-                //     }
-                // }
-                stage('Worker build - Metrics') {
-                    agent { node { label 'jammy-metrics' } }
-                    when {
-                        branch 'main'
-                        beforeAgent true
-                        expression {
-                            return runWorkers
-                        }
-                    }
-                    environment {
-                        METRICS_PUBLISH_KEY = credentials('52e0945f-ce7a-43d1-87af-67d1d87cc40f')
-                    }
-                    stages {
-                        stage('Checkout') {
-                            steps {
-                                checkout scm
-                            }
-                        }
-                        stage('Run metrics tests') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --metrics -- -- --report-file /root/workloads/metrics.json'
-                            }
-                        }
-                        stage('Upload metrics report') {
-                            steps {
-                                sh 'curl -X PUT https://cloud-hypervisor-metrics.azurewebsites.net/api/publishmetrics -H "x-functions-key: $METRICS_PUBLISH_KEY" -T ~/workloads/metrics.json'
-                            }
-                        }
-                    }
-                }
-                stage('Worker build - Rate Limiter') {
-                    agent { node { label 'focal-metrics' } }
-                    when {
-                        branch 'main'
-                        beforeAgent true
-                        expression {
-                            return runWorkers
-                        }
-                    }
-                    stages {
-                        stage('Checkout') {
-                            steps {
-                                checkout scm
-                            }
-                        }
-                        stage('Run rate-limiter integration tests') {
-                            options {
-                                timeout(time: 10, unit: 'MINUTES')
-                            }
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --integration-rate-limiter'
-                            }
-                        }
-                    }
-                }
-                stage('Worker build - SGX') {
-                    agent { node { label 'jammy-sgx' } }
-                    when {
-                        beforeAgent true
-                        allOf {
-                            branch 'main'
-                            expression {
-                                return runWorkers
-                            }
-                        }
-                    }
-                    stages {
-                        stage('Checkout') {
-                            steps {
-                                checkout scm
-                            }
-                        }
-                        stage('Run SGX integration tests') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --integration-sgx'
-                            }
-                        }
-                        stage('Run SGX integration tests for musl') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --integration-sgx --libc musl'
-                            }
-                        }
-                    }
-                    post {
-                        always {
-                            sh "sudo chown -R jenkins.jenkins ${WORKSPACE}"
-                            deleteDir()
-                        }
-                    }
-                }
-                stage('Worker build - VFIO') {
-                    agent { node { label 'jammy-vfio' } }
-                    when {
-                        beforeAgent true
-                        allOf {
-                            branch 'main'
-                            expression {
-                                return runWorkers
-                            }
-                        }
-                    }
-                    stages {
-                        stage('Checkout') {
-                            steps {
-                                checkout scm
-                            }
-                        }
-                        stage('Run VFIO integration tests') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --integration-vfio'
-                            }
-                        }
-                        stage('Run VFIO integration tests for musl') {
-                            options {
-                                timeout(time: 1, unit: 'HOURS')
-                            }
-                            steps {
-                                sh 'scripts/dev_cli.sh tests --integration-vfio --libc musl'
-                            }
-                        }
-                    }
-                    post {
-                        always {
-                            sh "sudo chown -R jenkins.jenkins ${WORKSPACE}"
-                            deleteDir()
-                        }
-                    }
-                }
-            }
-        }
-    }
-    post {
-        regression {
-            script {
-                if (env.BRANCH_NAME == 'main') {
-                    slackSend(color: '#ff0000', message: '"main" branch build is now failing', channel: '#jenkins-ci')
-                }
-            }
-        }
-        fixed {
-            script {
-                if (env.BRANCH_NAME == 'main') {
-                    slackSend(color: '#00ff00', message: '"main" branch build is now fixed', channel: '#jenkins-ci')
-                }
-            }
-        }
-    }
+pipeline{
+	agent none
+	stages {
+		stage ('Master build') {
+			agent { node { label 'master' } }
+			stages {
+				stage ('Check for RFC/WIP builds') {
+					when {
+  						changeRequest comparator: 'REGEXP', title: '.*(rfc|RFC|wip|WIP).*'
+  						beforeAgent true
+					}
+					steps {
+						error("Failing as this is marked as a WIP or RFC PR.")
+					}
+				}
+				stage ('Cancel older builds') {
+					steps {
+						cancelPreviousBuilds()
+					}
+				}
+			}
+		}
+		stage ('Worker build') {
+			agent { node { label 'bionic' } }
+			options {
+				timeout(time: 1, unit: 'HOURS')
+			}
+			stages {
+				stage ('Checkout') {
+					steps {
+						checkout scm
+					}
+				}
+				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"
+					}
+				}
+			}
+		}
+	}
 }
 
 def cancelPreviousBuilds() {
-    // Check for other instances of this particular build, cancel any that are older than the current one
-    def jobName = env.JOB_NAME
-    def currentBuildNumber = env.BUILD_NUMBER.toInteger()
-    def currentJob = Jenkins.instance.getItemByFullName(jobName)
+	// Check for other instances of this particular build, cancel any that are older than the current one
+	def jobName = env.JOB_NAME
+		def currentBuildNumber = env.BUILD_NUMBER.toInteger()
+		def currentJob = Jenkins.instance.getItemByFullName(jobName)
 
-    // Loop through all instances of this particular job/branch
-    for (def build : currentJob.builds) {
-        if (build.isBuilding() && (build.number.toInteger() < currentBuildNumber)) {
-            echo "Older build still queued. Sending kill signal to build number: ${build.number}"
-            build.doStop()
-        }
-    }
-}
-
-def installAzureCli(distro, arch) {
-    sh 'sudo apt install -y ca-certificates curl apt-transport-https lsb-release gnupg'
-    sh 'curl -sL https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/microsoft.gpg > /dev/null'
-    sh "echo \"deb [arch=${arch}] https://packages.microsoft.com/repos/azure-cli/ ${distro} main\" | sudo tee /etc/apt/sources.list.d/azure-cli.list"
-    sh 'sudo apt update'
-    sh 'sudo apt install -y azure-cli'
-}
-
-def boolean skipWorkerBuild() {
-    if (env.CHANGE_TARGET == null) {
-        return false
-    }
-
-    if (sh(
-        returnStatus: true,
-        script: "git diff --name-only origin/${env.CHANGE_TARGET}... | grep -v '\\.md'"
-    ) != 0) {
-        return true
-    }
-
-    if (sh(
-        returnStatus: true,
-        script: "git diff --name-only origin/${env.CHANGE_TARGET}... | grep -v -E 'fuzz/'"
-    ) != 0) {
-        return true
-    }
-
-    if (sh(
-        returnStatus: true,
-        script: "git diff --name-only origin/${env.CHANGE_TARGET}... | grep -v -E '.github/'"
-    ) != 0) {
-        return true
-    }
-
-    return false
+		// Loop through all instances of this particular job/branch
+		for (def build : currentJob.builds) {
+			if (build.isBuilding() && (build.number.toInteger() < currentBuildNumber)) {
+				echo "Older build still queued. Sending kill signal to build number: ${build.number}"
+				build.doStop()
+			}
+		}
 }

MAINTAINERS.md

@@ -1,8 +1,6 @@
 # Maintainers
 
-- Sebastien Boeuf - @sboeuf
-- Robert Bradford - @rbradford
-- Bo Chen - @likebreath
-- Samuel Ortiz - @sameo
-- Wei Liu - @liuw
-- Michael Zhao - @michael2012z
+- Sebastien Boeuf <sebastien.boeuf@intel.com> @sboeuf
+- Robert Bradford <robert.bradford@intel.com> @rbradford
+- Samuel Ortiz <sameo@linux.intel.com> @sameo
+- Chao P Peng <chao.p.peng@linux.intel.com> @chao-p

README.md

@@ -1,387 +1,324 @@
-- [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)
-  - [Host OS](#host-os)
-  - [Use Pre-built Binaries](#use-pre-built-binaries)
-  - [Packages](#packages)
-  - [Building from Source](#building-from-source)
-  - [Booting Linux](#booting-linux)
-    - [Firmware Booting](#firmware-booting)
-    - [Custom Kernel and Disk Image](#custom-kernel-and-disk-image)
-      - [Building your Kernel](#building-your-kernel)
-      - [Disk image](#disk-image)
-      - [Booting the guest VM](#booting-the-guest-vm)
-- [3. Status](#3-status)
-  - [Hot Plug](#hot-plug)
-  - [Device Model](#device-model)
-  - [Roadmap](#roadmap)
-- [4. Relationship with _Rust VMM_ Project](#4-relationship-with-rust-vmm-project)
-  - [Differences with Firecracker and crosvm](#differences-with-firecracker-and-crosvm)
-- [5. Community](#5-community)
-  - [Contribute](#contribute)
-  - [Slack](#slack)
-  - [Mailing list](#mailing-list)
-  - [Security issues](#security-issues)
+[![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)
+   * [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 the [KVM](https://www.kernel.org/doc/Documentation/virtual/kvm/api.txt)
-hypervisor and the Microsoft Hypervisor (MSHV).
+**This project is an experiment and should not be used with production workloads.**
 
-The project focuses on running modern, _Cloud Workloads_, on specific, common,
-hardware architectures. In this case _Cloud Workloads_ refers to those that are
-run by customers inside a Cloud Service Provider. This means modern operating
-systems with most I/O handled by
-paravirtualised devices (e.g. _virtio_), no requirement for legacy devices, and
-64-bit CPUs.
+Cloud Hypervisor is 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
+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.
+Cloud Hypervisor is implemented in [Rust](https://www.rust-lang.org/) and is based on the [rust-vmm](https://github.com/rust-vmm) crates.
 
 ## Objectives
 
 ### 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
-minor 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
 
-The following sections describe how to build and run Cloud Hypervisor.
-
-## Prerequisites for AArch64
-
-- AArch64 servers (recommended) or development boards equipped with the GICv3
-  interrupt controller.
-
-## Host OS
-
-For required KVM functionality the minimum host kernel version is 4.11.  For
-adequate performance the minimum recommended host kernel version is 5.6. The
-majority of the CI currently tests with kernel version 5.15.
-
-## Use Pre-built Binaries
-
-The recommended approach to getting started with Cloud Hypervisor is by using a
-pre-built binary. Binaries are available for the [latest
-release](https://github.com/cloud-hypervisor/cloud-hypervisor/releases/latest).
-Use `cloud-hypervisor-static` for `x86-64` or `cloud-hypervisor-static-aarch64`
-for `AArch64` platform.
-
-## Packages
-
-For convenience, packages are also available targeting some popular Linux
-distributions. This is thanks to the [Open Build
-Service](https://build.opensuse.org). The [OBS
-README](https://github.com/cloud-hypervisor/obs-packaging) explains how to
-enable the repository in a supported Linux distribution and install Cloud Hypervisor
-and accompanying packages. Please report any packaging issues in the
-[obs-packaging](https://github.com/cloud-hypervisor/obs-packaging) repository.
-
-## Building from Source
-
-Please see the [instructions for building from source](docs/building.md) if you
-do not wish to use the pre-built binaries.
-
-## Booting Linux
-
-Cloud Hypervisor supports direct kernel boot (the x86-64 kernel requires the kernel
-built with PVH support) or booting via a firmware (either [Rust Hypervisor
-Firmware](https://github.com/cloud-hypervisor/rust-hypervisor-firmware) or an
-edk2 UEFI firmware called `CLOUDHV` / `CLOUDHV_EFI`.)
-
-Binary builds of the firmware files are available for the latest release of
-[Rust Hypervisor
-Firmware](https://github.com/cloud-hypervisor/rust-hypervisor-firmware/releases/latest)
-and [our edk2
-repository](https://github.com/cloud-hypervisor/edk2/releases/latest)
-
-The choice of firmware depends on your guest OS choice; some experimentation
-may be required.
-
-### Firmware Booting
-
-Cloud Hypervisor supports booting disk images containing all needed components
-to run cloud workloads, a.k.a. cloud images.
-
-The following sample commands will download an Ubuntu Cloud image, converting
-it into a format that Cloud Hypervisor can use and a firmware to boot the image
-with.
+We create a folder to build and run `cloud-hypervisor` at `$HOME/cloud-hypervisor`
 
 ```shell
-$ wget https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-amd64.img
-$ qemu-img convert -p -f qcow2 -O raw focal-server-cloudimg-amd64.img focal-server-cloudimg-amd64.raw
-$ wget https://github.com/cloud-hypervisor/rust-hypervisor-firmware/releases/download/0.4.2/hypervisor-fw
+$ export CLOUDH=$HOME/cloud-hypervisor
+$ mkdir $CLOUDH
 ```
 
-The Ubuntu cloud images do not ship with a default password so it necessary to
-use a `cloud-init` disk image to customise the image on the first boot. A basic
-`cloud-init` image is generated by this [script](scripts/create-cloud-init.sh).
-This seeds the image with a default username/password of `cloud/cloud123`. It
-is only necessary to add this disk image on the first boot.
+## Clone and build
+
+First you need to clone and build the cloud-hypervisor repo:
 
 ```shell
-$ sudo setcap cap_net_admin+ep ./cloud-hypervisor
-$ ./create-cloud-init.sh
-$ ./cloud-hypervisor \
-	--kernel ./hypervisor-fw \
-	--disk path=focal-server-cloudimg-amd64.raw --disk path=/tmp/ubuntu-cloudinit.img \
-	--cpus boot=4 \
-	--memory size=1024M \
-	--net "tap=,mac=,ip=,mask="
+$ pushd $CLOUDH
+$ git clone https://github.com/cloud-hypervisor/cloud-hypervisor.git
+$ cd cloud-hypervisor
+$ cargo build --release
+
+# We need to give the cloud-hypervisor binary the NET_ADMIN capabilities for it to set TAP interfaces up on the host.
+$ sudo setcap cap_net_admin+ep ./target/release/cloud-hypervisor
+
+$ popd
 ```
 
-If access to the firmware messages or interaction with the boot loader (e.g.
-GRUB) is required then it necessary to switch to the serial console instead of
-`virtio-console`.
+This will build a `cloud-hypervisor` binary under `$CLOUDH/cloud-hypervisor/target/release/cloud-hypervisor`.
+
+### Containerized builds and tests
+
+If you want to build and test Cloud Hypervisor without having to install all the
+required dependencies (The rust toolchain, cargo tools, etc), you can also use
+Cloud Hypervisor's development script: `dev_cli.sh`. Please note that upon its
+first invocation, this script will pull a fairly large container image.
+
+For example, to build the Cloud Hypervisor release binary:
 
 ```shell
-$ ./cloud-hypervisor \
+$ pushd $CLOUDH
+$ cd cloud-hypervisor
+$ ./scripts/dev_cli.sh build --release
+```
+
+With `dev_cli.sh`, one can also run the Cloud Hypervisor CI locally. This can be
+very convenient for debugging CI errors without having to fully rely on the
+Cloud Hypervisor CI infrastructure.
+
+For example, to run the Cloud Hypervisor unit tests:
+
+```shell
+$ ./scripts/dev_cli.sh tests --unit
+```
+
+Run the `./scripts/dev_cli.sh --help` command to view all the supported
+development script commands and their related options.
+
+## Run
+
+You can run a guest VM by either using an existing cloud image or booting into your own kernel and disk image.
+
+### Cloud image
+
+`cloud-hypervisor` supports booting disk images containing all needed
+components to run cloud workloads, a.k.a. cloud images.  To do that we rely on
+the [Rust Hypervisor
+Firmware](https://github.com/cloud-hypervisor/rust-hypervisor-firmware) project to provide
+an ELF
+formatted KVM firmware for `cloud-hypervisor` to directly boot into.
+
+We need to get the latest `rust-hypervisor-firmware` release and also a working cloud image. Here we will use a Clear Linux image:
+
+```shell
+$ pushd $CLOUDH
+$ 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
+```
+
+```shell
+$ pushd $CLOUDH
+$ sudo setcap cap_net_admin+ep ./cloud-hypervisor/target/release/cloud-hypervisor
+$ ./cloud-hypervisor/target/release/cloud-hypervisor \
 	--kernel ./hypervisor-fw \
-	--disk path=focal-server-cloudimg-amd64.raw --disk path=/tmp/ubuntu-cloudinit.img \
+	--disk path=clear-31890-kvm.img \
 	--cpus boot=4 \
 	--memory size=1024M \
 	--net "tap=,mac=,ip=,mask=" \
-	--serial tty \
-	--console off
+	--rng
+$ popd
 ```
 
-### Custom Kernel and Disk Image
+Multiple arguments can be given to the `--disk` parameter.
 
-#### Building your Kernel
+### Custom kernel and disk image
 
-Cloud Hypervisor also supports direct kernel boot. For x86-64, a `vmlinux` ELF kernel (compiled with PVH support) is needed. In order to support development there is a custom branch; however provided the required options are enabled any recent kernel will suffice.
+#### Building your kernel
+
+`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:
 
 ```shell
+
 # Clone the Cloud Hypervisor Linux branch
-$ git clone --depth 1 https://github.com/cloud-hypervisor/linux.git -b ch-6.2 linux-cloud-hypervisor
+$ pushd $CLOUDH
+$ 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 x86-64 cloud-hypervisor kernel config to build your kernel for x86-64
-$ wget https://raw.githubusercontent.com/cloud-hypervisor/cloud-hypervisor/main/resources/linux-config-x86_64
-# Use the AArch64 cloud-hypervisor kernel config to build your kernel for AArch64
-$ wget https://raw.githubusercontent.com/cloud-hypervisor/cloud-hypervisor/main/resources/linux-config-aarch64
-$ cp linux-config-x86_64 .config  # x86-64
-$ cp linux-config-aarch64 .config # AArch64
-# Do native build of the x86-64 kernel
-$ KCFLAGS="-Wa,-mx86-used-note=no" make bzImage -j `nproc`
-# Do native build of the AArch64 kernel
-$ make -j `nproc`
+
+# Use the cloud-hypervisor kernel config to build your kernel
+$ cp $CLOUDH/cloud-hypervisor/resources/linux-virtio-fs-virtio-iommu-config .config
+$ make bzImage -j `nproc`
 $ popd
 ```
 
-For x86-64, the `vmlinux` kernel image will then be located at
-`linux-cloud-hypervisor/arch/x86/boot/compressed/vmlinux.bin`.
-For AArch64, the `Image` kernel image will then be located at
-`linux-cloud-hypervisor/arch/arm64/boot/Image`.
+The `vmlinux` kernel image will then be located at `linux-cloud-hypervisor/arch/x86/boot/compressed/vmlinux.bin`.
 
 #### Disk image
 
-For the disk image the same Ubuntu image as before can be used. This contains
-an `ext4` root filesystem.
+For the disk image, we will use a Clear Linux cloud image that contains a root partition:
 
 ```shell
-$ wget https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-amd64.img # x86-64
-$ wget https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-arm64.img # AArch64
-$ qemu-img convert -p -f qcow2 -O raw focal-server-cloudimg-amd64.img focal-server-cloudimg-amd64.raw # x86-64
-$ qemu-img convert -p -f qcow2 -O raw focal-server-cloudimg-arm64.img focal-server-cloudimg-arm64.raw # AArch64
+$ pushd $CLOUDH
+$ wget https://download.clearlinux.org/releases/31890/clear/clear-31890-kvm.img.xz
+$ unxz clear-31890-kvm.img.xz
+$ popd
 ```
 
 #### Booting the guest VM
 
-These sample commands boot the disk image using the custom kernel whilst also
-supplying the desired kernel command line.
-
-- x86-64
+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
-$ sudo setcap cap_net_admin+ep ./cloud-hypervisor
-$ ./create-cloud-init.sh
-$ ./cloud-hypervisor \
+$ 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 --disk path=/tmp/ubuntu-cloudinit.img \
-	--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="
+	--net "tap=,mac=,ip=,mask=" \
+	--rng
 ```
 
-- AArch64
+The above example use the `virtio-console` device as the guest console, and this
+device may not be enabled soon enough by the guest kernel to get early kernel
+debug messages.
+
+When in need for earlier debug messages, using the legacy serial device based
+console is preferred:
 
-```shell
-$ sudo setcap cap_net_admin+ep ./cloud-hypervisor
-$ ./create-cloud-init.sh
-$ ./cloud-hypervisor \
-	--kernel ./linux-cloud-hypervisor/arch/arm64/boot/Image \
-	--disk path=focal-server-cloudimg-arm64.raw --disk path=/tmp/ubuntu-cloudinit.img \
-	--cmdline "console=hvc0 root=/dev/vda1 rw" \
-	--cpus boot=4 \
-	--memory size=1024M \
-	--net "tap=,mac=,ip=,mask="
 ```
-
-If earlier kernel messages are required the serial console should be used instead of `virtio-console`.
-
-- x86-64
-
-```shell
-$ ./cloud-hypervisor \
+$ ./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="
-```
-
-- AArch64
-
-```shell
-$ ./cloud-hypervisor \
-	--kernel ./linux-cloud-hypervisor/arch/arm64/boot/Image \
-	--console off \
-	--serial tty \
-	--disk path=focal-server-cloudimg-arm64.raw \
-	--cmdline "console=ttyAMA0 root=/dev/vda1 rw" \
-	--cpus boot=4 \
-	--memory size=1024M \
-	--net "tap=,mac=,ip=,mask="
+	--net "tap=,mac=,ip=,mask=" \
+	--rng
 ```
 
 # 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 major releases notice. Where possible
-  warnings will be given about the use of deprecated functionality and the
-  deprecations will be documented in the release notes.
+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)
 
-* Point releases will be made between individual releases where there are
-  substantial bug fixes or security issues that need to be fixed. These point
-  releases will only include bug fixes.
-
-Currently the following items are **not** guaranteed across updates:
-
-* Snapshot/restore is not supported across different versions
-* Live migration is not supported across different versions
-* The following features are considered experimental and may change
-  substantially between releases: TDX, vfio-user, vDPA.
-
-Further details can be found in the [release documentation](docs/releases.md).
-
-As of 2023-01-03, the following cloud images are supported:
-
-- [Ubuntu Focal](https://cloud-images.ubuntu.com/focal/current/) (focal-server-cloudimg-{amd64,arm64}.img)
-- [Ubuntu Jammy](https://cloud-images.ubuntu.com/jammy/current/) (jammy-server-cloudimg-{amd64,arm64}.img )
-- [Fedora 36](https://fedora.mirrorservice.org/fedora/linux/releases/36/Cloud/) ([Fedora-Cloud-Base-36-1.5.x86_64.raw.xz](https://fedora.mirrorservice.org/fedora/linux/releases/36/Cloud/x86_64/images/) / [Fedora-Cloud-Base-36-1.5.aarch64.raw.xz](https://fedora.mirrorservice.org/fedora/linux/releases/36/Cloud/aarch64/images/))
-
-Direct kernel boot to userspace should work with a rootfs from most
-distributions although you may need to enable exotic filesystem types in the
-reference kernel configuration (e.g. XFS or btrfs.)
+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).
 
-## Roadmap
+## TODO
 
-The project roadmap is tracked through a [GitHub
-project](https://github.com/orgs/cloud-hypervisor/projects/6).
+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. Relationship with _Rust VMM_ Project
+# 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.
+In order to satisfy the design goal of having a high-performance, security-focused hypervisor the decision
+was made to use the [Rust](https://www.rust-lang.org/) programming language.
+The language's strong focus on memory and thread safety makes it an ideal candidate for implementing VMMs
 
-Instead of implementing the VMM components from scratch, Cloud Hypervisor is
-importing the [Rust VMM](https://github.com/rust-vmm) crates, and sharing code
-and architecture together with other VMMs like e.g. Amazon's
-[Firecracker](https://firecracker-microvm.github.io/) and Google's
-[crosvm](https://chromium.googlesource.com/chromiumos/platform/crosvm/).
+Instead of implementing the VMM components from scratch, `cloud-hypervisor` is importing the [rust-vmm](https://github.com/rust-vmm)
+crates, and sharing code and architecture together with other VMMs like e.g. Amazon's [Firecracker](https://firecracker-microvm.github.io/)
+and Google's [crosvm](https://chromium.googlesource.com/chromiumos/platform/crosvm/).
 
-Cloud Hypervisor embraces the _Rust VMM_ project's goals, which is to be able
-to share and re-use as many virtualization crates as possible.
+`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:
 
-## Differences with Firecracker and crosvm
+1. It will use as much of the rust-vmm code as possible. Any new rust-vmm crate that's relevant to the project
+   goals will be integrated as soon as possible.
+2. As it is likely that the rust-vmm project will lack some of the features that `cloud-hypervisor` needs (e.g. ACPI,
+   VFIO, vhost-user, etc), we will be using the `cloud-hypervisor` VMM to implement and test them, and contribute them
+   back to the rust-vmm project.
 
-A large part of the Cloud Hypervisor code is based on either the Firecracker or
-the crosvm project's implementations. Both of these are VMMs written in Rust
-with a focus on safety and security, like Cloud Hypervisor.
+## Firecracker and crosvm
 
-The goal of the Cloud Hypervisor project differs from the aforementioned
-projects in that it aims to be a general purpose VMM for _Cloud Workloads_ and
-not limited to container/serverless or client workloads.
+A large part of the `cloud-hypervisor` code is based on either the Firecracker or the crosvm projects implementations.
+Both of these are VMMs written in Rust with a focus on safety and security, like Cloud Hypervisor.
 
-The Cloud Hypervisor community thanks the communities of both the Firecracker
-and crosvm projects for their excellent work.
+However we want to emphasize that the Cloud Hypervisor project is neither a fork nor a reimplementation of any of those
+projects. The goals and use cases we're trying to meet are different.
+We're aiming at supporting cloud workloads, i.e. those modern, full Linux distribution images currently being run by
+Cloud Service Provider (CSP) tenants.
+
+Our primary target is not to support client or serverless use cases, and as such our code base already diverges
+from the crosvm and Firecracker ones. As we add more features to support our use cases, we believe that the divergence
+will increase while at the same time sharing as much of the fundamental virtualization code through the rust-vmm project
+crates as possible.
 
 # 5. Community
 
-The Cloud Hypervisor project follows the governance, and community guidelines
-described in the [Community](https://github.com/cloud-hypervisor/community)
-repository.
+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.
 
-## Contribute
+We believe that contributing to a open source project like Cloud Hypervisor covers a lot more than just sending
+code. Testing, documentation, pull request reviews, bug reports, feature requests, project improvement suggestions,
+etc, are all equal and welcome means of contribution. See the [CONTRIBUTING](CONTRIBUTING.md) document for more details.
 
-The project strongly believes in building a global, diverse and collaborative
-community around the Cloud Hypervisor project. Anyone who is interested in
-[contributing](CONTRIBUTING.md) to the project is welcome to participate.
+## Join us
 
-Contributing to a open source project like Cloud Hypervisor covers a lot more
-than just sending code. Testing, documentation, pull request
-reviews, bug reports, feature requests, project improvement suggestions, etc,
-are all equal and welcome means of contribution. See the
-[CONTRIBUTING](CONTRIBUTING.md) document for more details.
+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/).
 
-## Slack
+# 6. Security
 
-Get an [invite to our Slack channel](https://join.slack.com/t/cloud-hypervisor/shared_invite/enQtNjY3MTE3MDkwNDQ4LWQ1MTA1ZDVmODkwMWQ1MTRhYzk4ZGNlN2UwNTI3ZmFlODU0OTcwOWZjMTkwZDExYWE3YjFmNzgzY2FmNDAyMjI),
- [join us on Slack](https://cloud-hypervisor.slack.com/), and [participate in our community activities](https://cloud-hypervisor.slack.com/archives/C04R5DUQVBN).
+**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.
 
-## Mailing list
+It is important to include the following details:
+  - The projects and versions affected
+  - Detailed description of the vulnerability
+  - Information on known exploits
 
-Please report bugs using the [GitHub issue
-tracker](https://github.com/cloud-hypervisor/cloud-hypervisor/issues) but for
-broader community discussions you may use our [mailing
-list](https://lists.cloudhypervisor.org/g/dev/).
+Vulnerability information is extremely sensitive. Please encrypt all security
+vulnerability reports using our *PGP key*
 
-## Security issues
+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*
 
-Please contact the maintainers listed in the MAINTAINERS.md file with security issues.
+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

@@ -0,0 +1,9 @@
+[package]
+name = "acpi_tables"
+version = "0.1.0"
+authors = ["The Cloud Hypervisor Authors"]
+edition = "2018"
+
+[dependencies]
+vm-memory = { git = "https://github.com/rust-vmm/vm-memory" }
+

acpi_tables/src/lib.rs

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

acpi_tables/src/rsdp.rs

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

acpi_tables/src/sdt.rs

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

api_client/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "api_client"
-version = "0.1.0"
-authors = ["The Cloud Hypervisor Authors"]
-edition = "2021"
-
-[dependencies]
-vmm-sys-util = "0.11.0"

api_client/src/lib.rs

@@ -1,249 +0,0 @@
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-use std::fmt;
-use std::io::{Read, Write};
-use std::os::unix::io::RawFd;
-use vmm_sys_util::sock_ctrl_msg::ScmSocket;
-
-#[derive(Debug)]
-pub enum Error {
-    Socket(std::io::Error),
-    SocketSendFds(vmm_sys_util::errno::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}"),
-            SocketSendFds(e) => write!(f, "Error writing to or reading from HTTP socket: {e}"),
-            StatusCodeParsing(e) => write!(f, "Error parsing HTTP status code: {e}"),
-            MissingProtocol => write!(f, "HTTP output is missing protocol statement"),
-            ContentLengthParsing(e) => write!(f, "Error parsing HTTP Content-Length field: {e}"),
-            ServerResponse(s, o) => {
-                if let Some(o) = o {
-                    write!(f, "Server responded with an error: {s:?}: {o}")
-                } else {
-                    write!(f, "Server responded with an error: {s:?}")
-                }
-            }
-        }
-    }
-}
-
-#[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)?;
-        // If the return value is 0, the peer has performed an orderly shutdown.
-        if count == 0 {
-            break;
-        }
-        res.push_str(std::str::from_utf8(&bytes[0..count]).unwrap());
-
-        // End of headers
-        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(body_offset.map(|o| String::from(&res[o..])));
-    let status_code = get_status_code(&res)?;
-
-    if status_code.is_server_error() {
-        Err(Error::ServerResponse(status_code, body_string))
-    } else {
-        Ok(body_string)
-    }
-}
-
-/// Make an API request using the fully qualified command name.
-/// For example, full_command could be "vm.create" or "vmm.ping".
-pub fn simple_api_full_command_with_fds_and_response<T: Read + Write + ScmSocket>(
-    socket: &mut T,
-    method: &str,
-    full_command: &str,
-    request_body: Option<&str>,
-    request_fds: Vec<RawFd>,
-) -> Result<Option<String>, Error> {
-    socket
-        .send_with_fds(
-            &[format!(
-                "{method} /api/v1/{full_command} HTTP/1.1\r\nHost: localhost\r\nAccept: */*\r\n"
-            )
-            .as_bytes()],
-            &request_fds,
-        )
-        .map_err(Error::SocketSendFds)?;
-
-    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)?;
-
-    parse_http_response(socket)
-}
-
-pub fn simple_api_full_command_with_fds<T: Read + Write + ScmSocket>(
-    socket: &mut T,
-    method: &str,
-    full_command: &str,
-    request_body: Option<&str>,
-    request_fds: Vec<RawFd>,
-) -> Result<(), Error> {
-    let response = simple_api_full_command_with_fds_and_response(
-        socket,
-        method,
-        full_command,
-        request_body,
-        request_fds,
-    )?;
-
-    if response.is_some() {
-        println!("{}", response.unwrap());
-    }
-
-    Ok(())
-}
-
-pub fn simple_api_full_command<T: Read + Write + ScmSocket>(
-    socket: &mut T,
-    method: &str,
-    full_command: &str,
-    request_body: Option<&str>,
-) -> Result<(), Error> {
-    simple_api_full_command_with_fds(socket, method, full_command, request_body, Vec::new())
-}
-
-pub fn simple_api_full_command_and_response<T: Read + Write + ScmSocket>(
-    socket: &mut T,
-    method: &str,
-    full_command: &str,
-    request_body: Option<&str>,
-) -> Result<Option<String>, Error> {
-    simple_api_full_command_with_fds_and_response(
-        socket,
-        method,
-        full_command,
-        request_body,
-        Vec::new(),
-    )
-}
-
-pub fn simple_api_command_with_fds<T: Read + Write + ScmSocket>(
-    socket: &mut T,
-    method: &str,
-    c: &str,
-    request_body: Option<&str>,
-    request_fds: Vec<RawFd>,
-) -> Result<(), Error> {
-    // Create the full VM command. For VMM commands, use
-    // simple_api_full_command().
-    let full_command = format!("vm.{c}");
-
-    simple_api_full_command_with_fds(socket, method, &full_command, request_body, request_fds)
-}
-
-pub fn simple_api_command<T: Read + Write + ScmSocket>(
-    socket: &mut T,
-    method: &str,
-    c: &str,
-    request_body: Option<&str>,
-) -> Result<(), Error> {
-    simple_api_command_with_fds(socket, method, c, request_body, Vec::new())
-}

arch/Cargo.toml

@@ -2,28 +2,26 @@
 name = "arch"
 version = "0.1.0"
 authors = ["The Chromium OS Authors"]
-edition = "2021"
 
 [features]
 default = []
-tdx = []
 
 [dependencies]
-anyhow = "1.0.70"
-byteorder = "1.4.3"
-hypervisor = { path = "../hypervisor" }
-libc = "0.2.139"
-linux-loader = { version = "0.8.1", features = ["elf", "bzimage", "pe"] }
-log = "0.4.17"
-serde = { version = "1.0.156", features = ["rc", "derive"] }
-thiserror = "1.0.39"
-uuid = "1.3.0"
-versionize = "0.1.10"
-versionize_derive = "0.1.4"
-vm-memory = { version = "0.10.0", features = ["backend-mmap", "backend-bitmap"] }
-vm-migration = { path = "../vm-migration" }
-vmm-sys-util = { version = "0.11.0", features = ["with-serde"] }
+byteorder = "1.3.4"
+kvm-bindings = "0.2.0"
+kvm-ioctls = "0.5.0"
+libc = "0.2.66"
 
-[target.'cfg(target_arch = "aarch64")'.dependencies]
-fdt_parser = { version = "0.1.4", package = "fdt" }
-vm-fdt = { git = "https://github.com/rust-vmm/vm-fdt", branch = "main" }
+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,871 +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 crate::{NumaNodes, PciSpaceInfo};
-use byteorder::{BigEndian, ByteOrder};
-use hypervisor::arch::aarch64::gic::Vgic;
-use std::cmp;
-use std::collections::HashMap;
-use std::ffi::CStr;
-use std::fmt::Debug;
-use std::result;
-use std::str;
-use std::sync::{Arc, Mutex};
-
-use super::super::DeviceType;
-use super::super::GuestMemoryMmap;
-use super::super::InitramfsConfig;
-use super::layout::{
-    IRQ_BASE, MEM_32BIT_DEVICES_SIZE, MEM_32BIT_DEVICES_START, MEM_PCI_IO_SIZE, MEM_PCI_IO_START,
-    PCI_HIGH_BASE, PCI_MMIO_CONFIG_SIZE_PER_SEGMENT,
-};
-use vm_fdt::{FdtWriter, FdtWriterResult};
-use vm_memory::{Address, Bytes, GuestMemory, GuestMemoryError, GuestMemoryRegion};
-
-// 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;
-// This is a value for virtio-iommu. Now only one virtio-iommu device is supported.
-const VIRTIO_IOMMU_PHANDLE: u32 = 5;
-// NOTE: Keep FIRST_VCPU_PHANDLE the last PHANDLE defined.
-// This is a value for uniquely identifying the FDT node containing the first vCPU.
-// The last number of vCPU phandle depends on the number of vCPUs.
-const FIRST_VCPU_PHANDLE: u32 = 6;
-
-// 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;
-
-// PMU PPI interrupt number
-pub const AARCH64_PMU_IRQ: u32 = 7;
-
-// Keys and Buttons
-// System Power Down
-const KEY_POWER: u32 = 116;
-
-/// 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 {
-    /// Failure in writing FDT in memory.
-    WriteFdtToMemory(GuestMemoryError),
-}
-type Result<T> = result::Result<T, Error>;
-
-/// Creates the flattened device tree for this aarch64 VM.
-#[allow(clippy::too_many_arguments)]
-pub fn create_fdt<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
-    guest_mem: &GuestMemoryMmap,
-    cmdline: &str,
-    vcpu_mpidr: Vec<u64>,
-    vcpu_topology: Option<(u8, u8, u8)>,
-    device_info: &HashMap<(DeviceType, String), T, S>,
-    gic_device: &Arc<Mutex<dyn Vgic>>,
-    initrd: &Option<InitramfsConfig>,
-    pci_space_info: &[PciSpaceInfo],
-    numa_nodes: &NumaNodes,
-    virtio_iommu_bdf: Option<u32>,
-    pmu_supported: bool,
-) -> FdtWriterResult<Vec<u8>> {
-    // Allocate stuff necessary for the holding the blob.
-    let mut fdt = FdtWriter::new().unwrap();
-
-    // For an explanation why these nodes were introduced in the blob take a look at
-    // https://github.com/torvalds/linux/blob/master/Documentation/devicetree/booting-without-of.txt#L845
-    // Look for "Required nodes and properties".
-
-    // Header or the root node as per above mentioned documentation.
-    let root_node = fdt.begin_node("")?;
-    fdt.property_string("compatible", "linux,dummy-virt")?;
-    // For info on #address-cells and size-cells read "Note about cells and address representation"
-    // from the above mentioned txt file.
-    fdt.property_u32("#address-cells", ADDRESS_CELLS)?;
-    fdt.property_u32("#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.
-    fdt.property_u32("interrupt-parent", GIC_PHANDLE)?;
-    create_cpu_nodes(&mut fdt, &vcpu_mpidr, vcpu_topology, numa_nodes)?;
-    create_memory_node(&mut fdt, guest_mem, numa_nodes)?;
-    create_chosen_node(&mut fdt, cmdline, initrd)?;
-    create_gic_node(&mut fdt, gic_device)?;
-    create_timer_node(&mut fdt)?;
-    if pmu_supported {
-        create_pmu_node(&mut fdt)?;
-    }
-    create_clock_node(&mut fdt)?;
-    create_psci_node(&mut fdt)?;
-    create_devices_node(&mut fdt, device_info)?;
-    create_pci_nodes(&mut fdt, pci_space_info, virtio_iommu_bdf)?;
-    if numa_nodes.len() > 1 {
-        create_distance_map_node(&mut fdt, numa_nodes)?;
-    }
-
-    // End Header node.
-    fdt.end_node(root_node)?;
-
-    let fdt_final = fdt.finish()?;
-
-    Ok(fdt_final)
-}
-
-pub fn write_fdt_to_memory(fdt_final: Vec<u8>, guest_mem: &GuestMemoryMmap) -> Result<()> {
-    // Write FDT to memory.
-    guest_mem
-        .write_slice(fdt_final.as_slice(), super::layout::FDT_START)
-        .map_err(Error::WriteFdtToMemory)?;
-    Ok(())
-}
-
-// Following are the auxiliary function for creating the different nodes that we append to our FDT.
-fn create_cpu_nodes(
-    fdt: &mut FdtWriter,
-    vcpu_mpidr: &[u64],
-    vcpu_topology: Option<(u8, u8, u8)>,
-    numa_nodes: &NumaNodes,
-) -> FdtWriterResult<()> {
-    // See https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/arm/cpus.yaml.
-    let cpus_node = fdt.begin_node("cpus")?;
-    fdt.property_u32("#address-cells", 0x1)?;
-    fdt.property_u32("#size-cells", 0x0)?;
-
-    let num_cpus = vcpu_mpidr.len();
-
-    for (cpu_id, mpidr) in vcpu_mpidr.iter().enumerate().take(num_cpus) {
-        let cpu_name = format!("cpu@{cpu_id:x}");
-        let cpu_node = fdt.begin_node(&cpu_name)?;
-        fdt.property_string("device_type", "cpu")?;
-        fdt.property_string("compatible", "arm,arm-v8")?;
-        if num_cpus > 1 {
-            // This is required on armv8 64-bit. See aforementioned documentation.
-            fdt.property_string("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.
-        fdt.property_u32("reg", (mpidr & 0x7FFFFF) as u32)?;
-        fdt.property_u32("phandle", cpu_id as u32 + FIRST_VCPU_PHANDLE)?;
-
-        // Add `numa-node-id` property if there is any numa config.
-        if numa_nodes.len() > 1 {
-            for numa_node_idx in 0..numa_nodes.len() {
-                let numa_node = numa_nodes.get(&(numa_node_idx as u32));
-                if numa_node.unwrap().cpus.contains(&(cpu_id as u8)) {
-                    fdt.property_u32("numa-node-id", numa_node_idx as u32)?;
-                }
-            }
-        }
-
-        fdt.end_node(cpu_node)?;
-    }
-
-    if let Some(topology) = vcpu_topology {
-        let (threads_per_core, cores_per_package, packages) = topology;
-        let cpu_map_node = fdt.begin_node("cpu-map")?;
-
-        // Create device tree nodes with regard of above mapping.
-        for package_idx in 0..packages {
-            let package_name = format!("socket{package_idx:x}");
-            let package_node = fdt.begin_node(&package_name)?;
-
-            // Cluster is the container of cores, and it is mandatory in the CPU topology.
-            // Add a default "cluster0" in each socket/package.
-            let cluster_node = fdt.begin_node("cluster0")?;
-
-            for core_idx in 0..cores_per_package {
-                let core_name = format!("core{core_idx:x}");
-                let core_node = fdt.begin_node(&core_name)?;
-
-                for thread_idx in 0..threads_per_core {
-                    let thread_name = format!("thread{thread_idx:x}");
-                    let thread_node = fdt.begin_node(&thread_name)?;
-                    let cpu_idx = threads_per_core * cores_per_package * package_idx
-                        + threads_per_core * core_idx
-                        + thread_idx;
-                    fdt.property_u32("cpu", cpu_idx as u32 + FIRST_VCPU_PHANDLE)?;
-                    fdt.end_node(thread_node)?;
-                }
-
-                fdt.end_node(core_node)?;
-            }
-            fdt.end_node(cluster_node)?;
-            fdt.end_node(package_node)?;
-        }
-        fdt.end_node(cpu_map_node)?;
-    } else {
-        debug!("Boot using device tree, CPU topology is not (correctly) specified");
-    }
-
-    fdt.end_node(cpus_node)?;
-
-    Ok(())
-}
-
-fn create_memory_node(
-    fdt: &mut FdtWriter,
-    guest_mem: &GuestMemoryMmap,
-    numa_nodes: &NumaNodes,
-) -> FdtWriterResult<()> {
-    // See https://github.com/torvalds/linux/blob/58ae0b51506802713aa0e9956d1853ba4c722c98/Documentation/devicetree/bindings/numa.txt
-    // for NUMA setting in memory node.
-    if numa_nodes.len() > 1 {
-        for numa_node_idx in 0..numa_nodes.len() {
-            let numa_node = numa_nodes.get(&(numa_node_idx as u32));
-            let mut mem_reg_prop: Vec<u64> = Vec::new();
-            let mut node_memory_addr: u64 = 0;
-            // Each memory zone of numa will have its own memory node, but
-            // different numa nodes should not share same memory zones.
-            for memory_region in numa_node.unwrap().memory_regions.iter() {
-                let memory_region_start_addr: u64 = memory_region.start_addr().raw_value();
-                let memory_region_size: u64 = memory_region.size() as u64;
-                mem_reg_prop.push(memory_region_start_addr);
-                mem_reg_prop.push(memory_region_size);
-                // Set the node address the first non-zero regison address
-                if node_memory_addr == 0 {
-                    node_memory_addr = memory_region_start_addr;
-                }
-            }
-            let memory_node_name = format!("memory@{node_memory_addr:x}");
-            let memory_node = fdt.begin_node(&memory_node_name)?;
-            fdt.property_string("device_type", "memory")?;
-            fdt.property_array_u64("reg", &mem_reg_prop)?;
-            fdt.property_u32("numa-node-id", numa_node_idx as u32)?;
-            fdt.end_node(memory_node)?;
-        }
-    } else {
-        // Note: memory regions from "GuestMemory" are sorted and non-zero sized.
-        let ram_regions = {
-            let mut ram_regions = Vec::new();
-            let mut current_start = guest_mem
-                .iter()
-                .next()
-                .map(GuestMemoryRegion::start_addr)
-                .expect("GuestMemory must have one memory region at least")
-                .raw_value();
-            let mut current_end = current_start;
-
-            for (start, size) in guest_mem
-                .iter()
-                .map(|m| (m.start_addr().raw_value(), m.len()))
-            {
-                if current_end == start {
-                    // This zone is continuous with the previous one.
-                    current_end += size;
-                } else {
-                    ram_regions.push((current_start, current_end));
-
-                    current_start = start;
-                    current_end = start + size;
-                }
-            }
-
-            ram_regions.push((current_start, current_end));
-
-            ram_regions
-        };
-
-        if ram_regions.len() > 2 {
-            panic!(
-                "There should be up to two non-continuous regions, devidided by the
-                    gap at the end of 32bit address space."
-            );
-        }
-
-        // Create the memory node for memory region before the gap
-        {
-            let (first_region_start, first_region_end) = ram_regions
-                .first()
-                .expect("There should be at last one memory region");
-            let ram_start = super::layout::RAM_START.raw_value();
-            let mem_32bit_reserved_start = super::layout::MEM_32BIT_RESERVED_START.raw_value();
-
-            if !((first_region_start <= &ram_start)
-                && (first_region_end > &ram_start)
-                && (first_region_end <= &mem_32bit_reserved_start))
-            {
-                panic!(
-                    "Unexpected first memory region layout: (start: 0x{:08x}, end: 0x{:08x}).
-                    ram_start: 0x{:08x}, mem_32bit_reserved_start: 0x{:08x}",
-                    first_region_start, first_region_end, ram_start, mem_32bit_reserved_start
-                );
-            }
-
-            let mem_size = first_region_end - ram_start;
-            let mem_reg_prop = [ram_start, mem_size];
-            let memory_node_name = format!("memory@{:x}", ram_start);
-            let memory_node = fdt.begin_node(&memory_node_name)?;
-            fdt.property_string("device_type", "memory")?;
-            fdt.property_array_u64("reg", &mem_reg_prop)?;
-            fdt.end_node(memory_node)?;
-        }
-
-        // Create the memory map entry for memory region after the gap if any
-        if let Some((second_region_start, second_region_end)) = ram_regions.get(1) {
-            let ram_64bit_start = super::layout::RAM_64BIT_START.raw_value();
-
-            if second_region_start != &ram_64bit_start {
-                panic!(
-                    "Unexpected second memory region layout: start: 0x{:08x}, ram_64bit_start: 0x{:08x}",
-                    second_region_start, ram_64bit_start
-                );
-            }
-
-            let mem_size = second_region_end - ram_64bit_start;
-            let mem_reg_prop = [ram_64bit_start, mem_size];
-            let memory_node_name = format!("memory@{:x}", ram_64bit_start);
-            let memory_node = fdt.begin_node(&memory_node_name)?;
-            fdt.property_string("device_type", "memory")?;
-            fdt.property_array_u64("reg", &mem_reg_prop)?;
-            fdt.end_node(memory_node)?;
-        }
-    }
-
-    Ok(())
-}
-
-fn create_chosen_node(
-    fdt: &mut FdtWriter,
-    cmdline: &str,
-    initrd: &Option<InitramfsConfig>,
-) -> FdtWriterResult<()> {
-    let chosen_node = fdt.begin_node("chosen")?;
-    fdt.property_string("bootargs", cmdline)?;
-
-    if let Some(initrd_config) = initrd {
-        let initrd_start = initrd_config.address.raw_value();
-        let initrd_end = initrd_config.address.raw_value() + initrd_config.size as u64;
-        fdt.property_u64("linux,initrd-start", initrd_start)?;
-        fdt.property_u64("linux,initrd-end", initrd_end)?;
-    }
-
-    fdt.end_node(chosen_node)?;
-
-    Ok(())
-}
-
-fn create_gic_node(fdt: &mut FdtWriter, gic_device: &Arc<Mutex<dyn Vgic>>) -> FdtWriterResult<()> {
-    let gic_reg_prop = gic_device.lock().unwrap().device_properties();
-
-    let intc_node = fdt.begin_node("intc")?;
-
-    fdt.property_string("compatible", gic_device.lock().unwrap().fdt_compatibility())?;
-    fdt.property_null("interrupt-controller")?;
-    // "interrupt-cells" field specifies the number of cells needed to encode an
-    // interrupt source. The type shall be a <u32> and the value shall be 3 if no PPI affinity description
-    // is required.
-    fdt.property_u32("#interrupt-cells", 3)?;
-    fdt.property_array_u64("reg", &gic_reg_prop)?;
-    fdt.property_u32("phandle", GIC_PHANDLE)?;
-    fdt.property_u32("#address-cells", 2)?;
-    fdt.property_u32("#size-cells", 2)?;
-    fdt.property_null("ranges")?;
-
-    let gic_intr_prop = [
-        GIC_FDT_IRQ_TYPE_PPI,
-        gic_device.lock().unwrap().fdt_maint_irq(),
-        IRQ_TYPE_LEVEL_HI,
-    ];
-    fdt.property_array_u32("interrupts", &gic_intr_prop)?;
-
-    if gic_device.lock().unwrap().msi_compatible() {
-        let msic_node = fdt.begin_node("msic")?;
-        fdt.property_string("compatible", gic_device.lock().unwrap().msi_compatibility())?;
-        fdt.property_null("msi-controller")?;
-        fdt.property_u32("phandle", MSI_PHANDLE)?;
-        let msi_reg_prop = gic_device.lock().unwrap().msi_properties();
-        fdt.property_array_u64("reg", &msi_reg_prop)?;
-        fdt.end_node(msic_node)?;
-    }
-
-    fdt.end_node(intc_node)?;
-
-    Ok(())
-}
-
-fn create_clock_node(fdt: &mut FdtWriter) -> FdtWriterResult<()> {
-    // 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.
-    let clock_node = fdt.begin_node("apb-pclk")?;
-    fdt.property_string("compatible", "fixed-clock")?;
-    fdt.property_u32("#clock-cells", 0x0)?;
-    fdt.property_u32("clock-frequency", 24000000)?;
-    fdt.property_string("clock-output-names", "clk24mhz")?;
-    fdt.property_u32("phandle", CLOCK_PHANDLE)?;
-    fdt.end_node(clock_node)?;
-
-    Ok(())
-}
-
-fn create_timer_node(fdt: &mut FdtWriter) -> FdtWriterResult<()> {
-    // 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_node = fdt.begin_node("timer")?;
-    fdt.property_string("compatible", compatible)?;
-    fdt.property_null("always-on")?;
-    fdt.property_array_u32("interrupts", &timer_reg_cells)?;
-    fdt.end_node(timer_node)?;
-
-    Ok(())
-}
-
-fn create_psci_node(fdt: &mut FdtWriter) -> FdtWriterResult<()> {
-    let compatible = "arm,psci-0.2";
-    let psci_node = fdt.begin_node("psci")?;
-    fdt.property_string("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.
-    fdt.property_string("method", "hvc")?;
-    fdt.end_node(psci_node)?;
-
-    Ok(())
-}
-
-fn create_virtio_node<T: DeviceInfoForFdt + Clone + Debug>(
-    fdt: &mut FdtWriter,
-    dev_info: &T,
-) -> FdtWriterResult<()> {
-    let device_reg_prop = [dev_info.addr(), dev_info.length()];
-    let irq = [GIC_FDT_IRQ_TYPE_SPI, dev_info.irq(), IRQ_TYPE_EDGE_RISING];
-
-    let virtio_node = fdt.begin_node(&format!("virtio_mmio@{:x}", dev_info.addr()))?;
-    fdt.property_string("compatible", "virtio,mmio")?;
-    fdt.property_array_u64("reg", &device_reg_prop)?;
-    fdt.property_array_u32("interrupts", &irq)?;
-    fdt.property_u32("interrupt-parent", GIC_PHANDLE)?;
-    fdt.end_node(virtio_node)?;
-
-    Ok(())
-}
-
-fn create_serial_node<T: DeviceInfoForFdt + Clone + Debug>(
-    fdt: &mut FdtWriter,
-    dev_info: &T,
-) -> FdtWriterResult<()> {
-    let compatible = b"arm,pl011\0arm,primecell\0";
-    let serial_reg_prop = [dev_info.addr(), dev_info.length()];
-    let irq = [
-        GIC_FDT_IRQ_TYPE_SPI,
-        dev_info.irq() - IRQ_BASE,
-        IRQ_TYPE_EDGE_RISING,
-    ];
-
-    let serial_node = fdt.begin_node(&format!("pl011@{:x}", dev_info.addr()))?;
-    fdt.property("compatible", compatible)?;
-    fdt.property_array_u64("reg", &serial_reg_prop)?;
-    fdt.property_u32("clocks", CLOCK_PHANDLE)?;
-    fdt.property_string("clock-names", "apb_pclk")?;
-    fdt.property_array_u32("interrupts", &irq)?;
-    fdt.end_node(serial_node)?;
-
-    Ok(())
-}
-
-fn create_rtc_node<T: DeviceInfoForFdt + Clone + Debug>(
-    fdt: &mut FdtWriter,
-    dev_info: &T,
-) -> FdtWriterResult<()> {
-    let compatible = b"arm,pl031\0arm,primecell\0";
-    let rtc_reg_prop = [dev_info.addr(), dev_info.length()];
-    let irq = [
-        GIC_FDT_IRQ_TYPE_SPI,
-        dev_info.irq() - IRQ_BASE,
-        IRQ_TYPE_LEVEL_HI,
-    ];
-
-    let rtc_node = fdt.begin_node(&format!("rtc@{:x}", dev_info.addr()))?;
-    fdt.property("compatible", compatible)?;
-    fdt.property_array_u64("reg", &rtc_reg_prop)?;
-    fdt.property_array_u32("interrupts", &irq)?;
-    fdt.property_u32("clocks", CLOCK_PHANDLE)?;
-    fdt.property_string("clock-names", "apb_pclk")?;
-    fdt.end_node(rtc_node)?;
-
-    Ok(())
-}
-
-fn create_gpio_node<T: DeviceInfoForFdt + Clone + Debug>(
-    fdt: &mut FdtWriter,
-    dev_info: &T,
-) -> FdtWriterResult<()> {
-    // PL061 GPIO controller node
-    let compatible = b"arm,pl061\0arm,primecell\0";
-    let gpio_reg_prop = [dev_info.addr(), dev_info.length()];
-    let irq = [
-        GIC_FDT_IRQ_TYPE_SPI,
-        dev_info.irq() - IRQ_BASE,
-        IRQ_TYPE_EDGE_RISING,
-    ];
-
-    let gpio_node = fdt.begin_node(&format!("pl061@{:x}", dev_info.addr()))?;
-    fdt.property("compatible", compatible)?;
-    fdt.property_array_u64("reg", &gpio_reg_prop)?;
-    fdt.property_array_u32("interrupts", &irq)?;
-    fdt.property_null("gpio-controller")?;
-    fdt.property_u32("#gpio-cells", 2)?;
-    fdt.property_u32("clocks", CLOCK_PHANDLE)?;
-    fdt.property_string("clock-names", "apb_pclk")?;
-    fdt.property_u32("phandle", GPIO_PHANDLE)?;
-    fdt.end_node(gpio_node)?;
-
-    // gpio-keys node
-    let gpio_keys_node = fdt.begin_node("gpio-keys")?;
-    fdt.property_string("compatible", "gpio-keys")?;
-    fdt.property_u32("#size-cells", 0)?;
-    fdt.property_u32("#address-cells", 1)?;
-    let gpio_keys_poweroff_node = fdt.begin_node("button@1")?;
-    fdt.property_string("label", "GPIO Key Poweroff")?;
-    fdt.property_u32("linux,code", KEY_POWER)?;
-    let gpios = [GPIO_PHANDLE, 3, 0];
-    fdt.property_array_u32("gpios", &gpios)?;
-    fdt.end_node(gpio_keys_poweroff_node)?;
-    fdt.end_node(gpio_keys_node)?;
-
-    Ok(())
-}
-
-fn create_devices_node<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
-    fdt: &mut FdtWriter,
-    dev_info: &HashMap<(DeviceType, String), T, S>,
-) -> FdtWriterResult<()> {
-    // 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_pmu_node(fdt: &mut FdtWriter) -> FdtWriterResult<()> {
-    let compatible = "arm,armv8-pmuv3";
-    let irq = [GIC_FDT_IRQ_TYPE_PPI, AARCH64_PMU_IRQ, IRQ_TYPE_LEVEL_HI];
-
-    let pmu_node = fdt.begin_node("pmu")?;
-    fdt.property_string("compatible", compatible)?;
-    fdt.property_array_u32("interrupts", &irq)?;
-    fdt.end_node(pmu_node)?;
-    Ok(())
-}
-
-fn create_pci_nodes(
-    fdt: &mut FdtWriter,
-    pci_device_info: &[PciSpaceInfo],
-    virtio_iommu_bdf: Option<u32>,
-) -> FdtWriterResult<()> {
-    // Add node for PCIe controller.
-    // See Documentation/devicetree/bindings/pci/host-generic-pci.txt in the kernel
-    // and https://elinux.org/Device_Tree_Usage.
-    // In multiple PCI segments setup, each PCI segment needs a PCI node.
-    for pci_device_info_elem in pci_device_info.iter() {
-        // EDK2 requires the PCIe high space above 4G address.
-        // The actual space in CLH follows the RAM. If the RAM space is small, the PCIe high space
-        // could fall bellow 4G.
-        // Here we cut off PCI device space below 8G in FDT to workaround the EDK2 check.
-        // But the address written in ACPI is not impacted.
-        let (pci_device_base_64bit, pci_device_size_64bit) =
-            if pci_device_info_elem.pci_device_space_start < PCI_HIGH_BASE.raw_value() {
-                (
-                    PCI_HIGH_BASE.raw_value(),
-                    pci_device_info_elem.pci_device_space_size
-                        - (PCI_HIGH_BASE.raw_value() - pci_device_info_elem.pci_device_space_start),
-                )
-            } else {
-                (
-                    pci_device_info_elem.pci_device_space_start,
-                    pci_device_info_elem.pci_device_space_size,
-                )
-            };
-        // There is no specific requirement of the 32bit MMIO range, and
-        // therefore at least we can make these ranges 4K aligned.
-        let pci_device_size_32bit: u64 =
-            MEM_32BIT_DEVICES_SIZE / ((1 << 12) * pci_device_info.len() as u64) * (1 << 12);
-        let pci_device_base_32bit: u64 = MEM_32BIT_DEVICES_START.0
-            + pci_device_size_32bit * pci_device_info_elem.pci_segment_id as u64;
-
-        let ranges = [
-            // io addresses. Since AArch64 will not use IO address,
-            // we can set the same IO address range for every segment.
-            0x1000000,
-            0_u32,
-            0_u32,
-            (MEM_PCI_IO_START.0 >> 32) as u32,
-            MEM_PCI_IO_START.0 as u32,
-            (MEM_PCI_IO_SIZE >> 32) as u32,
-            MEM_PCI_IO_SIZE as u32,
-            // mmio addresses
-            0x2000000,                            // (ss = 10: 32-bit memory space)
-            (pci_device_base_32bit >> 32) as u32, // PCI address
-            pci_device_base_32bit as u32,
-            (pci_device_base_32bit >> 32) as u32, // CPU address
-            pci_device_base_32bit as u32,
-            (pci_device_size_32bit >> 32) as u32, // size
-            pci_device_size_32bit as u32,
-            // device addresses
-            0x3000000,                            // (ss = 11: 64-bit memory space)
-            (pci_device_base_64bit >> 32) as u32, // PCI address
-            pci_device_base_64bit as u32,
-            (pci_device_base_64bit >> 32) as u32, // CPU address
-            pci_device_base_64bit as u32,
-            (pci_device_size_64bit >> 32) as u32, // size
-            pci_device_size_64bit as u32,
-        ];
-        let bus_range = [0, 0]; // Only bus 0
-        let reg = [
-            pci_device_info_elem.mmio_config_address,
-            PCI_MMIO_CONFIG_SIZE_PER_SEGMENT,
-        ];
-        // See kernel document Documentation/devicetree/bindings/pci/pci-msi.txt
-        let msi_map = [
-            // rid-base: A single cell describing the first RID matched by the entry.
-            0x0,
-            // msi-controller: A single phandle to an MSI controller.
-            MSI_PHANDLE,
-            // msi-base: An msi-specifier describing the msi-specifier produced for the
-            // first RID matched by the entry.
-            (pci_device_info_elem.pci_segment_id as u32) << 8,
-            // length: A single cell describing how many consecutive RIDs are matched
-            // following the rid-base.
-            0x100,
-        ];
-
-        let pci_node_name = format!("pci@{:x}", pci_device_info_elem.mmio_config_address);
-        let pci_node = fdt.begin_node(&pci_node_name)?;
-
-        fdt.property_string("compatible", "pci-host-ecam-generic")?;
-        fdt.property_string("device_type", "pci")?;
-        fdt.property_array_u32("ranges", &ranges)?;
-        fdt.property_array_u32("bus-range", &bus_range)?;
-        fdt.property_u32(
-            "linux,pci-domain",
-            pci_device_info_elem.pci_segment_id as u32,
-        )?;
-        fdt.property_u32("#address-cells", 3)?;
-        fdt.property_u32("#size-cells", 2)?;
-        fdt.property_array_u64("reg", &reg)?;
-        fdt.property_u32("#interrupt-cells", 1)?;
-        fdt.property_null("interrupt-map")?;
-        fdt.property_null("interrupt-map-mask")?;
-        fdt.property_null("dma-coherent")?;
-        fdt.property_array_u32("msi-map", &msi_map)?;
-        fdt.property_u32("msi-parent", MSI_PHANDLE)?;
-
-        if pci_device_info_elem.pci_segment_id == 0 {
-            if let Some(virtio_iommu_bdf) = virtio_iommu_bdf {
-                // See kernel document Documentation/devicetree/bindings/pci/pci-iommu.txt
-                // for 'iommu-map' attribute setting.
-                let iommu_map = [
-                    0_u32,
-                    VIRTIO_IOMMU_PHANDLE,
-                    0_u32,
-                    virtio_iommu_bdf,
-                    virtio_iommu_bdf + 1,
-                    VIRTIO_IOMMU_PHANDLE,
-                    virtio_iommu_bdf + 1,
-                    0xffff - virtio_iommu_bdf,
-                ];
-                fdt.property_array_u32("iommu-map", &iommu_map)?;
-
-                // See kernel document Documentation/devicetree/bindings/virtio/iommu.txt
-                // for virtio-iommu node settings.
-                let virtio_iommu_node_name = format!("virtio_iommu@{virtio_iommu_bdf:x}");
-                let virtio_iommu_node = fdt.begin_node(&virtio_iommu_node_name)?;
-                fdt.property_u32("#iommu-cells", 1)?;
-                fdt.property_string("compatible", "virtio,pci-iommu")?;
-
-                // 'reg' is a five-cell address encoded as
-                // (phys.hi phys.mid phys.lo size.hi size.lo). phys.hi should contain the
-                // device's BDF as 0b00000000 bbbbbbbb dddddfff 00000000. The other cells
-                // should be zero.
-                let reg = [virtio_iommu_bdf << 8, 0_u32, 0_u32, 0_u32, 0_u32];
-                fdt.property_array_u32("reg", &reg)?;
-                fdt.property_u32("phandle", VIRTIO_IOMMU_PHANDLE)?;
-
-                fdt.end_node(virtio_iommu_node)?;
-            }
-        }
-
-        fdt.end_node(pci_node)?;
-    }
-
-    Ok(())
-}
-
-fn create_distance_map_node(fdt: &mut FdtWriter, numa_nodes: &NumaNodes) -> FdtWriterResult<()> {
-    let distance_map_node = fdt.begin_node("distance-map")?;
-    fdt.property_string("compatible", "numa-distance-map-v1")?;
-    // Construct the distance matrix.
-    // 1. We use the word entry to describe a distance from a node to
-    // its destination, e.g. 0 -> 1 = 20 is described as <0 1 20>.
-    // 2. Each entry represents distance from first node to second node.
-    // The distances are equal in either direction.
-    // 3. The distance from a node to self (local distance) is represented
-    // with value 10 and all internode distance should be represented with
-    // a value greater than 10.
-    // 4. distance-matrix should have entries in lexicographical ascending
-    // order of nodes.
-    let mut distance_matrix = Vec::new();
-    for numa_node_idx in 0..numa_nodes.len() {
-        let numa_node = numa_nodes.get(&(numa_node_idx as u32));
-        for dest_numa_node in 0..numa_node.unwrap().distances.len() + 1 {
-            if numa_node_idx == dest_numa_node {
-                distance_matrix.push(numa_node_idx as u32);
-                distance_matrix.push(dest_numa_node as u32);
-                distance_matrix.push(10_u32);
-                continue;
-            }
-
-            distance_matrix.push(numa_node_idx as u32);
-            distance_matrix.push(dest_numa_node as u32);
-            distance_matrix.push(
-                *numa_node
-                    .unwrap()
-                    .distances
-                    .get(&(dest_numa_node as u32))
-                    .unwrap() as u32,
-            );
-        }
-    }
-    fdt.property_array_u32("distance-matrix", distance_matrix.as_ref())?;
-    fdt.end_node(distance_map_node)?;
-
-    Ok(())
-}
-
-// Parse the DTB binary and print for debugging
-pub fn print_fdt(dtb: &[u8]) {
-    match fdt_parser::Fdt::new(dtb) {
-        Ok(fdt) => {
-            if let Some(root) = fdt.find_node("/") {
-                debug!("Printing the FDT:");
-                print_node(root, 0);
-            } else {
-                debug!("Failed to find root node in FDT for debugging.");
-            }
-        }
-        Err(_) => debug!("Failed to parse FDT for debugging."),
-    }
-}
-
-fn print_node(node: fdt_parser::node::FdtNode<'_, '_>, n_spaces: usize) {
-    debug!("{:indent$}{}/", "", node.name, indent = n_spaces);
-    for property in node.properties() {
-        let name = property.name;
-
-        // If the property is 'compatible', its value requires special handling.
-        // The u8 array could contain multiple null-terminated strings.
-        // We copy the original array and simply replace all 'null' characters with spaces.
-        let value = if name == "compatible" {
-            let mut compatible = vec![0u8; 256];
-            let handled_value = property
-                .value
-                .iter()
-                .map(|&c| if c == 0 { b' ' } else { c })
-                .collect::<Vec<_>>();
-            let len = cmp::min(255, handled_value.len());
-            compatible[..len].copy_from_slice(&handled_value[..len]);
-            compatible[..(len + 1)].to_vec()
-        } else {
-            property.value.to_vec()
-        };
-        let value = &value;
-
-        // Now the value can be either:
-        //   - A null-terminated C string, or
-        //   - Binary data
-        // We follow a very simple logic to present the value:
-        //   - At first, try to convert it to CStr and print,
-        //   - If failed, print it as u32 array.
-        let value_result = match CStr::from_bytes_with_nul(value) {
-            Ok(value_cstr) => match value_cstr.to_str() {
-                Ok(value_str) => Some(value_str),
-                Err(_e) => None,
-            },
-            Err(_e) => None,
-        };
-
-        if let Some(value_str) = value_result {
-            debug!(
-                "{:indent$}{} : {:#?}",
-                "",
-                name,
-                value_str,
-                indent = (n_spaces + 2)
-            );
-        } else {
-            let mut array = Vec::with_capacity(256);
-            array.resize(value.len() / 4, 0u32);
-            BigEndian::read_u32_into(value, &mut array);
-            debug!(
-                "{:indent$}{} : {:X?}",
-                "",
-                name,
-                array,
-                indent = (n_spaces + 2)
-            );
-        };
-    }
-
-    // Print children nodes if there is any
-    for child in node.children() {
-        print_node(child, n_spaces + 2);
-    }
-}

arch/src/aarch64/layout.rs

@@ -1,139 +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                               |
-//           |                                                               |
-//           |                                                               |
-// 4GB       +---------------------------------------------------------------+
-//           |                      32-bit devices hole                      |
-// 4GB-64M   +---------------------------------------------------------------+
-//           |                                                               |
-//           |                                                               |
-//           |                            DRAM                               |
-//           |                                                               |
-//           |                                                               |
-// 1GB       +---------------------------------------------------------------+
-//           |                                                               |
-//           |                        PCI MMCONFIG space                     |
-//           |                                                               |
-// 768 M     +---------------------------------------------------------------+
-//           |                                                               |
-//           |                                                               |
-//           |                           PCI MMIO space                      |
-//           |                                                               |
-// 256 M     +---------------------------------------------------------------|
-//           |                                                               |
-//           |                        Legacy devices space                   |
-//           |                                                               |
-// 144 M     +---------------------------------------------------------------|
-//           |                                                               |
-//           |                    Reserved (now GIC is here)                 |
-//           |                                                               |
-//  4  M     +---------------------------------------------------------------+
-//           |                          UEFI flash                           |
-// 0GB       +---------------------------------------------------------------+
-//
-//
-
-use vm_memory::GuestAddress;
-
-/// 0x0 ~ 0x40_0000 (4 MiB) is reserved to UEFI
-/// UEFI binary size is required less than 3 MiB, reserving 4 MiB is enough.
-pub const UEFI_START: GuestAddress = GuestAddress(0);
-pub const UEFI_SIZE: u64 = 0x040_0000;
-
-/// Below this address will reside the GIC, above this address will reside the MMIO devices.
-const MAPPED_IO_START: GuestAddress = GuestAddress(0x0900_0000);
-
-/// See kernel file arch/arm64/include/uapi/asm/kvm.h for the GIC related definitions.
-/// 0x08ff_0000 ~ 0x0900_0000 is reserved for GICv3 Distributor
-pub const GIC_V3_DIST_SIZE: u64 = 0x01_0000;
-pub const GIC_V3_DIST_START: GuestAddress = GuestAddress(MAPPED_IO_START.0 - GIC_V3_DIST_SIZE);
-/// Below 0x08ff_0000 is reserved for GICv3 Redistributor.
-/// The size defined here is for each vcpu.
-/// The total size is 'number_of_vcpu * GIC_V3_REDIST_SIZE'
-pub const GIC_V3_REDIST_SIZE: u64 = 0x02_0000;
-/// Below Redistributor area is GICv3 ITS
-pub const GIC_V3_ITS_SIZE: u64 = 0x02_0000;
-
-/// Space 0x0900_0000 ~ 0x0905_0000 is reserved for legacy devices.
-pub const LEGACY_SERIAL_MAPPED_IO_START: GuestAddress = MAPPED_IO_START;
-pub const LEGACY_RTC_MAPPED_IO_START: GuestAddress = GuestAddress(0x0901_0000);
-pub const LEGACY_GPIO_MAPPED_IO_START: GuestAddress = GuestAddress(0x0902_0000);
-
-/// Space 0x0905_0000 ~ 0x0906_0000 is reserved for pcie io address
-pub const MEM_PCI_IO_START: GuestAddress = GuestAddress(0x0905_0000);
-pub const MEM_PCI_IO_SIZE: u64 = 0x10000;
-
-/// 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;
-// One bus with potentially 256 devices (32 slots x 8 functions).
-pub const PCI_MMIO_CONFIG_SIZE_PER_SEGMENT: u64 = 4096 * 256;
-
-/// Start of RAM.
-pub const RAM_START: GuestAddress = GuestAddress(0x4000_0000);
-
-/// 32-bit reserved area: 64MiB before 4GiB
-pub const MEM_32BIT_RESERVED_START: GuestAddress = GuestAddress(0xfc00_0000);
-pub const MEM_32BIT_RESERVED_SIZE: u64 = 0x0400_0000;
-
-/// TPM Address Range
-/// This Address range is specific to CRB Interface
-pub const TPM_START: GuestAddress = GuestAddress(0xfed4_0000);
-pub const TPM_SIZE: u64 = 0x1000;
-
-/// Start of 64-bit RAM.
-pub const RAM_64BIT_START: GuestAddress = GuestAddress(0x1_0000_0000);
-
-/// Kernel command line maximum size.
-/// As per `arch/arm64/include/uapi/asm/setup.h`.
-pub const CMDLINE_MAX_SIZE: usize = 2048;
-
-/// FDT is at the beginning of RAM.
-/// Maximum size of the device tree blob as specified in https://www.kernel.org/doc/Documentation/arm64/booting.txt.
-pub const FDT_START: GuestAddress = RAM_START;
-pub const FDT_MAX_SIZE: u64 = 0x20_0000;
-
-/// Put ACPI table above dtb
-pub const ACPI_START: GuestAddress = GuestAddress(RAM_START.0 + FDT_MAX_SIZE);
-pub const ACPI_MAX_SIZE: u64 = 0x20_0000;
-pub const RSDP_POINTER: GuestAddress = ACPI_START;
-
-/// Kernel start after FDT and ACPI
-pub const KERNEL_START: GuestAddress = GuestAddress(ACPI_START.0 + ACPI_MAX_SIZE);
-
-/// Pci high memory base
-pub const PCI_HIGH_BASE: GuestAddress = GuestAddress(0x2_0000_0000);
-
-// As per virt/kvm/arm/vgic/vgic-kvm-device.c we need
-// the number of interrupts our GIC will support to be:
-// * 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 = 32;
-
-/// Number of supported interrupts
-pub const IRQ_NUM: u32 = 256;
+/// 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,210 +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;
-/// Layout for this aarch64 system.
 pub mod layout;
-/// Module for system registers definition
-pub mod regs;
-/// Module for loading UEFI binary.
-pub mod uefi;
 
-pub use self::fdt::DeviceInfoForFdt;
-use crate::{DeviceType, GuestMemoryMmap, NumaNodes, PciSpaceInfo, RegionType};
-use hypervisor::arch::aarch64::gic::Vgic;
-use log::{log_enabled, Level};
-use std::collections::HashMap;
-use std::convert::TryInto;
-use std::fmt::Debug;
-use std::sync::{Arc, Mutex};
-use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic};
+use memory_model::{GuestAddress, GuestMemory};
 
-pub const _NSIG: i32 = 65;
-
-/// Errors thrown while configuring aarch64 system.
-#[derive(Debug)]
-pub enum Error {
-    /// Failed to create a FDT.
-    SetupFdt,
-
-    /// Failed to write FDT to memory.
-    WriteFdtToMemory(fdt::Error),
-
-    /// Failed to create a GIC.
-    SetupGic,
-
-    /// Failed to compute the initramfs address.
-    InitramfsAddress,
-
-    /// Error configuring the general purpose registers
-    RegsConfiguration(hypervisor::HypervisorCpuError),
-
-    /// Error configuring the MPIDR register
-    VcpuRegMpidr(hypervisor::HypervisorCpuError),
-
-    /// Error initializing PMU for vcpu
-    VcpuInitPmu,
+/// 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::PlatformSpecific(e)
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-/// Specifies the entry point address where the guest must start
-/// executing code.
-pub struct EntryPoint {
-    /// Address in guest memory where the guest must start execution
-    pub entry_addr: GuestAddress,
-}
-
-/// Configure the specified VCPU, and return its MPIDR.
-pub fn configure_vcpu(
-    vcpu: &Arc<dyn hypervisor::Vcpu>,
-    id: u8,
-    boot_setup: Option<(EntryPoint, &GuestMemoryAtomic<GuestMemoryMmap>)>,
-) -> super::Result<u64> {
-    if let Some((kernel_entry_point, _guest_memory)) = boot_setup {
-        vcpu.setup_regs(
-            id,
-            kernel_entry_point.entry_addr.raw_value(),
-            super::layout::FDT_START.raw_value(),
-        )
-        .map_err(Error::RegsConfiguration)?;
-    }
-
-    let mpidr = vcpu
-        .get_sys_reg(regs::MPIDR_EL1)
-        .map_err(Error::VcpuRegMpidr)?;
-    Ok(mpidr)
-}
-
-pub fn arch_memory_regions() -> Vec<(GuestAddress, usize, RegionType)> {
-    vec![
-        // 0 MiB ~ 256 MiB: UEFI, GIC and legacy devices
-        (
-            GuestAddress(0),
-            layout::MEM_32BIT_DEVICES_START.0 as usize,
-            RegionType::Reserved,
-        ),
-        // 256 MiB ~ 768 MiB: MMIO space
-        (
-            layout::MEM_32BIT_DEVICES_START,
-            layout::MEM_32BIT_DEVICES_SIZE as usize,
-            RegionType::SubRegion,
-        ),
-        // 768 MiB ~ 1 GiB: reserved. The leading 256M for PCIe MMCONFIG space
-        (
-            layout::PCI_MMCONFIG_START,
-            layout::PCI_MMCONFIG_SIZE as usize,
-            RegionType::Reserved,
-        ),
-        // 1GiB ~ 4032 MiB: RAM before the gap
-        (
-            layout::RAM_START,
-            layout::MEM_32BIT_RESERVED_START.unchecked_offset_from(layout::RAM_START) as usize,
-            RegionType::Ram,
-        ),
-        // 4GiB ~ inf: RAM after the gap
-        (layout::RAM_64BIT_START, usize::MAX, RegionType::Ram),
-        // Add the 32-bit reserved memory hole as a reserved region
-        (
-            layout::MEM_32BIT_RESERVED_START,
-            layout::MEM_32BIT_RESERVED_SIZE as usize,
-            RegionType::Reserved,
-        ),
-    ]
-}
-
-/// Configures the system and should be called once per vm before starting vcpu threads.
-#[allow(clippy::too_many_arguments)]
-pub fn configure_system<T: DeviceInfoForFdt + Clone + Debug, S: ::std::hash::BuildHasher>(
-    guest_mem: &GuestMemoryMmap,
-    cmdline: &str,
-    vcpu_mpidr: Vec<u64>,
-    vcpu_topology: Option<(u8, u8, u8)>,
-    device_info: &HashMap<(DeviceType, String), T, S>,
-    initrd: &Option<super::InitramfsConfig>,
-    pci_space_info: &[PciSpaceInfo],
-    virtio_iommu_bdf: Option<u32>,
-    gic_device: &Arc<Mutex<dyn Vgic>>,
-    numa_nodes: &NumaNodes,
-    pmu_supported: bool,
+/// 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<()> {
-    let fdt_final = fdt::create_fdt(
-        guest_mem,
-        cmdline,
-        vcpu_mpidr,
-        vcpu_topology,
-        device_info,
-        gic_device,
-        initrd,
-        pci_space_info,
-        numa_nodes,
-        virtio_iommu_bdf,
-        pmu_supported,
-    )
-    .map_err(|_| Error::SetupFdt)?;
-
-    if log_enabled!(Level::Debug) {
-        fdt::print_fdt(&fdt_final);
-    }
-
-    fdt::write_fdt_to_memory(fdt_final, guest_mem).map_err(Error::WriteFdtToMemory)?;
-
     Ok(())
 }
 
-/// Returns the memory address where the initramfs could be loaded.
-pub fn initramfs_load_addr(
-    guest_mem: &GuestMemoryMmap,
-    initramfs_size: usize,
-) -> super::Result<u64> {
-    let round_to_pagesize = |size| (size + (super::PAGE_SIZE - 1)) & !(super::PAGE_SIZE - 1);
-    match guest_mem
-        .last_addr()
-        .checked_sub(round_to_pagesize(initramfs_size) as u64 - 1)
-    {
-        Some(offset) => {
-            if guest_mem.address_in_range(offset) {
-                Ok(offset.raw_value())
-            } else {
-                Err(super::Error::PlatformSpecific(Error::InitramfsAddress))
-            }
-        }
-        None => Err(super::Error::PlatformSpecific(Error::InitramfsAddress)),
-    }
-}
-
-pub fn get_host_cpu_phys_bits() -> u8 {
-    // A dummy hypervisor created only for querying the host IPA size and will
-    // be freed after the query.
-    let hv = hypervisor::new().unwrap();
-    let host_cpu_phys_bits = hv.get_host_ipa_limit().try_into().unwrap();
-    if host_cpu_phys_bits == 0 {
-        // Host kernel does not support `get_host_ipa_limit`,
-        // we return the default value 40 here.
-        40
-    } else {
-        host_cpu_phys_bits
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_arch_memory_regions_dram() {
-        let regions = arch_memory_regions();
-        assert_eq!(6, regions.len());
-        assert_eq!(layout::RAM_START, regions[3].0);
-        assert_eq!(RegionType::Ram, regions[3].2);
-        assert_eq!(RegionType::Reserved, regions[5].2);
-        assert_eq!(RegionType::Ram, regions[4].2);
-    }
+/// 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,43 +0,0 @@
-// Copyright 2022 Arm Limited (or its affiliates). All rights reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// AArch64 system register encoding:
-// See https://developer.arm.com/documentation/ddi0487 (chapter D12)
-//
-//   31      22  21 20 19 18 16 15 12 11  8 7   5 4  0
-//  +----------+---+-----+-----+-----+-----+-----+----+
-//  |1101010100| L | op0 | op1 | CRn | CRm | op2 | Rt |
-//  +----------+---+-----+-----+-----+-----+-----+----+
-//
-// Notes:
-// - L and Rt are reserved as implementation defined fields, ignored.
-
-const SYSREG_HEAD: u32 = 0b1101010100u32 << 22;
-const SYSREG_OP0_SHIFT: u32 = 19;
-const SYSREG_OP0_MASK: u32 = 0b11u32 << 19;
-const SYSREG_OP1_SHIFT: u32 = 16;
-const SYSREG_OP1_MASK: u32 = 0b111u32 << 16;
-const SYSREG_CRN_SHIFT: u32 = 12;
-const SYSREG_CRN_MASK: u32 = 0b1111u32 << 12;
-const SYSREG_CRM_SHIFT: u32 = 8;
-const SYSREG_CRM_MASK: u32 = 0b1111u32 << 8;
-const SYSREG_OP2_SHIFT: u32 = 5;
-const SYSREG_OP2_MASK: u32 = 0b111u32 << 5;
-
-/// Define the ID of system registers
-#[macro_export]
-macro_rules! arm64_sys_reg {
-    ($name: tt, $op0: tt, $op1: tt, $crn: tt, $crm: tt, $op2: tt) => {
-        pub const $name: u32 = SYSREG_HEAD
-            | ((($op0 as u32) << SYSREG_OP0_SHIFT) & SYSREG_OP0_MASK as u32)
-            | ((($op1 as u32) << SYSREG_OP1_SHIFT) & SYSREG_OP1_MASK as u32)
-            | ((($crn as u32) << SYSREG_CRN_SHIFT) & SYSREG_CRN_MASK as u32)
-            | ((($crm as u32) << SYSREG_CRM_SHIFT) & SYSREG_CRM_MASK as u32)
-            | ((($op2 as u32) << SYSREG_OP2_SHIFT) & SYSREG_OP2_MASK as u32);
-    };
-}
-
-arm64_sys_reg!(MPIDR_EL1, 3, 0, 0, 0, 5);
-arm64_sys_reg!(ID_AA64MMFR0_EL1, 3, 0, 0, 7, 0);
-arm64_sys_reg!(TTBR1_EL1, 3, 0, 2, 0, 1);
-arm64_sys_reg!(TCR_EL1, 3, 0, 2, 0, 2);

arch/src/aarch64/uefi.rs

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

arch/src/lib.rs

@@ -1,60 +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::unreadable_literal,
+    clippy::redundant_static_lifetimes,
+    clippy::cast_lossless,
+    clippy::transmute_ptr_to_ptr,
+    clippy::cast_ptr_alignment
+)]
 
-#[macro_use]
-extern crate log;
+extern crate byteorder;
+extern crate kvm_bindings;
+extern crate libc;
+
+#[cfg(feature = "acpi")]
+extern crate acpi_tables;
+extern crate arch_gen;
+extern crate kvm_ioctls;
+extern crate linux_loader;
+extern crate vm_memory;
 
-#[cfg(target_arch = "x86_64")]
-use crate::x86_64::SgxEpcSection;
-use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-use std::fmt;
 use std::result;
-use std::sync::Arc;
-use thiserror::Error;
-use versionize::{VersionMap, Versionize, VersionizeError, VersionizeResult};
-use versionize_derive::Versionize;
-use vm_migration::VersionMapped;
 
-type GuestMemoryMmap = vm_memory::GuestMemoryMmap<vm_memory::bitmap::AtomicBitmap>;
-type GuestRegionMmap = vm_memory::GuestRegionMmap<vm_memory::bitmap::AtomicBitmap>;
-
-/// Type for returning error code.
-#[derive(Debug, Error)]
+#[derive(Debug)]
 pub enum Error {
     #[cfg(target_arch = "x86_64")]
-    #[error("Platform specific error (x86_64): {0:?}")]
-    PlatformSpecific(x86_64::Error),
-    #[cfg(target_arch = "aarch64")]
-    #[error("Platform specific error (aarch64): {0:?}")]
-    PlatformSpecific(aarch64::Error),
-    #[error("The memory map table extends past the end of guest memory")]
-    MemmapTablePastRamEnd,
-    #[error("Error writing memory map table to guest memory")]
-    MemmapTableSetup,
-    #[error("The hvm_start_info structure extends past the end of guest memory")]
-    StartInfoPastRamEnd,
-    #[error("Error writing hvm_start_info to guest memory")]
-    StartInfoSetup,
-    #[error("Failed to compute initramfs address")]
-    InitramfsAddress,
-    #[error("Error writing module entry to guest memory: {0}")]
-    ModlistSetup(#[source] vm_memory::GuestMemoryError),
-    #[error("RSDP extends past the end of guest memory")]
-    RsdpPastRamEnd,
+    /// X86_64 specific error triggered during system configuration.
+    X86_64Setup(x86_64::Error),
+    /// The zero page extends past the end of guest_mem.
+    ZeroPagePastRamEnd,
+    /// Error writing the zero page of guest memory.
+    ZeroPageSetup(vm_memory::GuestMemoryError),
 }
-
-/// Type for returning public functions outcome.
 pub type Result<T> = result::Result<T, Error>;
 
-/// Type for memory region types.
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, Versionize)]
+#[derive(PartialEq)]
 pub enum RegionType {
     /// RAM type
     Ram,
@@ -72,17 +52,13 @@ pub enum RegionType {
     Reserved,
 }
 
-impl VersionMapped for RegionType {}
-
-/// Module for aarch64 related functionality.
 #[cfg(target_arch = "aarch64")]
 pub mod aarch64;
 
 #[cfg(target_arch = "aarch64")]
 pub use aarch64::{
-    arch_memory_regions, configure_system, configure_vcpu, fdt::DeviceInfoForFdt,
-    get_host_cpu_phys_bits, initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE,
-    layout::IRQ_BASE, uefi, EntryPoint, _NSIG,
+    arch_memory_regions, configure_system, get_reserved_mem_addr, layout::CMDLINE_MAX_SIZE,
+    layout::CMDLINE_START,
 };
 
 #[cfg(target_arch = "x86_64")]
@@ -90,93 +66,5 @@ pub mod x86_64;
 
 #[cfg(target_arch = "x86_64")]
 pub use x86_64::{
-    arch_memory_regions, configure_system, configure_vcpu, generate_common_cpuid,
-    get_host_cpu_phys_bits, initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE,
-    layout::CMDLINE_START, regs, CpuidFeatureEntry, EntryPoint, _NSIG,
+    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 {
-    // SAFETY: Trivially safe
-    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
-}
-
-#[derive(Clone, Default)]
-pub struct NumaNode {
-    pub memory_regions: Vec<Arc<GuestRegionMmap>>,
-    pub hotplug_regions: Vec<Arc<GuestRegionMmap>>,
-    pub cpus: Vec<u8>,
-    pub distances: BTreeMap<u32, u8>,
-    pub memory_zones: Vec<String>,
-    #[cfg(target_arch = "x86_64")]
-    pub sgx_epc_sections: Vec<SgxEpcSection>,
-}
-
-pub type NumaNodes = BTreeMap<u32, NumaNode>;
-
-/// 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 len: u64,
-    pub irq: u32,
-}
-
-/// Structure to describe PCI space information
-#[derive(Clone, Debug)]
-#[cfg(target_arch = "aarch64")]
-pub struct PciSpaceInfo {
-    pub pci_segment_id: u16,
-    pub mmio_config_address: u64,
-    pub pci_device_space_start: u64,
-    pub pci_device_space_size: u64,
-}
-
-#[cfg(target_arch = "aarch64")]
-impl DeviceInfoForFdt for MmioDeviceInfo {
-    fn addr(&self) -> u64 {
-        self.addr
-    }
-    fn irq(&self) -> u32 {
-        self.irq
-    }
-    fn length(&self) -> u64 {
-        self.len
-    }
-}

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::arch::x86::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,
@@ -106,6 +79,7 @@ pub fn segment_from_gdt(entry: u64, table_index: u8) -> SegmentRegister {
         l: get_l(entry),
         g: get_g(entry),
         avl: get_avl(entry),
+        padding: 0,
         unusable: match get_p(entry) {
             0 => 1,
             _ => 0,
@@ -120,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);
@@ -135,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,35 +5,154 @@
 // 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::io::Cursor;
+use std::mem;
 use std::result;
-use std::sync::Arc;
 
-pub type Result<T> = result::Result<T, hypervisor::HypervisorCpuError>;
+use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+
+use kvm_bindings::kvm_lapic_state;
+use kvm_ioctls;
+
+#[derive(Debug)]
+pub enum Error {
+    GetLapic(kvm_ioctls::Error),
+    SetLapic(kvm_ioctls::Error),
+}
+
+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 set_apic_delivery_mode(reg: u32, mode: u32) -> u32 {
-    ((reg) & !0x700) | ((mode) << 8)
+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).
+        mem::transmute::<&[i8], &[u8]>(&klapic.regs[reg_offset..])
+    };
+    let mut reader = Cursor::new(sliceu8);
+    // Following call can't fail if the offsets defined above are correct.
+    reader
+        .read_u32::<LittleEndian>()
+        .expect("Failed to read klapic register")
+}
+
+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).
+        mem::transmute::<&mut [i8], &mut [u8]>(&mut klapic.regs[reg_offset..])
+    };
+    let mut writer = Cursor::new(sliceu8);
+    // Following call can't fail if the offsets defined above are correct.
+    writer
+        .write_u32::<LittleEndian>(value)
+        .expect("Failed to write klapic register")
+}
+
+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 = klapic.get_klapic_reg(APIC_LVT0);
-    klapic.set_klapic_reg(
+    let lvt_lint0 = get_klapic_reg(&klapic, APIC_LVT0);
+    set_klapic_reg(
+        &mut klapic,
         APIC_LVT0,
         set_apic_delivery_mode(lvt_lint0, APIC_MODE_EXTINT),
     );
-    let lvt_lint1 = klapic.get_klapic_reg(APIC_LVT1);
-    klapic.set_klapic_reg(APIC_LVT1, set_apic_delivery_mode(lvt_lint1, APIC_MODE_NMI));
+    let lvt_lint1 = get_klapic_reg(&klapic, APIC_LVT1);
+    set_klapic_reg(
+        &mut klapic,
+        APIC_LVT1,
+        set_apic_delivery_mode(lvt_lint1, APIC_MODE_NMI),
+    );
 
-    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 = kvm_lapic_state::default();
+        set_klapic_reg(&mut klapic, reg_offset, 3);
+        let value = get_klapic_reg(&klapic, reg_offset);
+        assert_eq!(value, 3);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_set_and_get_klapic_out_of_bounds() {
+        let reg_offset = KVM_APIC_REG_SIZE + 10;
+        let mut klapic = kvm_lapic_state::default();
+        set_klapic_reg(&mut klapic, reg_offset, 3);
+    }
+
+    #[test]
+    fn test_apic_delivery_mode() {
+        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};
 
 /*
 
@@ -24,24 +22,10 @@ pub const LOW_RAM_START: GuestAddress = GuestAddress(0x0);
 
 // == Fixed addresses within the "Low RAM" range: ==
 
-// Location of EBDA address
-pub const EBDA_POINTER: GuestAddress = GuestAddress(0x40e);
-
 // Initial GDT/IDT needed to boot kernel
 pub const BOOT_GDT_START: GuestAddress = GuestAddress(0x500);
 pub const BOOT_IDT_START: GuestAddress = GuestAddress(0x520);
 
-/// 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);
 
@@ -50,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);
@@ -73,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) **
@@ -82,43 +63,31 @@ pub const HIGH_RAM_START: GuestAddress = GuestAddress(0x100000);
 
 // == No fixed addresses in the "High RAM" range ==
 
-// ** 32-bit reserved area (start: 3GiB, length: 896MiB) **
+// ** 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 = PCI_MMCONFIG_SIZE + MEM_32BIT_DEVICES_SIZE;
+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;
-// One bus with potentially 256 devices (32 slots x 8 functions).
-pub const PCI_MMIO_CONFIG_SIZE_PER_SEGMENT: u64 = 4096 * 256;
-
-// TSS is 3 pages after the PCI MMCONFIG space
-pub const KVM_TSS_START: GuestAddress = GuestAddress(PCI_MMCONFIG_START.0 + PCI_MMCONFIG_SIZE);
-pub const KVM_TSS_SIZE: u64 = (3 * 4) << 10;
-
-// Identity map is a one page region after the TSS
-pub const KVM_IDENTITY_MAP_START: GuestAddress = GuestAddress(KVM_TSS_START.0 + KVM_TSS_SIZE);
-pub const KVM_IDENTITY_MAP_SIZE: u64 = 4 << 10;
-
-/// TPM Address Range
-/// This Address range is specific to CRB Interface
-pub const TPM_START: GuestAddress = GuestAddress(0xfed4_0000);
-pub const TPM_SIZE: u64 = 0x1000;
+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);
 
+/// Address for the TSS setup.
+pub const KVM_TSS_ADDRESS: GuestAddress = GuestAddress(0xfffb_d000);
+
 // == End of "32-bit reserved" range. ==
 
 // ** 64-bit RAM start (start: 4GiB, length: varies) **

arch/src/x86_64/mpspec.rs

@@ -1,112 +0,0 @@
-// 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.
-
-pub const MP_PROCESSOR: ::std::os::raw::c_uint = 0;
-pub const MP_BUS: ::std::os::raw::c_uint = 1;
-pub const MP_IOAPIC: ::std::os::raw::c_uint = 2;
-pub const MP_INTSRC: ::std::os::raw::c_uint = 3;
-pub const MP_LINTSRC: ::std::os::raw::c_uint = 4;
-pub const CPU_ENABLED: ::std::os::raw::c_uint = 1;
-pub const CPU_BOOTPROCESSOR: ::std::os::raw::c_uint = 2;
-pub const MPC_APIC_USABLE: ::std::os::raw::c_uint = 1;
-pub const MP_IRQDIR_DEFAULT: ::std::os::raw::c_uint = 0;
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct mpf_intel {
-    pub signature: [::std::os::raw::c_char; 4usize],
-    pub physptr: ::std::os::raw::c_uint,
-    pub length: ::std::os::raw::c_uchar,
-    pub specification: ::std::os::raw::c_uchar,
-    pub checksum: ::std::os::raw::c_uchar,
-    pub feature1: ::std::os::raw::c_uchar,
-    pub feature2: ::std::os::raw::c_uchar,
-    pub feature3: ::std::os::raw::c_uchar,
-    pub feature4: ::std::os::raw::c_uchar,
-    pub feature5: ::std::os::raw::c_uchar,
-}
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct mpc_table {
-    pub signature: [::std::os::raw::c_char; 4usize],
-    pub length: ::std::os::raw::c_ushort,
-    pub spec: ::std::os::raw::c_char,
-    pub checksum: ::std::os::raw::c_char,
-    pub oem: [::std::os::raw::c_char; 8usize],
-    pub productid: [::std::os::raw::c_char; 12usize],
-    pub oemptr: ::std::os::raw::c_uint,
-    pub oemsize: ::std::os::raw::c_ushort,
-    pub oemcount: ::std::os::raw::c_ushort,
-    pub lapic: ::std::os::raw::c_uint,
-    pub reserved: ::std::os::raw::c_uint,
-}
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct mpc_cpu {
-    pub type_: ::std::os::raw::c_uchar,
-    pub apicid: ::std::os::raw::c_uchar,
-    pub apicver: ::std::os::raw::c_uchar,
-    pub cpuflag: ::std::os::raw::c_uchar,
-    pub cpufeature: ::std::os::raw::c_uint,
-    pub featureflag: ::std::os::raw::c_uint,
-    pub reserved: [::std::os::raw::c_uint; 2usize],
-}
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct mpc_bus {
-    pub type_: ::std::os::raw::c_uchar,
-    pub busid: ::std::os::raw::c_uchar,
-    pub bustype: [::std::os::raw::c_uchar; 6usize],
-}
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct mpc_ioapic {
-    pub type_: ::std::os::raw::c_uchar,
-    pub apicid: ::std::os::raw::c_uchar,
-    pub apicver: ::std::os::raw::c_uchar,
-    pub flags: ::std::os::raw::c_uchar,
-    pub apicaddr: ::std::os::raw::c_uint,
-}
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct mpc_intsrc {
-    pub type_: ::std::os::raw::c_uchar,
-    pub irqtype: ::std::os::raw::c_uchar,
-    pub irqflag: ::std::os::raw::c_ushort,
-    pub srcbus: ::std::os::raw::c_uchar,
-    pub srcbusirq: ::std::os::raw::c_uchar,
-    pub dstapic: ::std::os::raw::c_uchar,
-    pub dstirq: ::std::os::raw::c_uchar,
-}
-
-pub const MP_IRQ_SOURCE_TYPES_MP_INT: ::std::os::raw::c_uint = 0;
-pub const MP_IRQ_SOURCE_TYPES_MP_NMI: ::std::os::raw::c_uint = 1;
-pub const MP_IRQ_SOURCE_TYPES_MP_EXT_INT: ::std::os::raw::c_uint = 3;
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct mpc_lintsrc {
-    pub type_: ::std::os::raw::c_uchar,
-    pub irqtype: ::std::os::raw::c_uchar,
-    pub irqflag: ::std::os::raw::c_ushort,
-    pub srcbusid: ::std::os::raw::c_uchar,
-    pub srcbusirq: ::std::os::raw::c_uchar,
-    pub destapic: ::std::os::raw::c_uchar,
-    pub destapiclint: ::std::os::raw::c_uchar,
-}
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct mpc_oemtable {
-    pub signature: [::std::os::raw::c_char; 4usize],
-    pub length: ::std::os::raw::c_ushort,
-    pub rev: ::std::os::raw::c_char,
-    pub checksum: ::std::os::raw::c_char,
-    pub mpc: [::std::os::raw::c_char; 8usize],
-}

arch/src/x86_64/mptable.rs

@@ -5,15 +5,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
-use crate::layout::{APIC_START, HIGH_RAM_START, IOAPIC_START};
-use crate::x86_64::mpspec;
-use crate::GuestMemoryMmap;
-use libc::c_char;
 use std::io;
 use std::mem;
 use std::result;
 use std::slice;
-use vm_memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryError};
+
+use libc::c_char;
+
+use arch_gen::x86::mpspec;
+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:
@@ -35,19 +36,13 @@ struct MpcLintsrcWrapper(mpspec::mpc_lintsrc);
 #[derive(Copy, Clone, Default)]
 struct MpfIntelWrapper(mpspec::mpf_intel);
 
-// SAFETY: These `mpspec` wrapper types are only data, reading them from data is a safe initialization.
+// These `mpspec` wrapper types are only data, reading them from data is a safe initialization.
 unsafe impl ByteValued for MpcBusWrapper {}
-// SAFETY: see above
 unsafe impl ByteValued for MpcCpuWrapper {}
-// SAFETY: see above
 unsafe impl ByteValued for MpcIntsrcWrapper {}
-// SAFETY: see above
 unsafe impl ByteValued for MpcIoapicWrapper {}
-// SAFETY: see above
 unsafe impl ByteValued for MpcTableWrapper {}
-// SAFETY: see above
 unsafe impl ByteValued for MpcLintsrcWrapper {}
-// SAFETY: see above
 unsafe impl ByteValued for MpfIntelWrapper {}
 
 #[derive(Debug)]
@@ -101,7 +96,7 @@ const CPU_FEATURE_APIC: u32 = 0x200;
 const CPU_FEATURE_FPU: u32 = 0x001;
 
 fn compute_checksum<T: Copy>(v: &T) -> u8 {
-    // SAFETY: we are only reading the bytes within the size of the `T` reference `v`.
+    // 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() {
@@ -126,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;
 
@@ -225,7 +215,7 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
         let size = mem::size_of::<MpcIntsrcWrapper>();
         let mut mpc_intsrc = MpcIntsrcWrapper(mpspec::mpc_intsrc::default());
         mpc_intsrc.0.type_ = mpspec::MP_INTSRC as u8;
-        mpc_intsrc.0.irqtype = mpspec::MP_IRQ_SOURCE_TYPES_MP_INT as u8;
+        mpc_intsrc.0.irqtype = mpspec::mp_irq_source_types_mp_INT as u8;
         mpc_intsrc.0.irqflag = mpspec::MP_IRQDIR_DEFAULT as u16;
         mpc_intsrc.0.srcbus = 0;
         mpc_intsrc.0.srcbusirq = i;
@@ -240,7 +230,7 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
         let size = mem::size_of::<MpcLintsrcWrapper>();
         let mut mpc_lintsrc = MpcLintsrcWrapper(mpspec::mpc_lintsrc::default());
         mpc_lintsrc.0.type_ = mpspec::MP_LINTSRC as u8;
-        mpc_lintsrc.0.irqtype = mpspec::MP_IRQ_SOURCE_TYPES_MP_EXT_INT as u8;
+        mpc_lintsrc.0.irqtype = mpspec::mp_irq_source_types_mp_ExtINT as u8;
         mpc_lintsrc.0.irqflag = mpspec::MP_IRQDIR_DEFAULT as u16;
         mpc_lintsrc.0.srcbusid = 0;
         mpc_lintsrc.0.srcbusirq = 0;
@@ -255,7 +245,7 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
         let size = mem::size_of::<MpcLintsrcWrapper>();
         let mut mpc_lintsrc = MpcLintsrcWrapper(mpspec::mpc_lintsrc::default());
         mpc_lintsrc.0.type_ = mpspec::MP_LINTSRC as u8;
-        mpc_lintsrc.0.irqtype = mpspec::MP_IRQ_SOURCE_TYPES_MP_NMI as u8;
+        mpc_lintsrc.0.irqtype = mpspec::mp_irq_source_types_mp_NMI as u8;
         mpc_lintsrc.0.irqflag = mpspec::MP_IRQDIR_DEFAULT as u16;
         mpc_lintsrc.0.srcbusid = 0;
         mpc_lintsrc.0.srcbusirq = 0;
@@ -290,7 +280,6 @@ pub fn setup_mptable(offset: GuestAddress, mem: &GuestMemoryMmap, num_cpus: u8)
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::layout::MPTABLE_START;
     use vm_memory::{GuestAddress, GuestUsize};
 
     fn table_entry_size(type_: u8) -> usize {
@@ -300,7 +289,7 @@ mod tests {
             mpspec::MP_IOAPIC => mem::size_of::<MpcIoapicWrapper>(),
             mpspec::MP_INTSRC => mem::size_of::<MpcIntsrcWrapper>(),
             mpspec::MP_LINTSRC => mem::size_of::<MpcLintsrcWrapper>(),
-            _ => panic!("unrecognized mpc table entry type: {type_}"),
+            _ => panic!("unrecognized mpc table entry type: {}", type_),
         }
     }
 
@@ -310,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]
@@ -319,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]
@@ -328,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();
 
@@ -344,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);
@@ -378,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);
@@ -411,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,46 +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 crate::layout::{BOOT_GDT_START, BOOT_IDT_START, PVH_INFO_START};
-use crate::GuestMemoryMmap;
-use hypervisor::arch::x86::gdt::{gdt_entry, segment_from_gdt};
-use hypervisor::arch::x86::regs::CR0_PE;
-use hypervisor::arch::x86::{FpuState, SpecialRegisters, StandardRegisters};
-use std::sync::Arc;
+
 use std::{mem, result};
-use vm_memory::{Address, Bytes, GuestMemory, GuestMemoryError};
+
+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>;
@@ -50,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.
@@ -65,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(&vcpu.boot_msr_entries())
+pub fn setup_msrs(vcpu: &VcpuFd) -> Result<()> {
+    vcpu.set_msrs(&create_msr_entries())
         .map_err(Error::SetModelSpecificRegisters)?;
 
     Ok(())
@@ -78,13 +79,18 @@ pub fn setup_msrs(vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
 ///
 /// * `vcpu` - Structure for the VCPU that holds the VCPU's fd.
 /// * `boot_ip` - Starting instruction pointer.
-pub fn setup_regs(vcpu: &Arc<dyn hypervisor::Vcpu>, boot_ip: u64) -> Result<()> {
-    let regs = StandardRegisters {
+/// * `boot_sp` - Starting stack pointer.
+/// * `boot_si` - Must point to zero page address per Linux ABI.
+pub fn setup_regs(vcpu: &VcpuFd, boot_ip: u64, boot_sp: u64, boot_si: u64) -> Result<()> {
+    let regs: kvm_regs = kvm_regs {
         rflags: 0x0000000000000002u64,
-        rbx: PVH_INFO_START.raw_value(),
         rip: boot_ip,
+        rsp: boot_sp,
+        rbp: boot_sp,
+        rsi: boot_si,
         ..Default::default()
     };
+
     vcpu.set_regs(&regs).map_err(Error::SetBaseRegisters)
 }
 
@@ -94,21 +100,31 @@ pub fn setup_regs(vcpu: &Arc<dyn hypervisor::Vcpu>, boot_ip: u64) -> Result<()>
 ///
 /// * `mem` - The memory that will be passed to the guest.
 /// * `vcpu` - Structure for the VCPU that holds the VCPU's fd.
-pub fn setup_sregs(mem: &GuestMemoryMmap, vcpu: &Arc<dyn hypervisor::Vcpu>) -> Result<()> {
-    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)?;
+    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(())
 }
@@ -117,26 +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,
-) -> Result<()> {
-    let gdt_table: [u64; BOOT_GDT_MAX] = {
-        // 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
-        ]
-    };
+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)?;
@@ -155,20 +165,111 @@ pub fn configure_segments_and_sregs(
     sregs.ss = data_seg;
     sregs.tr = tss_seg;
 
-    sregs.cr0 = CR0_PE;
-    sregs.cr4 = 0;
+    /* 64-bit protected mode */
+    sregs.cr0 |= X86_CR0_PE;
+    sregs.efer |= EFER_LME | EFER_LMA;
 
     Ok(())
 }
 
+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)?;
+
+    // Entry covering VA [0..1GB)
+    mem.write_obj(PDE_START.raw_value() | 0x03, PDPTE_START)
+        .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)?;
+    }
+
+    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 crate::GuestMemoryMmap;
-    use vm_memory::GuestAddress;
+    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 {
@@ -177,12 +278,13 @@ 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).unwrap();
+
         assert_eq!(0x0, read_u64(&gm, BOOT_GDT_START));
         assert_eq!(
-            0xcf9b000000ffff,
+            0xaf9b000000ffff,
             read_u64(&gm, BOOT_GDT_START.unchecked_add(8))
         );
         assert_eq!(
@@ -190,23 +292,132 @@ mod tests {
             read_u64(&gm, BOOT_GDT_START.unchecked_add(16))
         );
         assert_eq!(
-            0x8b0000000067,
+            0x8f8b000000ffff,
             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!(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!(0, sregs.tr.g);
-        assert_eq!(0x67, sregs.tr.limit);
-        assert_eq!(0xb, sregs.tr.type_);
+        assert_eq!(0xfffff, sregs.tr.limit);
         assert_eq!(0, sregs.tr.avl);
-        assert_eq!(CR0_PE, sregs.cr0);
-        assert_eq!(0, sregs.cr4);
+        assert_eq!(X86_CR0_PE, sregs.cr0);
+        assert_eq!(EFER_LME | EFER_LMA, sregs.efer);
+    }
+
+    #[test]
+    fn page_tables() {
+        let mut sregs: kvm_sregs = Default::default();
+        let gm = create_guest_mem();
+        setup_page_tables(&gm, &mut sregs).unwrap();
+
+        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,
+                read_u64(&gm, PDE_START.unchecked_add(i * 8))
+            );
+        }
+
+        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,325 +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 crate::layout::SMBIOS_START;
-use crate::GuestMemoryMmap;
-use std::fmt::{self, Display};
-use std::mem;
-use std::result;
-use std::slice;
-use uuid::Uuid;
-use vm_memory::ByteValued;
-use vm_memory::{Address, Bytes, GuestAddress};
-
-#[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,
-    /// Failure to parse uuid, uuid format may be error
-    ParseUuid(uuid::Error),
-}
-
-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".to_string()
-            }
-            AddressOverflow => {
-                "The SMBIOS table has too little address space to be stored".to_string()
-            }
-            Clear => "Failure while zeroing out the memory for the SMBIOS table".to_string(),
-            WriteSmbiosEp => "Failure to write SMBIOS entrypoint structure".to_string(),
-            WriteData => "Failure to write additional data to memory".to_string(),
-            ParseUuid(e) => format!("Failure to parse uuid: {e}"),
-        };
-
-        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 OEM_STRINGS: u8 = 11;
-const END_OF_TABLE: u8 = 127;
-const PCI_SUPPORTED: u64 = 1 << 7;
-const IS_VIRTUAL_MACHINE: u8 = 1 << 4;
-
-fn compute_checksum<T: Copy>(v: &T) -> u8 {
-    // SAFETY: we are only reading the bytes within the size of the `T` reference `v`.
-    let v_slice = unsafe { slice::from_raw_parts(v as *const T as *const u8, mem::size_of::<T>()) };
-    let mut checksum: u8 = 0;
-    for i in v_slice.iter() {
-        checksum = checksum.wrapping_add(*i);
-    }
-    (!checksum).wrapping_add(1)
-}
-
-#[repr(C)]
-#[repr(packed)]
-#[derive(Default, Copy, Clone)]
-struct Smbios30Entrypoint {
-    signature: [u8; 5usize],
-    checksum: u8,
-    length: u8,
-    majorver: u8,
-    minorver: u8,
-    docrev: u8,
-    revision: u8,
-    reserved: u8,
-    max_size: u32,
-    physptr: u64,
-}
-
-#[repr(C)]
-#[repr(packed)]
-#[derive(Default, Copy, Clone)]
-struct SmbiosBiosInfo {
-    r#type: u8,
-    length: u8,
-    handle: u16,
-    vendor: u8,
-    version: u8,
-    start_addr: u16,
-    release_date: u8,
-    rom_size: u8,
-    characteristics: u64,
-    characteristics_ext1: u8,
-    characteristics_ext2: u8,
-}
-
-#[repr(C)]
-#[repr(packed)]
-#[derive(Default, Copy, Clone)]
-struct SmbiosSysInfo {
-    r#type: u8,
-    length: u8,
-    handle: u16,
-    manufacturer: u8,
-    product_name: u8,
-    version: u8,
-    serial_number: u8,
-    uuid: [u8; 16usize],
-    wake_up_type: u8,
-    sku: u8,
-    family: u8,
-}
-
-#[repr(C)]
-#[repr(packed)]
-#[derive(Default, Copy, Clone)]
-struct SmbiosOemStrings {
-    r#type: u8,
-    length: u8,
-    handle: u16,
-    count: u8,
-}
-
-#[repr(C)]
-#[repr(packed)]
-#[derive(Default, Copy, Clone)]
-struct SmbiosEndOfTable {
-    r#type: u8,
-    length: u8,
-    handle: u16,
-}
-
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for Smbios30Entrypoint {}
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for SmbiosBiosInfo {}
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for SmbiosSysInfo {}
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for SmbiosOemStrings {}
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for SmbiosEndOfTable {}
-
-fn write_and_incr<T: ByteValued>(
-    mem: &GuestMemoryMmap,
-    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,
-    serial_number: Option<&str>,
-    uuid: Option<&str>,
-    oem_strings: Option<&[&str]>,
-) -> Result<u64> {
-    let physptr = GuestAddress(SMBIOS_START)
-        .checked_add(mem::size_of::<Smbios30Entrypoint>() as u64)
-        .ok_or(Error::NotEnoughMemory)?;
-    let mut curptr = physptr;
-    let mut handle = 0;
-
-    {
-        handle += 1;
-        let smbios_biosinfo = SmbiosBiosInfo {
-            r#type: 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 uuid_number = uuid
-            .map(Uuid::parse_str)
-            .transpose()
-            .map_err(Error::ParseUuid)?
-            .unwrap_or(Uuid::nil());
-        let smbios_sysinfo = SmbiosSysInfo {
-            r#type: SYSTEM_INFORMATION,
-            length: mem::size_of::<SmbiosSysInfo>() as u8,
-            handle,
-            manufacturer: 1, // First string written in this section
-            product_name: 2, // Second string written in this section
-            serial_number: serial_number.map(|_| 3).unwrap_or_default(), // 3rd string
-            uuid: uuid_number.to_bytes_le(), // set uuid
-            ..Default::default()
-        };
-        curptr = write_and_incr(mem, smbios_sysinfo, curptr)?;
-        curptr = write_string(mem, "Cloud Hypervisor", curptr)?;
-        curptr = write_string(mem, "cloud-hypervisor", curptr)?;
-        if let Some(serial_number) = serial_number {
-            curptr = write_string(mem, serial_number, curptr)?;
-        }
-        curptr = write_and_incr(mem, 0u8, curptr)?;
-    }
-
-    if let Some(oem_strings) = oem_strings {
-        handle += 1;
-
-        let smbios_oemstrings = SmbiosOemStrings {
-            r#type: OEM_STRINGS,
-            length: mem::size_of::<SmbiosOemStrings>() as u8,
-            handle,
-            count: oem_strings.len() as u8,
-        };
-
-        curptr = write_and_incr(mem, smbios_oemstrings, curptr)?;
-
-        for s in oem_strings {
-            curptr = write_string(mem, s, curptr)?;
-        }
-
-        curptr = write_and_incr(mem, 0u8, curptr)?;
-    }
-
-    {
-        handle += 1;
-        let smbios_end = SmbiosEndOfTable {
-            r#type: END_OF_TABLE,
-            length: mem::size_of::<SmbiosEndOfTable>() as u8,
-            handle,
-        };
-        curptr = write_and_incr(mem, smbios_end, curptr)?;
-        curptr = write_and_incr(mem, 0u8, 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) + std::mem::size_of::<Smbios30Entrypoint>() as u64)
-}
-
-#[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, None, None, None).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,532 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-use crate::GuestMemoryMmap;
-use std::fs::File;
-use std::io::{Read, Seek, SeekFrom};
-use std::str::FromStr;
-use thiserror::Error;
-use uuid::Uuid;
-use vm_memory::{ByteValued, Bytes, GuestAddress, GuestMemoryError};
-
-#[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("Failed read GUID table: {0}")]
-    ReadGuidTable(#[source] std::io::Error),
-    #[error("Invalid descriptor signature")]
-    InvalidDescriptorSignature,
-    #[error("Invalid descriptor size")]
-    InvalidDescriptorSize,
-    #[error("Invalid descriptor version")]
-    InvalidDescriptorVersion,
-    #[error("Failed to write HOB details to guest memory: {0}")]
-    GuestMemoryWriteHob(#[source] GuestMemoryError),
-    #[error("Failed to create Uuid: {0}")]
-    UuidCreation(#[source] uuid::Error),
-}
-
-const TABLE_FOOTER_GUID: &str = "96b582de-1fb2-45f7-baea-a366c55a082d";
-const TDVF_METADATA_OFFSET_GUID: &str = "e47a6535-984a-4798-865e-4685a7bf8ec2";
-
-// TDVF_DESCRIPTOR
-#[repr(packed)]
-#[derive(Default)]
-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, Default)]
-pub enum TdvfSectionType {
-    Bfv,
-    Cfv,
-    TdHob,
-    TempMem,
-    PermMem,
-    Payload,
-    PayloadParam,
-    #[default]
-    Reserved = 0xffffffff,
-}
-
-fn tdvf_descriptor_offset(file: &mut File) -> Result<(SeekFrom, bool), TdvfError> {
-    // Let's first try to identify the presence of the table footer GUID
-    file.seek(SeekFrom::End(-0x30))
-        .map_err(TdvfError::ReadGuidTable)?;
-    let mut table_footer_guid: [u8; 16] = [0; 16];
-    file.read_exact(&mut table_footer_guid)
-        .map_err(TdvfError::ReadGuidTable)?;
-    let uuid =
-        Uuid::from_slice_le(table_footer_guid.as_slice()).map_err(TdvfError::UuidCreation)?;
-    let expected_uuid = Uuid::from_str(TABLE_FOOTER_GUID).map_err(TdvfError::UuidCreation)?;
-    if uuid == expected_uuid {
-        // Retrieve the table size
-        file.seek(SeekFrom::End(-0x32))
-            .map_err(TdvfError::ReadGuidTable)?;
-        let mut table_size: [u8; 2] = [0; 2];
-        file.read_exact(&mut table_size)
-            .map_err(TdvfError::ReadGuidTable)?;
-        let table_size = u16::from_le_bytes(table_size) as usize;
-        let mut table: Vec<u8> = vec![0; table_size];
-
-        // Read the entire table
-        file.seek(SeekFrom::End(-(table_size as i64 + 0x20)))
-            .map_err(TdvfError::ReadGuidTable)?;
-        file.read_exact(table.as_mut_slice())
-            .map_err(TdvfError::ReadGuidTable)?;
-
-        // Let's start from the top and go backward down the table.
-        // We start after the footer GUID and the table length.
-        let mut offset = table_size - 18;
-
-        debug!("Parsing GUIDed structure");
-        while offset >= 18 {
-            let entry_uuid = Uuid::from_slice_le(&table[offset - 16..offset])
-                .map_err(TdvfError::UuidCreation)?;
-            let entry_size =
-                u16::from_le_bytes(table[offset - 18..offset - 16].try_into().unwrap()) as usize;
-            debug!(
-                "Entry GUID = {}, size = {}",
-                entry_uuid.hyphenated().to_string(),
-                entry_size
-            );
-
-            // Avoid going through an infinite loop if the entry size is 0
-            if entry_size == 0 {
-                break;
-            }
-
-            offset -= entry_size;
-
-            let expected_uuid =
-                Uuid::from_str(TDVF_METADATA_OFFSET_GUID).map_err(TdvfError::UuidCreation)?;
-            if entry_uuid == expected_uuid && entry_size == 22 {
-                return Ok((
-                    SeekFrom::End(
-                        -(u32::from_le_bytes(table[offset..offset + 4].try_into().unwrap()) as i64),
-                    ),
-                    true,
-                ));
-            }
-        }
-    }
-
-    // If we end up here, this means the firmware doesn't support the new way
-    // of exposing the TDVF descriptor offset through the table of GUIDs.
-    // That's why we fallback onto the deprecated method.
-
-    // The 32-bit offset to the TDVF metadata is located 32 bytes from
-    // the end of the file.
-    // See "TDVF Metadata Pointer" in "TDX Virtual Firmware Design Guide
-    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)?;
-
-    Ok((
-        SeekFrom::Start(u32::from_le_bytes(descriptor_offset) as u64),
-        false,
-    ))
-}
-
-pub fn parse_tdvf_sections(file: &mut File) -> Result<(Vec<TdvfSection>, bool), TdvfError> {
-    let (descriptor_offset, guid_found) = tdvf_descriptor_offset(file)?;
-
-    file.seek(descriptor_offset)
-        .map_err(TdvfError::ReadDescriptor)?;
-
-    let mut descriptor: TdvfDescriptor = Default::default();
-    // SAFETY: we read exactly the size of the descriptor header
-    file.read_exact(unsafe {
-        std::slice::from_raw_parts_mut(
-            &mut descriptor as *mut _ as *mut u8,
-            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);
-
-    // SAFETY: 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, guid_found))
-}
-
-#[repr(u16)]
-#[derive(Copy, Clone, Debug, Default)]
-enum HobType {
-    Handoff = 0x1,
-    ResourceDescriptor = 0x3,
-    GuidExtension = 0x4,
-    #[default]
-    Unused = 0xfffe,
-    EndOfHobList = 0xffff,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-struct HobHeader {
-    r#type: HobType,
-    length: u16,
-    reserved: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-struct HobHandoffInfoTable {
-    header: HobHeader,
-    version: u32,
-    boot_mode: 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,
-}
-
-#[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,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-struct HobGuidType {
-    header: HobHeader,
-    name: EfiGuid,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy, Debug, Default)]
-pub enum PayloadImageType {
-    #[default]
-    ExecutablePayload,
-    BzImage,
-    RawVmLinux,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-pub struct PayloadInfo {
-    pub image_type: PayloadImageType,
-    pub entry_point: u64,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-struct TdPayload {
-    guid_type: HobGuidType,
-    payload_info: PayloadInfo,
-}
-
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for HobHeader {}
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for HobHandoffInfoTable {}
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for HobResourceDescriptor {}
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for HobGuidType {}
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for PayloadInfo {}
-// SAFETY: data structure only contain a series of integers
-unsafe impl ByteValued for TdPayload {}
-
-pub struct TdHob {
-    start_offset: u64,
-    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,
-            boot_mode: 0,
-            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,
-        guid_found: bool,
-    ) -> Result<(), TdvfError> {
-        self.add_resource(
-            mem,
-            physical_start,
-            resource_length,
-            if ram {
-                if guid_found {
-                    0x7 /* EFI_RESOURCE_MEMORY_UNACCEPTED */
-                } else {
-                    0 /* EFI_RESOURCE_SYSTEM_MEMORY */
-                }
-            } else if guid_found {
-                0 /* EFI_RESOURCE_SYSTEM_MEMORY */
-            } else {
-                0x5 /*EFI_RESOURCE_MEMORY_RESERVED */
-            },
-            /* TODO:
-             * QEMU currently fills it in like this:
-             * EFI_RESOURCE_ATTRIBUTE_PRESENT | EFI_RESOURCE_ATTRIBUTE_INITIALIZED | EFI_RESOURCE_ATTRIBUTE_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,
-        )
-    }
-
-    pub fn add_acpi_table(
-        &mut self,
-        mem: &GuestMemoryMmap,
-        table_content: &[u8],
-    ) -> Result<(), TdvfError> {
-        // We already know the HobGuidType size is 8 bytes multiple, but we
-        // need the total size to be 8 bytes multiple. That is why the ACPI
-        // table size must be 8 bytes multiple as well.
-        let length = std::mem::size_of::<HobGuidType>() as u16
-            + align_hob(table_content.len() as u64) as u16;
-        let hob_guid_type = HobGuidType {
-            header: HobHeader {
-                r#type: HobType::GuidExtension,
-                length,
-                reserved: 0,
-            },
-            // ACPI_TABLE_HOB_GUID
-            // 0x6a0c5870, 0xd4ed, 0x44f4, {0xa1, 0x35, 0xdd, 0x23, 0x8b, 0x6f, 0xc, 0x8d }
-            name: EfiGuid {
-                data1: 0x6a0c_5870,
-                data2: 0xd4ed,
-                data3: 0x44f4,
-                data4: [0xa1, 0x35, 0xdd, 0x23, 0x8b, 0x6f, 0xc, 0x8d],
-            },
-        };
-        info!(
-            "Writing HOB ACPI table {:x} {:x?} {:x?}",
-            self.current_offset, hob_guid_type, table_content
-        );
-        mem.write_obj(hob_guid_type, GuestAddress(self.current_offset))
-            .map_err(TdvfError::GuestMemoryWriteHob)?;
-        let current_offset = self.current_offset + std::mem::size_of::<HobGuidType>() as u64;
-
-        // In case the table is quite large, let's make sure we can handle
-        // retrying until everything has been correctly copied.
-        let mut offset: usize = 0;
-        loop {
-            let bytes_written = mem
-                .write(
-                    &table_content[offset..],
-                    GuestAddress(current_offset + offset as u64),
-                )
-                .map_err(TdvfError::GuestMemoryWriteHob)?;
-            offset += bytes_written;
-            if offset >= table_content.len() {
-                break;
-            }
-        }
-        self.current_offset += length as u64;
-
-        Ok(())
-    }
-
-    pub fn add_payload(
-        &mut self,
-        mem: &GuestMemoryMmap,
-        payload_info: PayloadInfo,
-    ) -> Result<(), TdvfError> {
-        let payload = TdPayload {
-            guid_type: HobGuidType {
-                header: HobHeader {
-                    r#type: HobType::GuidExtension,
-                    length: std::mem::size_of::<TdPayload>() as u16,
-                    reserved: 0,
-                },
-                // HOB_PAYLOAD_INFO_GUID
-                // 0xb96fa412, 0x461f, 0x4be3, {0x8c, 0xd, 0xad, 0x80, 0x5a, 0x49, 0x7a, 0xc0
-                name: EfiGuid {
-                    data1: 0xb96f_a412,
-                    data2: 0x461f,
-                    data3: 0x4be3,
-                    data4: [0x8c, 0xd, 0xad, 0x80, 0x5a, 0x49, 0x7a, 0xc0],
-                },
-            },
-            payload_info,
-        };
-        info!(
-            "Writing HOB TD_PAYLOAD {:x} {:x?}",
-            self.current_offset, payload
-        );
-        mem.write_obj(payload, GuestAddress(self.current_offset))
-            .map_err(TdvfError::GuestMemoryWriteHob)?;
-        self.update_offset::<TdPayload>();
-
-        Ok(())
-    }
-}
-
-#[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!("{section:x?}")
-        }
-    }
-}

arch_gen/Cargo.lock

@@ -0,0 +1,6 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "arch_gen"
+version = "0.1.0"
+

arch_gen/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "arch_gen"
+version = "0.1.0"
+authors = ["Amazon firecracker team <firecracker-devel@amazon.com>"]
+
+[dependencies]
+

arch_gen/src/lib.rs

@@ -0,0 +1,5 @@
+// Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+pub mod x86;

arch_gen/src/x86/mod.rs

@@ -0,0 +1,25 @@
+// 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.
+
+#[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

@@ -0,0 +1,832 @@
+// 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.
+
+/* automatically generated by rust-bindgen */
+
+pub const MPC_SIGNATURE: &'static [u8; 5usize] = b"PCMP\x00";
+pub const MP_PROCESSOR: ::std::os::raw::c_uint = 0;
+pub const MP_BUS: ::std::os::raw::c_uint = 1;
+pub const MP_IOAPIC: ::std::os::raw::c_uint = 2;
+pub const MP_INTSRC: ::std::os::raw::c_uint = 3;
+pub const MP_LINTSRC: ::std::os::raw::c_uint = 4;
+pub const MP_TRANSLATION: ::std::os::raw::c_uint = 192;
+pub const CPU_ENABLED: ::std::os::raw::c_uint = 1;
+pub const CPU_BOOTPROCESSOR: ::std::os::raw::c_uint = 2;
+pub const CPU_STEPPING_MASK: ::std::os::raw::c_uint = 15;
+pub const CPU_MODEL_MASK: ::std::os::raw::c_uint = 240;
+pub const CPU_FAMILY_MASK: ::std::os::raw::c_uint = 3840;
+pub const BUSTYPE_EISA: &'static [u8; 5usize] = b"EISA\x00";
+pub const BUSTYPE_ISA: &'static [u8; 4usize] = b"ISA\x00";
+pub const BUSTYPE_INTERN: &'static [u8; 7usize] = b"INTERN\x00";
+pub const BUSTYPE_MCA: &'static [u8; 4usize] = b"MCA\x00";
+pub const BUSTYPE_VL: &'static [u8; 3usize] = b"VL\x00";
+pub const BUSTYPE_PCI: &'static [u8; 4usize] = b"PCI\x00";
+pub const BUSTYPE_PCMCIA: &'static [u8; 7usize] = b"PCMCIA\x00";
+pub const BUSTYPE_CBUS: &'static [u8; 5usize] = b"CBUS\x00";
+pub const BUSTYPE_CBUSII: &'static [u8; 7usize] = b"CBUSII\x00";
+pub const BUSTYPE_FUTURE: &'static [u8; 7usize] = b"FUTURE\x00";
+pub const BUSTYPE_MBI: &'static [u8; 4usize] = b"MBI\x00";
+pub const BUSTYPE_MBII: &'static [u8; 5usize] = b"MBII\x00";
+pub const BUSTYPE_MPI: &'static [u8; 4usize] = b"MPI\x00";
+pub const BUSTYPE_MPSA: &'static [u8; 5usize] = b"MPSA\x00";
+pub const BUSTYPE_NUBUS: &'static [u8; 6usize] = b"NUBUS\x00";
+pub const BUSTYPE_TC: &'static [u8; 3usize] = b"TC\x00";
+pub const BUSTYPE_VME: &'static [u8; 4usize] = b"VME\x00";
+pub const BUSTYPE_XPRESS: &'static [u8; 7usize] = b"XPRESS\x00";
+pub const MPC_APIC_USABLE: ::std::os::raw::c_uint = 1;
+pub const MP_IRQDIR_DEFAULT: ::std::os::raw::c_uint = 0;
+pub const MP_IRQDIR_HIGH: ::std::os::raw::c_uint = 1;
+pub const MP_IRQDIR_LOW: ::std::os::raw::c_uint = 3;
+pub const MP_APIC_ALL: ::std::os::raw::c_uint = 255;
+pub const MPC_OEM_SIGNATURE: &'static [u8; 5usize] = b"_OEM\x00";
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct mpf_intel {
+    pub signature: [::std::os::raw::c_char; 4usize],
+    pub physptr: ::std::os::raw::c_uint,
+    pub length: ::std::os::raw::c_uchar,
+    pub specification: ::std::os::raw::c_uchar,
+    pub checksum: ::std::os::raw::c_uchar,
+    pub feature1: ::std::os::raw::c_uchar,
+    pub feature2: ::std::os::raw::c_uchar,
+    pub feature3: ::std::os::raw::c_uchar,
+    pub feature4: ::std::os::raw::c_uchar,
+    pub feature5: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_mpf_intel() {
+    assert_eq!(
+        ::std::mem::size_of::<mpf_intel>(),
+        16usize,
+        concat!("Size of: ", stringify!(mpf_intel))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mpf_intel>(),
+        4usize,
+        concat!("Alignment of ", stringify!(mpf_intel))
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).signature as *const _ as usize },
+        0usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(signature)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).physptr as *const _ as usize },
+        4usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(physptr)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).length as *const _ as usize },
+        8usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(length)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).specification as *const _ as usize },
+        9usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(specification)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).checksum as *const _ as usize },
+        10usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(checksum)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).feature1 as *const _ as usize },
+        11usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(feature1)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).feature2 as *const _ as usize },
+        12usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(feature2)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).feature3 as *const _ as usize },
+        13usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(feature3)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).feature4 as *const _ as usize },
+        14usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(feature4)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpf_intel)).feature5 as *const _ as usize },
+        15usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpf_intel),
+            "::",
+            stringify!(feature5)
+        )
+    );
+}
+impl Clone for mpf_intel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct mpc_table {
+    pub signature: [::std::os::raw::c_char; 4usize],
+    pub length: ::std::os::raw::c_ushort,
+    pub spec: ::std::os::raw::c_char,
+    pub checksum: ::std::os::raw::c_char,
+    pub oem: [::std::os::raw::c_char; 8usize],
+    pub productid: [::std::os::raw::c_char; 12usize],
+    pub oemptr: ::std::os::raw::c_uint,
+    pub oemsize: ::std::os::raw::c_ushort,
+    pub oemcount: ::std::os::raw::c_ushort,
+    pub lapic: ::std::os::raw::c_uint,
+    pub reserved: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_mpc_table() {
+    assert_eq!(
+        ::std::mem::size_of::<mpc_table>(),
+        44usize,
+        concat!("Size of: ", stringify!(mpc_table))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mpc_table>(),
+        4usize,
+        concat!("Alignment of ", stringify!(mpc_table))
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).signature as *const _ as usize },
+        0usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(signature)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).length as *const _ as usize },
+        4usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(length)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).spec as *const _ as usize },
+        6usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(spec)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).checksum as *const _ as usize },
+        7usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(checksum)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).oem as *const _ as usize },
+        8usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(oem)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).productid as *const _ as usize },
+        16usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(productid)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).oemptr as *const _ as usize },
+        28usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(oemptr)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).oemsize as *const _ as usize },
+        32usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(oemsize)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).oemcount as *const _ as usize },
+        34usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(oemcount)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).lapic as *const _ as usize },
+        36usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(lapic)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_table)).reserved as *const _ as usize },
+        40usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_table),
+            "::",
+            stringify!(reserved)
+        )
+    );
+}
+impl Clone for mpc_table {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct mpc_cpu {
+    pub type_: ::std::os::raw::c_uchar,
+    pub apicid: ::std::os::raw::c_uchar,
+    pub apicver: ::std::os::raw::c_uchar,
+    pub cpuflag: ::std::os::raw::c_uchar,
+    pub cpufeature: ::std::os::raw::c_uint,
+    pub featureflag: ::std::os::raw::c_uint,
+    pub reserved: [::std::os::raw::c_uint; 2usize],
+}
+#[test]
+fn bindgen_test_layout_mpc_cpu() {
+    assert_eq!(
+        ::std::mem::size_of::<mpc_cpu>(),
+        20usize,
+        concat!("Size of: ", stringify!(mpc_cpu))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mpc_cpu>(),
+        4usize,
+        concat!("Alignment of ", stringify!(mpc_cpu))
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_cpu)).type_ as *const _ as usize },
+        0usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_cpu),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_cpu)).apicid as *const _ as usize },
+        1usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_cpu),
+            "::",
+            stringify!(apicid)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_cpu)).apicver as *const _ as usize },
+        2usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_cpu),
+            "::",
+            stringify!(apicver)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_cpu)).cpuflag as *const _ as usize },
+        3usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_cpu),
+            "::",
+            stringify!(cpuflag)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_cpu)).cpufeature as *const _ as usize },
+        4usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_cpu),
+            "::",
+            stringify!(cpufeature)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_cpu)).featureflag as *const _ as usize },
+        8usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_cpu),
+            "::",
+            stringify!(featureflag)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_cpu)).reserved as *const _ as usize },
+        12usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_cpu),
+            "::",
+            stringify!(reserved)
+        )
+    );
+}
+impl Clone for mpc_cpu {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct mpc_bus {
+    pub type_: ::std::os::raw::c_uchar,
+    pub busid: ::std::os::raw::c_uchar,
+    pub bustype: [::std::os::raw::c_uchar; 6usize],
+}
+#[test]
+fn bindgen_test_layout_mpc_bus() {
+    assert_eq!(
+        ::std::mem::size_of::<mpc_bus>(),
+        8usize,
+        concat!("Size of: ", stringify!(mpc_bus))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mpc_bus>(),
+        1usize,
+        concat!("Alignment of ", stringify!(mpc_bus))
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_bus)).type_ as *const _ as usize },
+        0usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_bus),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_bus)).busid as *const _ as usize },
+        1usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_bus),
+            "::",
+            stringify!(busid)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_bus)).bustype as *const _ as usize },
+        2usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_bus),
+            "::",
+            stringify!(bustype)
+        )
+    );
+}
+impl Clone for mpc_bus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct mpc_ioapic {
+    pub type_: ::std::os::raw::c_uchar,
+    pub apicid: ::std::os::raw::c_uchar,
+    pub apicver: ::std::os::raw::c_uchar,
+    pub flags: ::std::os::raw::c_uchar,
+    pub apicaddr: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_mpc_ioapic() {
+    assert_eq!(
+        ::std::mem::size_of::<mpc_ioapic>(),
+        8usize,
+        concat!("Size of: ", stringify!(mpc_ioapic))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mpc_ioapic>(),
+        4usize,
+        concat!("Alignment of ", stringify!(mpc_ioapic))
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_ioapic)).type_ as *const _ as usize },
+        0usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_ioapic),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_ioapic)).apicid as *const _ as usize },
+        1usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_ioapic),
+            "::",
+            stringify!(apicid)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_ioapic)).apicver as *const _ as usize },
+        2usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_ioapic),
+            "::",
+            stringify!(apicver)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_ioapic)).flags as *const _ as usize },
+        3usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_ioapic),
+            "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_ioapic)).apicaddr as *const _ as usize },
+        4usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_ioapic),
+            "::",
+            stringify!(apicaddr)
+        )
+    );
+}
+impl Clone for mpc_ioapic {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct mpc_intsrc {
+    pub type_: ::std::os::raw::c_uchar,
+    pub irqtype: ::std::os::raw::c_uchar,
+    pub irqflag: ::std::os::raw::c_ushort,
+    pub srcbus: ::std::os::raw::c_uchar,
+    pub srcbusirq: ::std::os::raw::c_uchar,
+    pub dstapic: ::std::os::raw::c_uchar,
+    pub dstirq: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_mpc_intsrc() {
+    assert_eq!(
+        ::std::mem::size_of::<mpc_intsrc>(),
+        8usize,
+        concat!("Size of: ", stringify!(mpc_intsrc))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mpc_intsrc>(),
+        2usize,
+        concat!("Alignment of ", stringify!(mpc_intsrc))
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_intsrc)).type_ as *const _ as usize },
+        0usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_intsrc),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_intsrc)).irqtype as *const _ as usize },
+        1usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_intsrc),
+            "::",
+            stringify!(irqtype)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_intsrc)).irqflag as *const _ as usize },
+        2usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_intsrc),
+            "::",
+            stringify!(irqflag)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_intsrc)).srcbus as *const _ as usize },
+        4usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_intsrc),
+            "::",
+            stringify!(srcbus)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_intsrc)).srcbusirq as *const _ as usize },
+        5usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_intsrc),
+            "::",
+            stringify!(srcbusirq)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_intsrc)).dstapic as *const _ as usize },
+        6usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_intsrc),
+            "::",
+            stringify!(dstapic)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_intsrc)).dstirq as *const _ as usize },
+        7usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_intsrc),
+            "::",
+            stringify!(dstirq)
+        )
+    );
+}
+impl Clone for mpc_intsrc {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub const mp_irq_source_types_mp_INT: mp_irq_source_types = 0;
+pub const mp_irq_source_types_mp_NMI: mp_irq_source_types = 1;
+pub const mp_irq_source_types_mp_SMI: mp_irq_source_types = 2;
+pub const mp_irq_source_types_mp_ExtINT: mp_irq_source_types = 3;
+pub type mp_irq_source_types = ::std::os::raw::c_uint;
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct mpc_lintsrc {
+    pub type_: ::std::os::raw::c_uchar,
+    pub irqtype: ::std::os::raw::c_uchar,
+    pub irqflag: ::std::os::raw::c_ushort,
+    pub srcbusid: ::std::os::raw::c_uchar,
+    pub srcbusirq: ::std::os::raw::c_uchar,
+    pub destapic: ::std::os::raw::c_uchar,
+    pub destapiclint: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_mpc_lintsrc() {
+    assert_eq!(
+        ::std::mem::size_of::<mpc_lintsrc>(),
+        8usize,
+        concat!("Size of: ", stringify!(mpc_lintsrc))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mpc_lintsrc>(),
+        2usize,
+        concat!("Alignment of ", stringify!(mpc_lintsrc))
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_lintsrc)).type_ as *const _ as usize },
+        0usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_lintsrc),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_lintsrc)).irqtype as *const _ as usize },
+        1usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_lintsrc),
+            "::",
+            stringify!(irqtype)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_lintsrc)).irqflag as *const _ as usize },
+        2usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_lintsrc),
+            "::",
+            stringify!(irqflag)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_lintsrc)).srcbusid as *const _ as usize },
+        4usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_lintsrc),
+            "::",
+            stringify!(srcbusid)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_lintsrc)).srcbusirq as *const _ as usize },
+        5usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_lintsrc),
+            "::",
+            stringify!(srcbusirq)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_lintsrc)).destapic as *const _ as usize },
+        6usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_lintsrc),
+            "::",
+            stringify!(destapic)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_lintsrc)).destapiclint as *const _ as usize },
+        7usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_lintsrc),
+            "::",
+            stringify!(destapiclint)
+        )
+    );
+}
+impl Clone for mpc_lintsrc {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct mpc_oemtable {
+    pub signature: [::std::os::raw::c_char; 4usize],
+    pub length: ::std::os::raw::c_ushort,
+    pub rev: ::std::os::raw::c_char,
+    pub checksum: ::std::os::raw::c_char,
+    pub mpc: [::std::os::raw::c_char; 8usize],
+}
+#[test]
+fn bindgen_test_layout_mpc_oemtable() {
+    assert_eq!(
+        ::std::mem::size_of::<mpc_oemtable>(),
+        16usize,
+        concat!("Size of: ", stringify!(mpc_oemtable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mpc_oemtable>(),
+        2usize,
+        concat!("Alignment of ", stringify!(mpc_oemtable))
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_oemtable)).signature as *const _ as usize },
+        0usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_oemtable),
+            "::",
+            stringify!(signature)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_oemtable)).length as *const _ as usize },
+        4usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_oemtable),
+            "::",
+            stringify!(length)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_oemtable)).rev as *const _ as usize },
+        6usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_oemtable),
+            "::",
+            stringify!(rev)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_oemtable)).checksum as *const _ as usize },
+        7usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_oemtable),
+            "::",
+            stringify!(checksum)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(0 as *const mpc_oemtable)).mpc as *const _ as usize },
+        8usize,
+        concat!(
+            "Alignment of field: ",
+            stringify!(mpc_oemtable),
+            "::",
+            stringify!(mpc)
+        )
+    );
+}
+impl Clone for mpc_oemtable {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub const mp_bustype_MP_BUS_ISA: mp_bustype = 1;
+pub const mp_bustype_MP_BUS_EISA: mp_bustype = 2;
+pub const mp_bustype_MP_BUS_PCI: mp_bustype = 3;
+pub type mp_bustype = ::std::os::raw::c_uint;

block_util/Cargo.toml

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

block_util/src/async_io.rs

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

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: &[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: &[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 next_completed_request(&mut self) -> Option<(u64, i32)> {
-        self.raw_file_async.next_completed_request()
-    }
-}

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: &[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: &[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 next_completed_request(&mut self) -> Option<(u64, i32)> {
-        self.raw_file_sync.next_completed_request()
-    }
-}

block_util/src/lib.rs

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

block_util/src/qcow_sync.rs

@@ -1,104 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
-use crate::AsyncAdaptor;
-use qcow::{QcowFile, RawFile, Result as QcowResult};
-use std::collections::VecDeque;
-use std::fs::File;
-use std::io::{Seek, SeekFrom};
-use std::sync::{Arc, Mutex, MutexGuard};
-use vmm_sys_util::eventfd::EventFd;
-
-pub struct QcowDiskSync {
-    qcow_file: Arc<Mutex<QcowFile>>,
-}
-
-impl QcowDiskSync {
-    pub fn new(file: File, direct_io: bool) -> QcowResult<Self> {
-        Ok(QcowDiskSync {
-            qcow_file: Arc::new(Mutex::new(QcowFile::from(RawFile::new(file, direct_io))?)),
-        })
-    }
-}
-
-impl DiskFile for QcowDiskSync {
-    fn size(&mut self) -> DiskFileResult<u64> {
-        let mut file = self.qcow_file.lock().unwrap();
-
-        file.seek(SeekFrom::End(0)).map_err(DiskFileError::Size)
-    }
-
-    fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
-        Ok(Box::new(QcowSync::new(self.qcow_file.clone())) as Box<dyn AsyncIo>)
-    }
-}
-
-pub struct QcowSync {
-    qcow_file: Arc<Mutex<QcowFile>>,
-    eventfd: EventFd,
-    completion_list: VecDeque<(u64, i32)>,
-}
-
-impl QcowSync {
-    pub fn new(qcow_file: Arc<Mutex<QcowFile>>) -> Self {
-        QcowSync {
-            qcow_file,
-            eventfd: EventFd::new(libc::EFD_NONBLOCK)
-                .expect("Failed creating EventFd for QcowSync"),
-            completion_list: VecDeque::new(),
-        }
-    }
-}
-
-impl AsyncAdaptor<QcowFile> for Arc<Mutex<QcowFile>> {
-    fn file(&mut self) -> MutexGuard<QcowFile> {
-        self.lock().unwrap()
-    }
-}
-
-impl AsyncIo for QcowSync {
-    fn notifier(&self) -> &EventFd {
-        &self.eventfd
-    }
-
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        self.qcow_file.read_vectored_sync(
-            offset,
-            iovecs,
-            user_data,
-            &self.eventfd,
-            &mut self.completion_list,
-        )
-    }
-
-    fn write_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        self.qcow_file.write_vectored_sync(
-            offset,
-            iovecs,
-            user_data,
-            &self.eventfd,
-            &mut self.completion_list,
-        )
-    }
-
-    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
-        self.qcow_file
-            .fsync_sync(user_data, &self.eventfd, &mut self.completion_list)
-    }
-
-    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
-        self.completion_list.pop_front()
-    }
-}

block_util/src/raw_async.rs

@@ -1,164 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use crate::async_io::{
-    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult, DiskTopology,
-};
-use io_uring::{opcode, squeue, types, IoUring};
-use std::fs::File;
-use std::io::{Seek, SeekFrom};
-use std::os::unix::io::{AsRawFd, RawFd};
-use vmm_sys_util::eventfd::EventFd;
-
-pub struct RawFileDisk {
-    file: File,
-}
-
-impl RawFileDisk {
-    pub fn new(file: File) -> Self {
-        RawFileDisk { file }
-    }
-}
-
-impl DiskFile for RawFileDisk {
-    fn size(&mut self) -> DiskFileResult<u64> {
-        self.file
-            .seek(SeekFrom::End(0))
-            .map_err(DiskFileError::Size)
-    }
-
-    fn new_async_io(&self, ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
-        Ok(Box::new(
-            RawFileAsync::new(self.file.as_raw_fd(), ring_depth)
-                .map_err(DiskFileError::NewAsyncIo)?,
-        ) as Box<dyn AsyncIo>)
-    }
-
-    fn topology(&mut self) -> DiskTopology {
-        if let Ok(topology) = DiskTopology::probe(&mut self.file) {
-            topology
-        } else {
-            warn!("Unable to get device topology. Using default topology");
-            DiskTopology::default()
-        }
-    }
-}
-
-pub struct RawFileAsync {
-    fd: RawFd,
-    io_uring: IoUring,
-    eventfd: EventFd,
-}
-
-impl RawFileAsync {
-    pub fn new(fd: RawFd, ring_depth: u32) -> std::io::Result<Self> {
-        let io_uring = IoUring::new(ring_depth)?;
-        let eventfd = EventFd::new(libc::EFD_NONBLOCK)?;
-
-        // Register the io_uring eventfd that will notify when something in
-        // the completion queue is ready.
-        io_uring.submitter().register_eventfd(eventfd.as_raw_fd())?;
-
-        Ok(RawFileAsync {
-            fd,
-            io_uring,
-            eventfd,
-        })
-    }
-}
-
-impl AsyncIo for RawFileAsync {
-    fn notifier(&self) -> &EventFd {
-        &self.eventfd
-    }
-
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        let (submitter, mut sq, _) = self.io_uring.split();
-
-        // SAFETY: we know the file descriptor is valid and we
-        // relied on vm-memory to provide the buffer address.
-        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: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        let (submitter, mut sq, _) = self.io_uring.split();
-
-        // SAFETY: we know the file descriptor is valid and we
-        // relied on vm-memory to provide the buffer address.
-        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();
-
-            // SAFETY: 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 {
-            // SAFETY: FFI call with a valid fd
-            unsafe { libc::fsync(self.fd) };
-        }
-
-        Ok(())
-    }
-
-    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
-        self.io_uring
-            .completion()
-            .next()
-            .map(|entry| (entry.user_data(), entry.result()))
-    }
-}

block_util/src/raw_sync.rs

@@ -1,134 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use crate::async_io::{
-    AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult, DiskTopology,
-};
-use std::collections::VecDeque;
-use std::fs::File;
-use std::io::{Seek, SeekFrom};
-use std::os::unix::io::{AsRawFd, RawFd};
-use vmm_sys_util::eventfd::EventFd;
-
-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> {
-        self.file
-            .seek(SeekFrom::End(0))
-            .map_err(DiskFileError::Size)
-    }
-
-    fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
-        Ok(Box::new(RawFileSync::new(self.file.as_raw_fd())) as Box<dyn AsyncIo>)
-    }
-
-    fn topology(&mut self) -> DiskTopology {
-        if let Ok(topology) = DiskTopology::probe(&mut self.file) {
-            topology
-        } else {
-            warn!("Unable to get device topology. Using default topology");
-            DiskTopology::default()
-        }
-    }
-}
-
-pub struct RawFileSync {
-    fd: RawFd,
-    eventfd: EventFd,
-    completion_list: VecDeque<(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: VecDeque::new(),
-        }
-    }
-}
-
-impl AsyncIo for RawFileSync {
-    fn notifier(&self) -> &EventFd {
-        &self.eventfd
-    }
-
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        // SAFETY: FFI call with valid arguments
-        let result = unsafe {
-            libc::preadv(
-                self.fd as libc::c_int,
-                iovecs.as_ptr() as *const libc::iovec,
-                iovecs.len() as libc::c_int,
-                offset,
-            )
-        };
-        if result < 0 {
-            return Err(AsyncIoError::ReadVectored(std::io::Error::last_os_error()));
-        }
-
-        self.completion_list.push_back((user_data, result as i32));
-        self.eventfd.write(1).unwrap();
-
-        Ok(())
-    }
-
-    fn write_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        // SAFETY: FFI call with valid arguments
-        let result = unsafe {
-            libc::pwritev(
-                self.fd as libc::c_int,
-                iovecs.as_ptr() as *const libc::iovec,
-                iovecs.len() as libc::c_int,
-                offset,
-            )
-        };
-        if result < 0 {
-            return Err(AsyncIoError::WriteVectored(std::io::Error::last_os_error()));
-        }
-
-        self.completion_list.push_back((user_data, result as i32));
-        self.eventfd.write(1).unwrap();
-
-        Ok(())
-    }
-
-    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
-        // SAFETY: FFI call
-        let result = unsafe { libc::fsync(self.fd as libc::c_int) };
-        if result < 0 {
-            return Err(AsyncIoError::Fsync(std::io::Error::last_os_error()));
-        }
-
-        if let Some(user_data) = user_data {
-            self.completion_list.push_back((user_data, result));
-            self.eventfd.write(1).unwrap();
-        }
-
-        Ok(())
-    }
-
-    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
-        self.completion_list.pop_front()
-    }
-}

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()));
-        });
-    }
-}

block_util/src/vhdx_sync.rs

@@ -1,103 +0,0 @@
-// Copyright © 2021 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
-use crate::AsyncAdaptor;
-use std::collections::VecDeque;
-use std::fs::File;
-use std::sync::{Arc, Mutex, MutexGuard};
-use vhdx::vhdx::{Result as VhdxResult, Vhdx};
-use vmm_sys_util::eventfd::EventFd;
-
-pub struct VhdxDiskSync {
-    vhdx_file: Arc<Mutex<Vhdx>>,
-}
-
-impl VhdxDiskSync {
-    pub fn new(f: File) -> VhdxResult<Self> {
-        Ok(VhdxDiskSync {
-            vhdx_file: Arc::new(Mutex::new(Vhdx::new(f)?)),
-        })
-    }
-}
-
-impl DiskFile for VhdxDiskSync {
-    fn size(&mut self) -> DiskFileResult<u64> {
-        Ok(self.vhdx_file.lock().unwrap().virtual_disk_size())
-    }
-
-    fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
-        Ok(
-            Box::new(VhdxSync::new(self.vhdx_file.clone()).map_err(DiskFileError::NewAsyncIo)?)
-                as Box<dyn AsyncIo>,
-        )
-    }
-}
-
-pub struct VhdxSync {
-    vhdx_file: Arc<Mutex<Vhdx>>,
-    eventfd: EventFd,
-    completion_list: VecDeque<(u64, i32)>,
-}
-
-impl VhdxSync {
-    pub fn new(vhdx_file: Arc<Mutex<Vhdx>>) -> std::io::Result<Self> {
-        Ok(VhdxSync {
-            vhdx_file,
-            eventfd: EventFd::new(libc::EFD_NONBLOCK)?,
-            completion_list: VecDeque::new(),
-        })
-    }
-}
-
-impl AsyncAdaptor<Vhdx> for Arc<Mutex<Vhdx>> {
-    fn file(&mut self) -> MutexGuard<Vhdx> {
-        self.lock().unwrap()
-    }
-}
-
-impl AsyncIo for VhdxSync {
-    fn notifier(&self) -> &EventFd {
-        &self.eventfd
-    }
-
-    fn read_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        self.vhdx_file.read_vectored_sync(
-            offset,
-            iovecs,
-            user_data,
-            &self.eventfd,
-            &mut self.completion_list,
-        )
-    }
-
-    fn write_vectored(
-        &mut self,
-        offset: libc::off_t,
-        iovecs: &[libc::iovec],
-        user_data: u64,
-    ) -> AsyncIoResult<()> {
-        self.vhdx_file.write_vectored_sync(
-            offset,
-            iovecs,
-            user_data,
-            &self.eventfd,
-            &mut self.completion_list,
-        )
-    }
-
-    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
-        self.vhdx_file
-            .fsync_sync(user_data, &self.eventfd, &mut self.completion_list)
-    }
-
-    fn next_completed_request(&mut self) -> Option<(u64, i32)> {
-        self.completion_list.pop_front()
-    }
-}

build.rs

@@ -1,24 +0,0 @@
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-use std::process::Command;
-
-fn main() {
-    let mut version = "v".to_owned() + env!("CARGO_PKG_VERSION");
-
-    if let Ok(git_out) = Command::new("git").args(["describe", "--dirty"]).output() {
-        if git_out.status.success() {
-            if let Ok(git_out_str) = String::from_utf8(git_out.stdout) {
-                version = git_out_str;
-            }
-        }
-    }
-
-    // This println!() has a special behavior, as it will set the environment
-    // variable BUILD_VERSION, so that it can be reused from the binary.
-    // Particularly, this is used from src/main.rs to display the exact
-    // version.
-    println!("cargo:rustc-env=BUILD_VERSION={version}");
-}

devices/Cargo.toml

@@ -2,28 +2,21 @@
 name = "devices"
 version = "0.1.0"
 authors = ["The Chromium OS Authors"]
-edition = "2021"
 
 [dependencies]
-acpi_tables = { git = "https://github.com/rust-vmm/acpi_tables", branch = "main"  }
-anyhow = "1.0.70"
-arch = { path = "../arch" }
-bitflags = "1.3.2"
-byteorder = "1.4.3"
-hypervisor = { path = "../hypervisor" }
-libc = "0.2.139"
-log = "0.4.17"
-thiserror = "1.0.39"
-tpm = { path = "../tpm" }
-versionize = "0.1.10"
-versionize_derive = "0.1.4"
+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" }
-vm-memory = "0.10.0"
-vm-migration = { path = "../vm-migration" }
-vmm-sys-util = "0.11.0"
+vm-memory = { git = "https://github.com/rust-vmm/vm-memory" }
+vmm-sys-util = "0.4.0"
 
-[target.'cfg(target_arch = "aarch64")'.dependencies]
-arch = { path = "../arch" }
+[dev-dependencies]
+tempfile = "3.1.0"
 
 [features]
 default = []
+acpi = []
+cmos = []

devices/src/acpi.rs

@@ -3,16 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-use super::AcpiNotificationFlags;
-use acpi_tables::{aml, Aml, AmlSink};
-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;
-
-pub const GED_DEVICE_ACPI_SIZE: usize = 0x1;
+use BusDevice;
+use HotPlugNotificationFlags;
 
 /// A device for handling ACPI shutdown and reboot
 pub struct AcpiShutdownDevice {
@@ -34,12 +29,14 @@ impl AcpiShutdownDevice {
 impl BusDevice for AcpiShutdownDevice {
     // Spec has all fields as zero
     fn read(&mut self, _base: u64, _offset: u64, data: &mut [u8]) {
-        data.fill(0)
+        for i in data.iter_mut() {
+            *i = 0;
+        }
     }
 
-    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 {
-            info!("ACPI Reboot signalled");
+            debug!("ACPI Reboot signalled");
             if let Err(e) = self.reset_evt.write(1) {
                 error!("Error triggering ACPI reset event: {}", e);
             }
@@ -49,40 +46,34 @@ impl BusDevice for AcpiShutdownDevice {
         const SLEEP_STATUS_EN_BIT: u8 = 5;
         const SLEEP_VALUE_BIT: u8 = 2;
         if data[0] == (S5_SLEEP_VALUE << SLEEP_VALUE_BIT) | (1 << SLEEP_STATUS_EN_BIT) {
-            info!("ACPI Shutdown signalled");
+            debug!("ACPI Shutdown signalled");
+            extern crate bitflags;
             if let Err(e) = self.exit_evt.write(1) {
                 error!("Error triggering ACPI shutdown event: {}", e);
             }
         }
-        None
     }
 }
 
 /// A device for handling ACPI GED event generation
-pub struct AcpiGedDevice {
-    interrupt: Arc<dyn InterruptSourceGroup>,
-    notification_type: AcpiNotificationFlags,
+pub struct AcpiGEDDevice {
+    interrupt: Arc<Box<dyn InterruptSourceGroup>>,
+    notification_type: HotPlugNotificationFlags,
     ged_irq: u32,
-    address: GuestAddress,
 }
 
-impl AcpiGedDevice {
-    pub fn new(
-        interrupt: Arc<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)
@@ -94,138 +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;
-    }
-}
-
-impl Aml for AcpiGedDevice {
-    fn to_aml_bytes(&self, sink: &mut dyn AmlSink) {
-        aml::Device::new(
-            "_SB_.GEC_".into(),
-            vec![
-                &aml::Name::new("_HID".into(), &aml::EISAName::new("PNP0A06")),
-                &aml::Name::new("_UID".into(), &"Generic Event Controller"),
-                &aml::Name::new(
-                    "_CRS".into(),
-                    &aml::ResourceTemplate::new(vec![&aml::AddressSpace::new_memory(
-                        aml::AddressSpaceCachable::NotCacheable,
-                        true,
-                        self.address.0,
-                        self.address.0 + GED_DEVICE_ACPI_SIZE as u64 - 1,
-                    )]),
-                ),
-                &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::FieldLockRule::NoLock,
-                    aml::FieldUpdateRule::WriteAsZeroes,
-                    vec![aml::FieldEntry::Named(*b"GDAT", 8)],
-                ),
-                &aml::Method::new(
-                    "ESCN".into(),
-                    0,
-                    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_.PHPR.PSCN".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(sink);
-        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::Method::new(
-                    "_EVT".into(),
-                    1,
-                    true,
-                    vec![&aml::MethodCall::new("\\_SB_.GEC_.ESCN".into(), vec![])],
-                ),
-            ],
-        )
-        .to_aml_bytes(sink)
-    }
-}
-
-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]) {
-        if data.len() != std::mem::size_of::<u32>() {
-            warn!("Invalid sized read of PM timer: {}", data.len());
-            return;
-        }
-        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

@@ -7,9 +7,9 @@
 
 //! Handles routing to devices in an address space.
 
-use std::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
+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)]
@@ -40,7 +40,7 @@ pub type Result<T> = result::Result<T, Error>;
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "bus_error: {self:?}")
+        write!(f, "bus_error: {:?}", self)
     }
 }
 
@@ -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 {
@@ -110,8 +110,9 @@ impl Bus {
         let devices = self.devices.read().unwrap();
         let (range, dev) = devices
             .range(..=BusRange { base: addr, len: 1 })
-            .next_back()?;
-        dev.upgrade().map(|d| (*range, d.clone()))
+            .rev()
+            .next()?;
+        Some((*range, dev.clone()))
     }
 
     #[allow(clippy::type_complexity)]
@@ -146,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);
@@ -170,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,
@@ -213,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
         }
     }
 }
@@ -256,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
         }
     }
 
@@ -274,7 +255,7 @@ mod tests {
 
         let result = bus.insert(dummy.clone(), 0x0f, 0x10);
         assert!(result.is_err());
-        assert_eq!(format!("{result:?}"), "Err(Overlap)");
+        assert_eq!(format!("{:?}", result), "Err(Overlap)");
 
         assert!(bus.insert(dummy.clone(), 0x10, 0x10).is_err());
         assert!(bus.insert(dummy.clone(), 0x10, 0x15).is_err());
@@ -283,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 });
@@ -334,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,175 +0,0 @@
-// Copyright 2020, ARM Limited.
-//
-// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
-
-use super::interrupt_controller::{Error, InterruptController};
-extern crate arch;
-use anyhow::anyhow;
-use arch::layout;
-use hypervisor::{
-    arch::aarch64::gic::{Vgic, VgicConfig},
-    CpuState, GicState,
-};
-use std::result;
-use std::sync::{Arc, Mutex};
-use vm_device::interrupt::{
-    InterruptIndex, InterruptManager, InterruptSourceConfig, InterruptSourceGroup,
-    LegacyIrqSourceConfig, MsiIrqGroupConfig,
-};
-use vm_memory::address::Address;
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-use vmm_sys_util::eventfd::EventFd;
-
-type Result<T> = result::Result<T, Error>;
-
-// Reserve 32 IRQs for legacy devices.
-pub const IRQ_LEGACY_BASE: usize = layout::IRQ_BASE as usize;
-pub const IRQ_LEGACY_COUNT: usize = 32;
-pub const GIC_SNAPSHOT_ID: &str = "gic-v3-its";
-
-// Gic (Generic Interupt Controller) struct provides all the functionality of a
-// GIC device. It wraps a hypervisor-emulated GIC device (Vgic) provided by the
-// `hypervisor` crate.
-// Gic struct also implements InterruptController to provide interrupt delivery
-// service.
-pub struct Gic {
-    interrupt_source_group: Arc<dyn InterruptSourceGroup>,
-    // The hypervisor agnostic virtual GIC
-    vgic: Option<Arc<Mutex<dyn Vgic>>>,
-}
-
-impl Gic {
-    pub fn new(
-        vcpu_count: u8,
-        interrupt_manager: Arc<dyn InterruptManager<GroupConfig = MsiIrqGroupConfig>>,
-        vm: Arc<dyn hypervisor::Vm>,
-    ) -> Result<Gic> {
-        let interrupt_source_group = interrupt_manager
-            .create_group(MsiIrqGroupConfig {
-                base: IRQ_LEGACY_BASE as InterruptIndex,
-                count: IRQ_LEGACY_COUNT as InterruptIndex,
-            })
-            .map_err(Error::CreateInterruptSourceGroup)?;
-
-        let vgic = vm
-            .create_vgic(Gic::create_default_config(vcpu_count as u64))
-            .map_err(Error::CreateGic)?;
-
-        let gic = Gic {
-            interrupt_source_group,
-            vgic: Some(vgic),
-        };
-        gic.enable()?;
-
-        Ok(gic)
-    }
-
-    pub fn restore_vgic(
-        &mut self,
-        state: Option<GicState>,
-        saved_vcpu_states: &[CpuState],
-    ) -> Result<()> {
-        self.set_gicr_typers(saved_vcpu_states);
-        self.vgic
-            .clone()
-            .unwrap()
-            .lock()
-            .unwrap()
-            .set_state(&state.unwrap())
-            .map_err(Error::RestoreGic)
-    }
-
-    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 - IRQ_LEGACY_BASE) as u32,
-            };
-            self.interrupt_source_group
-                .update(
-                    i as InterruptIndex,
-                    InterruptSourceConfig::LegacyIrq(config),
-                    false,
-                )
-                .map_err(Error::EnableInterrupt)?;
-        }
-        Ok(())
-    }
-
-    /// Default config implied by arch::layout
-    pub fn create_default_config(vcpu_count: u64) -> VgicConfig {
-        let redists_size = layout::GIC_V3_REDIST_SIZE * vcpu_count;
-        let redists_addr = layout::GIC_V3_DIST_START.raw_value() - redists_size;
-        VgicConfig {
-            vcpu_count,
-            dist_addr: layout::GIC_V3_DIST_START.raw_value(),
-            dist_size: layout::GIC_V3_DIST_SIZE,
-            redists_addr,
-            redists_size,
-            msi_addr: redists_addr - layout::GIC_V3_ITS_SIZE,
-            msi_size: layout::GIC_V3_ITS_SIZE,
-            nr_irqs: layout::IRQ_NUM,
-        }
-    }
-
-    pub fn get_vgic(&mut self) -> Result<Arc<Mutex<dyn Vgic>>> {
-        Ok(self.vgic.clone().unwrap())
-    }
-
-    pub fn set_gicr_typers(&mut self, vcpu_states: &[CpuState]) {
-        let vgic = self.vgic.as_ref().unwrap().clone();
-        vgic.lock().unwrap().set_gicr_typers(vcpu_states);
-    }
-}
-
-impl InterruptController for Gic {
-    // This should be called anytime an interrupt needs to be injected into the
-    // running guest.
-    fn service_irq(&mut self, irq: usize) -> Result<()> {
-        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)
-    }
-}
-
-impl Snapshottable for Gic {
-    fn id(&self) -> String {
-        GIC_SNAPSHOT_ID.to_string()
-    }
-
-    fn snapshot(&mut self) -> std::result::Result<Snapshot, MigratableError> {
-        let vgic = self.vgic.as_ref().unwrap().clone();
-        let state = vgic.lock().unwrap().state().unwrap();
-        Snapshot::new_from_state(&state)
-    }
-}
-
-impl Pausable for Gic {
-    fn pause(&mut self) -> std::result::Result<(), MigratableError> {
-        // Flush tables to guest RAM
-        let vgic = self.vgic.as_ref().unwrap().clone();
-        vgic.lock().unwrap().save_data_tables().map_err(|e| {
-            MigratableError::Pause(anyhow!(
-                "Could not save GICv3ITS GIC pending tables {:?}",
-                e
-            ))
-        })?;
-        Ok(())
-    }
-}
-impl Transportable for Gic {}
-impl Migratable for Gic {}

devices/src/interrupt_controller.rs

@@ -1,65 +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),
-    #[cfg(target_arch = "aarch64")]
-    /// Failed creating GIC device.
-    CreateGic(hypervisor::HypervisorVmError),
-    #[cfg(target_arch = "aarch64")]
-    /// Failed restoring GIC device.
-    RestoreGic(hypervisor::arch::aarch64::gic::Error),
-}
-
-type Result<T> = result::Result<T, Error>;
-
-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 = "x86_64")]
-    fn end_of_interrupt(&mut self, vec: u8);
-    fn notifier(&self, irq: usize) -> Option<EventFd>;
-}

devices/src/ioapic.rs

@@ -9,22 +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 crate::BusDevice;
 use byteorder::{ByteOrder, LittleEndian};
+use std::io;
 use std::result;
-use std::sync::{Arc, Barrier};
-use versionize::{VersionMap, Versionize, VersionizeResult};
-use versionize_derive::Versionize;
+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, VersionMapped,
-};
-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>;
 
@@ -64,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) {
@@ -85,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;
 
@@ -99,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,
@@ -109,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,
@@ -127,31 +166,16 @@ 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<dyn InterruptSourceGroup>,
+    interrupt_source_group: Arc<Box<dyn InterruptSourceGroup>>,
 }
 
-#[derive(Versionize)]
-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 VersionMapped for IoapicState {}
-
 impl BusDevice for Ioapic {
     fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
-        if data.len() != std::mem::size_of::<u32>() {
-            warn!("Invalid read size on IOAPIC: {}", data.len());
-            return;
-        }
+        assert!(data.len() == 4);
 
         debug!("IOAPIC_R @ offset 0x{:x}", offset);
 
@@ -167,11 +191,8 @@ impl BusDevice for Ioapic {
         LittleEndian::write_u32(data, value);
     }
 
-    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
-        if data.len() != std::mem::size_of::<u32>() {
-            warn!("Invalid write size on IOAPIC: {}", data.len());
-            return None;
-        }
+    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) {
+        assert!(data.len() == 4);
 
         debug!("IOAPIC_W @ offset 0x{:x}", offset);
 
@@ -184,149 +205,65 @@ 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>>,
-        state: Option<IoapicState>,
     ) -> 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)?;
 
-        let (id_reg, reg_sel, reg_entries, used_entries, apic_address) = if let Some(state) = &state
-        {
-            (
-                state.id_reg,
-                state.reg_sel,
-                state.reg_entries,
-                state.used_entries,
-                GuestAddress(state.apic_address),
-            )
-        } else {
-            (
-                0,
-                0,
-                [0x10000; NUM_IOAPIC_PINS],
-                [false; NUM_IOAPIC_PINS],
-                apic_address,
-            )
-        };
+        interrupt_source_group
+            .enable()
+            .map_err(Error::EnableInterrupt)?;
 
-        // The IOAPIC is created with entries already masked. The guest will be
-        // in charge of unmasking them if/when necessary.
-        let ioapic = Ioapic {
-            id,
-            id_reg,
-            reg_sel,
-            reg_entries,
-            used_entries,
+        Ok(Ioapic {
+            id: 0,
+            reg_sel: 0,
+            reg_entries: [0; NUM_IOAPIC_PINS],
             apic_address,
             interrupt_source_group,
-        };
-
-        // When restoring the Ioapic, we must enable used entries.
-        if state.is_some() {
-            for (irq, entry) in ioapic.used_entries.iter().enumerate() {
-                if *entry {
-                    ioapic.update_entry(irq)?;
-                }
-            }
-        }
-
-        Ok(ioapic)
+        })
     }
 
-    fn ioapic_write(&mut self, val: u32) {
-        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 index > NUM_IOAPIC_PINS {
-                    warn!("IOAPIC index out of range: {}", index);
-                    return;
-                }
-                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 index > NUM_IOAPIC_PINS {
-                    warn!("IOAPIC index out of range: {}", index);
-                    return 0;
-                }
-                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];
+
+        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 update_entry(&self, irq: usize) -> Result<()> {
@@ -334,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
@@ -359,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) => {}
@@ -378,70 +319,70 @@ impl Ioapic {
             high_addr: 0x0,
             low_addr,
             data,
-            devid: 0,
         };
 
         self.interrupt_source_group
-            .update(
-                irq as InterruptIndex,
-                InterruptSourceConfig::MsiIrq(config),
-                interrupt_mask(entry) == 1,
-            )
+            .update(irq as InterruptIndex, InterruptSourceConfig::MsiIrq(config))
             .map_err(Error::UpdateInterrupt)?;
 
+        if interrupt_mask(entry) == 1 {
+            self.interrupt_source_group
+                .mask(irq as InterruptIndex)
+                .map_err(Error::MaskInterrupt)?;
+        } else {
+            self.interrupt_source_group
+                .unmask(irq as InterruptIndex)
+                .map_err(Error::UnmaskInterrupt)?;
+        }
+
         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_versioned_state(&self.state())
-    }
-}
-
-impl Pausable for Ioapic {}
-impl Transportable for Ioapic {}
-impl Migratable for Ioapic {}

devices/src/legacy/cmos.rs

@@ -2,16 +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, 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 vmm_sys_util::eventfd::EventFd;
 
-// https://github.com/rust-lang/libc/issues/1848
-#[cfg_attr(target_env = "musl", allow(deprecated))]
-use libc::time_t;
+use crate::BusDevice;
 
 const INDEX_MASK: u8 = 0x7f;
 const INDEX_OFFSET: u64 = 0x0;
@@ -22,14 +17,13 @@ const DATA_LEN: usize = 128;
 pub struct Cmos {
     index: u8,
     data: [u8; DATA_LEN],
-    reset_evt: EventFd,
 }
 
 impl Cmos {
     /// Constructs a CMOS/RTC device with initial data.
     /// `mem_below_4g` is the size of memory in bytes below the 32-bit gap.
     /// `mem_above_4g` is the size of memory in bytes above the 32-bit gap.
-    pub fn new(mem_below_4g: u64, mem_above_4g: u64, reset_evt: EventFd) -> Cmos {
+    pub fn new(mem_below_4g: u64, mem_above_4g: u64) -> Cmos {
         let mut data = [0u8; DATA_LEN];
 
         // Extended memory from 16 MB to 4 GB in units of 64 KB
@@ -46,34 +40,21 @@ impl Cmos {
         data[0x5c] = (high_mem >> 8) as u8;
         data[0x5d] = (high_mem >> 16) as u8;
 
-        Cmos {
-            index: 0,
-            data,
-            reset_evt,
-        }
+        Cmos { index: 0, data }
     }
 }
 
 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 {
-            warn!("Invalid write size on CMOS device: {}", data.len());
-            return None;
+            return;
         }
 
         match offset {
-            INDEX_OFFSET => self.index = data[0],
-            DATA_OFFSET => {
-                if self.index == 0x8f && data[0] == 0 {
-                    info!("CMOS reset");
-                    self.reset_evt.write(1).unwrap();
-                } else {
-                    self.data[(self.index & INDEX_MASK) as usize] = data[0]
-                }
-            }
-            o => warn!("bad write offset on CMOS device: {}", o),
-        };
-        None
+            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),
+        }
     }
 
     fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
@@ -83,7 +64,6 @@ impl BusDevice for Cmos {
         }
 
         if data.len() != 1 {
-            warn!("Invalid read size on CMOS device: {}", data.len());
             return;
         }
 
@@ -97,19 +77,14 @@ impl BusDevice for Cmos {
                 let day;
                 let month;
                 let year;
-                // SAFETY: The clock_gettime and gmtime_r calls are safe as long as the structs they are
-                // given are large enough, and neither of them fail. It is safe to zero initialize
-                // the tm and timespec struct because it contains only plain data.
-                let update_in_progress = unsafe {
-                    let mut timespec: timespec = mem::zeroed();
-                    clock_gettime(CLOCK_REALTIME, &mut timespec as *mut _);
-
-                    // https://github.com/rust-lang/libc/issues/1848
-                    #[cfg_attr(target_env = "musl", allow(deprecated))]
-                    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;
@@ -118,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),
@@ -132,11 +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,
-                    // Bit 0-6 are reserved and must be 0.
-                    // Bit 7 must be 1 (CMOS has power)
-                    0x0d => 1 << 7,
                     0x32 => to_bcd(((year + 1900) / 100) as u8),
                     _ => {
                         // self.index is always guaranteed to be in range via INDEX_MASK.
@@ -144,10 +109,7 @@ impl BusDevice for Cmos {
                     }
                 }
             }
-            o => {
-                warn!("bad read offset on CMOS device: {}", o);
-                0
-            }
+            o => panic!("bad read offset on CMOS device: {}", o),
         }
     }
 }

devices/src/legacy/debug_port.rs

@@ -1,86 +0,0 @@
-// Copyright © 2022 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-use std::fmt;
-use std::time::Instant;
-use vm_device::BusDevice;
-
-/// Debug I/O port, see:
-/// https://www.intel.com/content/www/us/en/support/articles/000005500/boards-and-kits.html
-///
-/// Since we're not a physical platform, we can freely assign code ranges for
-/// debugging specific parts of our virtual platform.
-pub enum DebugIoPortRange {
-    Firmware,
-    Bootloader,
-    Kernel,
-    Userspace,
-    Custom,
-}
-
-#[cfg(target_arch = "x86_64")]
-const DEBUG_IOPORT_PREFIX: &str = "Debug I/O port";
-
-#[cfg(target_arch = "x86_64")]
-impl DebugIoPortRange {
-    fn from_u8(value: u8) -> DebugIoPortRange {
-        match value {
-            0x00..=0x1f => DebugIoPortRange::Firmware,
-            0x20..=0x3f => DebugIoPortRange::Bootloader,
-            0x40..=0x5f => DebugIoPortRange::Kernel,
-            0x60..=0x7f => DebugIoPortRange::Userspace,
-            _ => DebugIoPortRange::Custom,
-        }
-    }
-}
-
-#[cfg(target_arch = "x86_64")]
-impl fmt::Display for DebugIoPortRange {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            DebugIoPortRange::Firmware => write!(f, "{DEBUG_IOPORT_PREFIX}: Firmware"),
-            DebugIoPortRange::Bootloader => write!(f, "{DEBUG_IOPORT_PREFIX}: Bootloader"),
-            DebugIoPortRange::Kernel => write!(f, "{DEBUG_IOPORT_PREFIX}: Kernel"),
-            DebugIoPortRange::Userspace => write!(f, "{DEBUG_IOPORT_PREFIX}: Userspace"),
-            DebugIoPortRange::Custom => write!(f, "{DEBUG_IOPORT_PREFIX}: Custom"),
-        }
-    }
-}
-
-pub struct DebugPort {
-    timestamp: Instant,
-}
-
-impl DebugPort {
-    pub fn new(timestamp: Instant) -> Self {
-        Self { timestamp }
-    }
-}
-
-impl BusDevice for DebugPort {
-    fn read(&mut self, _base: u64, _offset: u64, _data: &mut [u8]) {
-        error!("Invalid read to debug port")
-    }
-
-    fn write(
-        &mut self,
-        _base: u64,
-        _offset: u64,
-        data: &[u8],
-    ) -> Option<std::sync::Arc<std::sync::Barrier>> {
-        let elapsed = self.timestamp.elapsed();
-
-        let code = data[0];
-        warn!(
-            "[{} code 0x{:x}] {}.{:>06} seconds",
-            DebugIoPortRange::from_u8(code),
-            code,
-            elapsed.as_secs(),
-            elapsed.as_micros()
-        );
-
-        None
-    }
-}

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,466 +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 versionize::{VersionMap, Versionize, VersionizeResult};
-use versionize_derive::Versionize;
-use vm_device::interrupt::InterruptSourceGroup;
-use vm_device::BusDevice;
-use vm_migration::{
-    Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable, VersionMapped,
-};
-
-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<dyn InterruptSourceGroup>,
-}
-
-#[derive(Versionize)]
-pub struct GpioState {
-    data: u32,
-    old_in_data: u32,
-    dir: u32,
-    isense: u32,
-    ibe: u32,
-    iev: u32,
-    im: u32,
-    istate: u32,
-    afsel: u32,
-}
-
-impl VersionMapped for GpioState {}
-
-impl Gpio {
-    /// Constructs an PL061 GPIO device.
-    pub fn new(
-        id: String,
-        interrupt: Arc<dyn InterruptSourceGroup>,
-        state: Option<GpioState>,
-    ) -> Self {
-        let (data, old_in_data, dir, isense, ibe, iev, im, istate, afsel) =
-            if let Some(state) = state {
-                (
-                    state.data,
-                    state.old_in_data,
-                    state.dir,
-                    state.isense,
-                    state.ibe,
-                    state.iev,
-                    state.im,
-                    state.istate,
-                    state.afsel,
-                )
-            } else {
-                (0, 0, 0, 0, 0, 0, 0, 0, 0)
-            };
-
-        Self {
-            id,
-            data,
-            old_in_data,
-            dir,
-            isense,
-            ibe,
-            iev,
-            im,
-            istate,
-            afsel,
-            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 pl061_internal_update(&mut self) {
-        // FIXME:
-        //  Missing Output Interrupt Emulation.
-
-        // Input Edging Interrupt Emulation.
-        let changed = (self.old_in_data ^ self.data) & !self.dir;
-        if changed > 0 {
-            self.old_in_data = self.data;
-            for i in 0..N_GPIOS {
-                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_versioned_state(&self.state())
-    }
-}
-
-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,
-            _masked: bool,
-        ) -> 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(TestInterrupt::new(intr_evt.try_clone().unwrap())),
-            None,
-        );
-        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, &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_u64;
-        gpio.write(LEGACY_GPIO_MAPPED_IO_START, offset, &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, &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, &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, &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, &data);
-        gpio.read(LEGACY_GPIO_MAPPED_IO_START, GPIOIE, &mut data);
-        let v = read_le_u32(&data);
-        assert_eq!(v, 7);
-
-        let mask = 0x00000002_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, &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, &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 {
-            info!("i8042 reset signalled");
+            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

@@ -5,33 +5,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
+#[cfg(feature = "cmos")]
 mod cmos;
-#[cfg(target_arch = "x86_64")]
-mod debug_port;
-#[cfg(target_arch = "x86_64")]
-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(target_arch = "x86_64")]
-pub use self::debug_port::DebugPort;
-#[cfg(target_arch = "x86_64")]
-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,565 +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`.
-    Real,
-    /// Equivalent to `libc::CLOCK_PROCESS_CPUTIME_ID`.
-    ProcessCpu,
-    /// Equivalent to `libc::CLOCK_THREAD_CPUTIME_ID`.
-    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.
-    #[cfg(test)]
-    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(),
-        };
-
-        // SAFETY: 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 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,
-    };
-    // SAFETY: the parameters are valid.
-    unsafe { libc::clock_gettime(clock_type.into(), &mut time_struct) };
-    seconds_to_nanoseconds(time_struct.tv_sec).unwrap() as u64 + (time_struct.tv_nsec as u64)
-}
-
-/// 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<dyn InterruptSourceGroup>,
-}
-
-impl Rtc {
-    /// Constructs an AMBA PL031 RTC device.
-    pub fn new(interrupt: Arc<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 mut read_ok = true;
-
-        let v = if (AMBA_ID_LOW..AMBA_ID_HIGH).contains(&offset) {
-            let index = ((offset - AMBA_ID_LOW) >> 2) as usize;
-            u32::from(PL031_ID[index])
-        } else {
-            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,
-            _masked: bool,
-        ) -> 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(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, &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, &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, &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, &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, &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, &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, &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() {
-                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,16 +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 versionize::{VersionMap, Versionize, VersionizeResult};
-use versionize_derive::Versionize;
 use vm_device::interrupt::InterruptSourceGroup;
-use vm_device::BusDevice;
-use vm_migration::{
-    Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable, VersionMapped,
-};
 use vmm_sys_util::errno::Result;
 
 const LOOP_SIZE: usize = 0x40;
@@ -60,9 +55,9 @@ 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>>,
     line_control: u8,
     line_status: u8,
     modem_control: u8,
@@ -70,104 +65,40 @@ pub struct Serial {
     scratch: u8,
     baud_divisor: u16,
     in_buffer: VecDeque<u8>,
-    interrupt: Arc<dyn InterruptSourceGroup>,
     out: Option<Box<dyn io::Write + Send>>,
 }
 
-#[derive(Versionize)]
-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 VersionMapped for SerialState {}
-
 impl Serial {
     pub fn new(
-        id: String,
-        interrupt: Arc<dyn InterruptSourceGroup>,
+        interrupt: Arc<Box<dyn InterruptSourceGroup>>,
         out: Option<Box<dyn io::Write + Send>>,
-        state: Option<SerialState>,
     ) -> Serial {
-        let (
-            interrupt_enable,
-            interrupt_identification,
-            line_control,
-            line_status,
-            modem_control,
-            modem_status,
-            scratch,
-            baud_divisor,
-            in_buffer,
-        ) = if let Some(state) = state {
-            (
-                state.interrupt_enable,
-                state.interrupt_identification,
-                state.line_control,
-                state.line_status,
-                state.modem_control,
-                state.modem_status,
-                state.scratch,
-                state.baud_divisor,
-                state.in_buffer.into(),
-            )
-        } else {
-            (
-                0,
-                DEFAULT_INTERRUPT_IDENTIFICATION,
-                DEFAULT_LINE_CONTROL,
-                DEFAULT_LINE_STATUS,
-                DEFAULT_MODEM_CONTROL,
-                DEFAULT_MODEM_STATUS,
-                0,
-                DEFAULT_BAUD_DIVISOR,
-                VecDeque::new(),
-            )
-        };
-
         Serial {
-            id,
-            interrupt_enable,
-            interrupt_identification,
-            line_control,
-            line_status,
-            modem_control,
-            modem_status,
-            scratch,
-            baud_divisor,
-            in_buffer,
+            interrupt_enable: 0,
+            interrupt_identification: DEFAULT_INTERRUPT_IDENTIFICATION,
             interrupt,
+            line_control: DEFAULT_LINE_CONTROL,
+            line_status: DEFAULT_LINE_STATUS,
+            modem_control: DEFAULT_MODEM_CONTROL,
+            modem_status: DEFAULT_MODEM_STATUS,
+            scratch: 0,
+            baud_divisor: DEFAULT_BAUD_DIVISOR,
+            in_buffer: VecDeque::new(),
             out,
         }
     }
 
     /// Constructs a Serial port ready for output.
     pub fn new_out(
-        id: String,
-        interrupt: Arc<dyn InterruptSourceGroup>,
+        interrupt: Arc<Box<dyn InterruptSourceGroup>>,
         out: Box<dyn io::Write + Send>,
-        state: Option<SerialState>,
     ) -> Serial {
-        Self::new(id, interrupt, Some(out), state)
+        Self::new(interrupt, Some(out))
     }
 
     /// Constructs a Serial port with no connected output.
-    pub fn new_sink(
-        id: String,
-        interrupt: Arc<dyn InterruptSourceGroup>,
-        state: Option<SerialState>,
-    ) -> Serial {
-        Self::new(id, interrupt, None, state)
-    }
-
-    pub fn set_out(&mut self, out: Box<dyn io::Write + Send>) {
-        self.out = Some(out);
+    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
@@ -180,13 +111,6 @@ impl Serial {
         Ok(())
     }
 
-    pub fn flush_output(&mut self) -> result::Result<(), io::Error> {
-        if let Some(out) = self.out.as_mut() {
-            out.flush()?;
-        }
-        Ok(())
-    }
-
     fn is_dlab_set(&self) -> bool {
         (self.line_control & LCR_DLAB_BIT) != 0
     }
@@ -241,7 +165,7 @@ impl Serial {
     }
 
     fn handle_write(&mut self, offset: u8, v: u8) -> Result<()> {
-        match offset {
+        match offset as u8 {
             DLAB_LOW if self.is_dlab_set() => {
                 self.baud_divisor = (self.baud_divisor & 0xff00) | u16::from(v)
             }
@@ -270,20 +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(),
-        }
-    }
 }
 
 impl BusDevice for Serial {
@@ -317,31 +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_versioned_state(&self.state())
-    }
-}
-
-impl Pausable for Serial {}
-impl Transportable for Serial {}
-impl Migratable for Serial {}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -350,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,
     }
@@ -364,13 +256,9 @@ mod tests {
             &self,
             _index: InterruptIndex,
             _config: InterruptSourceConfig,
-            _masked: bool,
         ) -> result::Result<(), std::io::Error> {
             Ok(())
         }
-        fn notifier(&self, _index: InterruptIndex) -> Option<EventFd> {
-            Some(self.event_fd.try_clone().unwrap())
-        }
     }
 
     impl TestInterrupt {
@@ -406,19 +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(TestInterrupt::new(intr_evt.try_clone().unwrap())),
+            Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
             Box::new(serial_out.clone()),
-            None,
         );
 
-        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]
         );
     }
 
@@ -427,17 +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(TestInterrupt::new(intr_evt.try_clone().unwrap())),
-            Box::new(serial_out),
-            None,
+            Arc::new(Box::new(TestInterrupt::new(intr_evt.try_clone().unwrap()))),
+            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);
 
@@ -450,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[..]);
@@ -464,17 +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(TestInterrupt::new(intr_evt.try_clone().unwrap())),
-            None,
-        );
+        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];
@@ -487,19 +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(TestInterrupt::new(intr_evt.try_clone().unwrap())),
-            None,
-        );
+        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[..]);
@@ -509,43 +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(TestInterrupt::new(intr_evt.try_clone().unwrap())),
-            None,
-        );
+        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(TestInterrupt::new(intr_evt.try_clone().unwrap())),
-            None,
-        );
+        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,573 +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::time::Instant;
-use std::{io, result};
-use versionize::{VersionMap, Versionize, VersionizeResult};
-use versionize_derive::Versionize;
-use vm_device::interrupt::InterruptSourceGroup;
-use vm_device::BusDevice;
-use vm_migration::{
-    Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable, VersionMapped,
-};
-
-/* 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 UARTDEBUG: u64 = 0x3c0;
-
-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,
-    debug: 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<dyn InterruptSourceGroup>,
-    out: Option<Box<dyn io::Write + Send>>,
-    timestamp: std::time::Instant,
-}
-
-#[derive(Versionize)]
-pub struct Pl011State {
-    flags: u32,
-    lcr: u32,
-    rsr: u32,
-    cr: u32,
-    dmacr: u32,
-    debug: 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 VersionMapped for Pl011State {}
-
-impl Pl011 {
-    /// Constructs an AMBA PL011 UART device.
-    pub fn new(
-        id: String,
-        irq: Arc<dyn InterruptSourceGroup>,
-        out: Option<Box<dyn io::Write + Send>>,
-        timestamp: Instant,
-        state: Option<Pl011State>,
-    ) -> Self {
-        let (
-            flags,
-            lcr,
-            rsr,
-            cr,
-            dmacr,
-            debug,
-            int_enabled,
-            int_level,
-            read_fifo,
-            ilpr,
-            ibrd,
-            fbrd,
-            ifl,
-            read_count,
-            read_trigger,
-        ) = if let Some(state) = state {
-            (
-                state.flags,
-                state.lcr,
-                state.rsr,
-                state.cr,
-                state.dmacr,
-                state.debug,
-                state.int_enabled,
-                state.int_level,
-                state.read_fifo.into(),
-                state.ilpr,
-                state.ibrd,
-                state.fbrd,
-                state.ifl,
-                state.read_count,
-                state.read_trigger,
-            )
-        } else {
-            (
-                0x90,
-                0,
-                0,
-                0x300,
-                0,
-                0,
-                0,
-                0,
-                VecDeque::new(),
-                0,
-                0,
-                0,
-                0x12,
-                0,
-                1,
-            )
-        };
-
-        Self {
-            id,
-            flags,
-            lcr,
-            rsr,
-            cr,
-            dmacr,
-            debug,
-            int_enabled,
-            int_level,
-            read_fifo,
-            ilpr,
-            ibrd,
-            fbrd,
-            ifl,
-            read_count,
-            read_trigger,
-            irq,
-            out,
-            timestamp,
-        }
-    }
-
-    pub fn set_out(&mut self, out: Box<dyn io::Write + Send>) {
-        self.out = Some(out);
-    }
-
-    fn state(&self) -> Pl011State {
-        Pl011State {
-            flags: self.flags,
-            lcr: self.lcr,
-            rsr: self.rsr,
-            cr: self.cr,
-            dmacr: self.dmacr,
-            debug: self.debug,
-            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,
-        }
-    }
-
-    /// 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(())
-    }
-
-    pub fn flush_output(&mut self) -> result::Result<(), io::Error> {
-        if let Some(out) = self.out.as_mut() {
-            out.flush()?;
-        }
-        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);
-                }
-            }
-            UARTDEBUG => {
-                self.debug = val;
-                self.handle_debug();
-            }
-            off => {
-                debug!("PL011: Bad write offset, offset: {}", off);
-                return Err(Error::BadWriteOffset(off));
-            }
-        }
-        Ok(())
-    }
-
-    fn handle_debug(&self) {
-        let elapsed = self.timestamp.elapsed();
-
-        match self.debug {
-            0x00..=0x1f => warn!(
-                "[Debug I/O port: Firmware code: 0x{:x}] {}.{:>06} seconds",
-                self.debug,
-                elapsed.as_secs(),
-                elapsed.as_micros()
-            ),
-            0x20..=0x3f => warn!(
-                "[Debug I/O port: Bootloader code: 0x{:x}] {}.{:>06} seconds",
-                self.debug,
-                elapsed.as_secs(),
-                elapsed.as_micros()
-            ),
-            0x40..=0x5f => warn!(
-                "[Debug I/O port: Kernel code: 0x{:x}] {}.{:>06} seconds",
-                self.debug,
-                elapsed.as_secs(),
-                elapsed.as_micros()
-            ),
-            0x60..=0x7f => warn!(
-                "[Debug I/O port: Userspace code: 0x{:x}] {}.{:>06} seconds",
-                self.debug,
-                elapsed.as_secs(),
-                elapsed.as_micros()
-            ),
-            _ => {}
-        }
-    }
-
-    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 mut read_ok = true;
-        let v = if (AMBA_ID_LOW..AMBA_ID_HIGH).contains(&(offset >> 2)) {
-            let index = ((offset - 0xfe0) >> 2) as usize;
-            u32::from(PL011_ID[index])
-        } else {
-            match offset >> 2 {
-                UARTDR => {
-                    self.flags &= !PL011_FLAG_RXFF;
-                    let c: u32 = 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;
-                    c
-                }
-                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,
-                UARTDEBUG => self.debug,
-                _ => {
-                    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_versioned_state(&self.state())
-    }
-}
-
-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,
-            _masked: bool,
-        ) -> 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(TestInterrupt::new(intr_evt.try_clone().unwrap())),
-            Some(Box::new(pl011_out.clone())),
-            Instant::now(),
-            None,
-        );
-
-        pl011.write(0, UARTDR, &[b'x', b'y']);
-        pl011.write(0, UARTDR, &[b'a']);
-        pl011.write(0, UARTDR, &[b'b']);
-        pl011.write(0, UARTDR, &[b'c']);
-        assert_eq!(
-            pl011_out.buf.lock().unwrap().as_slice(),
-            &[b'x', b'a', b'b', b'c']
-        );
-    }
-
-    #[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(TestInterrupt::new(intr_evt.try_clone().unwrap())),
-            Some(Box::new(pl011_out)),
-            Instant::now(),
-            None,
-        );
-
-        // write 1 to the interrupt event fd, so that read doesn't block in case the event fd
-        // 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, &mut data);
-        assert_eq!(data[0], b'a');
-        pl011.read(0, UARTDR, &mut data);
-        assert_eq!(data[0], b'b');
-        pl011.read(0, UARTDR, &mut data);
-        assert_eq!(data[0], b'c');
-    }
-}

devices/src/lib.rs

@@ -6,85 +6,72 @@
 // found in the LICENSE-BSD-3-Clause file.
 
 //! Emulates virtual and hardware devices.
-
 #[macro_use]
 extern crate bitflags;
+extern crate byteorder;
+extern crate epoll;
+extern crate libc;
 #[macro_use]
 extern crate log;
+extern crate vm_device;
+extern crate vm_memory;
+extern crate vmm_sys_util;
 
-pub mod acpi;
-#[cfg(target_arch = "aarch64")]
-pub mod gic;
-pub mod interrupt_controller;
-#[cfg(target_arch = "x86_64")]
+use std::fs::File;
+use std::io;
+
+#[cfg(feature = "acpi")]
+mod acpi;
+mod bus;
 pub mod ioapic;
 pub mod legacy;
-pub mod tpm;
 
-pub use self::acpi::{AcpiGedDevice, AcpiPmTimerDevice, AcpiShutdownDevice};
+#[cfg(feature = "acpi")]
+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;
     }
 }
-
-#[cfg(target_arch = "aarch64")]
-macro_rules! generate_read_fn {
-    ($fn_name: ident, $data_type: ty, $byte_type: ty, $type_size: expr, $endian_type: ident) => {
-        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)
-        }
-    };
-}
-
-#[cfg(target_arch = "aarch64")]
-macro_rules! generate_write_fn {
-    ($fn_name: ident, $data_type: ty, $byte_type: ty, $endian_type: ident) => {
-        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);

devices/src/tpm.rs

@@ -1,551 +0,0 @@
-// Copyright © 2022, Microsoft Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-use anyhow::anyhow;
-#[cfg(target_arch = "aarch64")]
-use arch::aarch64::layout::{TPM_SIZE, TPM_START};
-#[cfg(target_arch = "x86_64")]
-use arch::x86_64::layout::{TPM_SIZE, TPM_START};
-use std::cmp;
-use std::sync::{Arc, Barrier};
-use thiserror::Error;
-use tpm::emulator::{BackendCmd, Emulator};
-use tpm::TPM_CRB_BUFFER_MAX;
-use vm_device::BusDevice;
-
-#[derive(Error, Debug)]
-pub enum Error {
-    #[error("Emulator doesn't implement min required capabilities: {0}")]
-    CheckCaps(#[source] anyhow::Error),
-    #[error("Failed to initialize tpm: {0}")]
-    Init(#[source] anyhow::Error),
-}
-type Result<T> = anyhow::Result<T, Error>;
-
-#[allow(dead_code)]
-enum LocStateFields {
-    TpmEstablished,
-    LocAssigned,
-    ActiveLocality,
-    Reserved,
-    TpmRegValidSts,
-}
-
-enum LocStsFields {
-    Granted,
-    BeenSeized,
-}
-
-#[allow(dead_code)]
-enum IntfIdFields {
-    InterfaceType,
-    InterfaceVersion,
-    CapLocality,
-    CapCRBIdleBypass,
-    Reserved1,
-    CapDataXferSizeSupport,
-    CapFIFO,
-    CapCRB,
-    CapIFRes,
-    InterfaceSelector,
-    IntfSelLock,
-    Reserved2,
-    Rid,
-}
-
-#[allow(dead_code)]
-enum IntfId2Fields {
-    Vid,
-    Did,
-}
-
-enum CtrlStsFields {
-    TpmSts,
-    TpmIdle,
-}
-
-enum CrbRegister {
-    LocState(LocStateFields),
-    LocSts(LocStsFields),
-    IntfId(IntfIdFields),
-    IntfId2(IntfId2Fields),
-    CtrlSts(CtrlStsFields),
-}
-
-/* crb 32-bit registers */
-const CRB_LOC_STATE: u32 = 0x0;
-//Register Fields
-// Field => (base, offset, length)
-// base:   starting position of the register
-// offset: lowest bit in the bit field numbered from 0
-// length: length of the bit field
-const fn get_crb_loc_state_field(f: LocStateFields) -> (u32, u32, u32) {
-    let (offset, len) = match f {
-        LocStateFields::TpmEstablished => (0, 1),
-        LocStateFields::LocAssigned => (1, 1),
-        LocStateFields::ActiveLocality => (2, 3),
-        LocStateFields::Reserved => (5, 2),
-        LocStateFields::TpmRegValidSts => (7, 1),
-    };
-
-    (CRB_LOC_STATE, offset, len)
-}
-
-const CRB_LOC_CTRL: u32 = 0x08;
-const CRB_LOC_CTRL_REQUEST_ACCESS: u32 = 1 << 0;
-const CRB_LOC_CTRL_RELINQUISH: u32 = 1 << 1;
-const CRB_LOC_CTRL_RESET_ESTABLISHMENT_BIT: u32 = 1 << 3;
-const CRB_LOC_STS: u32 = 0x0C;
-const fn get_crb_loc_sts_field(f: LocStsFields) -> (u32, u32, u32) {
-    let (offset, len) = match f {
-        LocStsFields::Granted => (0, 1),
-        LocStsFields::BeenSeized => (1, 1),
-    };
-
-    (CRB_LOC_STS, offset, len)
-}
-
-const CRB_INTF_ID: u32 = 0x30;
-const fn get_crb_intf_id_field(f: IntfIdFields) -> (u32, u32, u32) {
-    let (offset, len) = match f {
-        IntfIdFields::InterfaceType => (0, 4),
-        IntfIdFields::InterfaceVersion => (4, 4),
-        IntfIdFields::CapLocality => (8, 1),
-        IntfIdFields::CapCRBIdleBypass => (9, 1),
-        IntfIdFields::Reserved1 => (10, 1),
-        IntfIdFields::CapDataXferSizeSupport => (11, 2),
-        IntfIdFields::CapFIFO => (13, 1),
-        IntfIdFields::CapCRB => (14, 1),
-        IntfIdFields::CapIFRes => (15, 2),
-        IntfIdFields::InterfaceSelector => (17, 2),
-        IntfIdFields::IntfSelLock => (19, 1),
-        IntfIdFields::Reserved2 => (20, 4),
-        IntfIdFields::Rid => (24, 8),
-    };
-
-    (CRB_INTF_ID, offset, len)
-}
-
-const CRB_INTF_ID2: u32 = 0x34;
-const fn get_crb_intf_id2_field(f: IntfId2Fields) -> (u32, u32, u32) {
-    let (offset, len) = match f {
-        IntfId2Fields::Vid => (0, 16),
-        IntfId2Fields::Did => (16, 16),
-    };
-
-    (CRB_INTF_ID2, offset, len)
-}
-
-const CRB_CTRL_REQ: u32 = 0x40;
-const CRB_CTRL_REQ_CMD_READY: u32 = 1 << 0;
-const CRB_CTRL_REQ_GO_IDLE: u32 = 1 << 1;
-const CRB_CTRL_STS: u32 = 0x44;
-const fn get_crb_ctrl_sts_field(f: CtrlStsFields) -> (u32, u32, u32) {
-    let (offset, len) = match f {
-        CtrlStsFields::TpmSts => (0, 1),
-        CtrlStsFields::TpmIdle => (1, 1),
-    };
-
-    (CRB_CTRL_STS, offset, len)
-}
-const CRB_CTRL_CANCEL: u32 = 0x48;
-const CRB_CANCEL_INVOKE: u32 = 1 << 0;
-const CRB_CTRL_START: u32 = 0x4C;
-const CRB_START_INVOKE: u32 = 1 << 0;
-const CRB_CTRL_CMD_LADDR: u32 = 0x5C;
-const CRB_CTRL_CMD_HADDR: u32 = 0x60;
-const CRB_CTRL_RSP_SIZE: u32 = 0x64;
-const CRB_CTRL_RSP_ADDR: u32 = 0x68;
-const CRB_DATA_BUFFER: u32 = 0x80;
-
-const TPM_CRB_NO_LOCALITY: u32 = 0xff;
-
-const TPM_CRB_ADDR_BASE: u32 = TPM_START.0 as u32;
-const TPM_CRB_ADDR_SIZE: usize = TPM_SIZE as usize;
-
-const TPM_CRB_R_MAX: usize = CRB_DATA_BUFFER as usize;
-
-// CRB Protocol details
-const CRB_INTF_TYPE_CRB_ACTIVE: u32 = 0b1;
-const CRB_INTF_VERSION_CRB: u32 = 0b1;
-const CRB_INTF_CAP_LOCALITY_0_ONLY: u32 = 0b0;
-const CRB_INTF_CAP_IDLE_FAST: u32 = 0b0;
-const CRB_INTF_CAP_XFER_SIZE_64: u32 = 0b11;
-const CRB_INTF_CAP_FIFO_NOT_SUPPORTED: u32 = 0b0;
-const CRB_INTF_CAP_CRB_SUPPORTED: u32 = 0b1;
-const CRB_INTF_IF_SELECTOR_CRB: u32 = 0b1;
-const PCI_VENDOR_ID_IBM: u32 = 0x1014;
-const CRB_CTRL_CMD_SIZE_REG: u32 = 0x58;
-const CRB_CTRL_CMD_SIZE: usize = TPM_CRB_ADDR_SIZE - CRB_DATA_BUFFER as usize;
-
-// Returns (register base, offset, len)
-const fn get_field(reg: CrbRegister) -> (u32, u32, u32) {
-    match reg {
-        CrbRegister::LocState(f) => get_crb_loc_state_field(f),
-        CrbRegister::LocSts(f) => get_crb_loc_sts_field(f),
-        CrbRegister::IntfId(f) => get_crb_intf_id_field(f),
-        CrbRegister::IntfId2(f) => get_crb_intf_id2_field(f),
-        CrbRegister::CtrlSts(f) => get_crb_ctrl_sts_field(f),
-    }
-}
-
-// Set a particular field in a Register
-fn set_reg_field(regs: &mut [u32; TPM_CRB_R_MAX], reg: CrbRegister, value: u32) {
-    let (base, offset, len) = get_field(reg);
-    let mask = (!(0_u32) >> (32 - len)) << offset;
-    regs[base as usize] = (regs[base as usize] & !mask) | ((value << offset) & mask);
-}
-
-// Get the value of a particular field in a Register
-const fn get_reg_field(regs: &[u32; TPM_CRB_R_MAX], reg: CrbRegister) -> u32 {
-    let (base, offset, len) = get_field(reg);
-    let mask = (!(0_u32) >> (32 - len)) << offset;
-    (regs[base as usize] & mask) >> offset
-}
-
-fn locality_from_addr(addr: u32) -> u8 {
-    (addr >> 12) as u8
-}
-
-pub struct Tpm {
-    emulator: Emulator,
-    regs: [u32; TPM_CRB_R_MAX],
-    backend_buff_size: usize,
-    data_buff: [u8; TPM_CRB_BUFFER_MAX],
-    data_buff_len: usize,
-}
-
-impl Tpm {
-    pub fn new(path: String) -> Result<Self> {
-        let emulator = Emulator::new(path)
-            .map_err(|e| Error::Init(anyhow!("Failed while initializing tpm Emulator: {:?}", e)))?;
-        let mut tpm = Tpm {
-            emulator,
-            regs: [0; TPM_CRB_R_MAX],
-            backend_buff_size: TPM_CRB_BUFFER_MAX,
-            data_buff: [0; TPM_CRB_BUFFER_MAX],
-            data_buff_len: 0,
-        };
-        tpm.reset()?;
-        Ok(tpm)
-    }
-
-    fn get_active_locality(&mut self) -> u32 {
-        if get_reg_field(
-            &self.regs,
-            CrbRegister::LocState(LocStateFields::LocAssigned),
-        ) == 0
-        {
-            return TPM_CRB_NO_LOCALITY;
-        }
-        get_reg_field(
-            &self.regs,
-            CrbRegister::LocState(LocStateFields::ActiveLocality),
-        )
-    }
-
-    fn request_completed(&mut self, success: bool) {
-        self.regs[CRB_CTRL_START as usize] = !CRB_START_INVOKE;
-        if !success {
-            set_reg_field(
-                &mut self.regs,
-                CrbRegister::CtrlSts(CtrlStsFields::TpmSts),
-                1,
-            );
-        }
-    }
-
-    fn reset(&mut self) -> Result<()> {
-        let cur_buff_size = self.emulator.get_buffer_size();
-        self.regs = [0; TPM_CRB_R_MAX];
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::LocState(LocStateFields::TpmRegValidSts),
-            1,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::CtrlSts(CtrlStsFields::TpmIdle),
-            1,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId(IntfIdFields::InterfaceType),
-            CRB_INTF_TYPE_CRB_ACTIVE,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId(IntfIdFields::InterfaceVersion),
-            CRB_INTF_VERSION_CRB,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId(IntfIdFields::CapLocality),
-            CRB_INTF_CAP_LOCALITY_0_ONLY,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId(IntfIdFields::CapCRBIdleBypass),
-            CRB_INTF_CAP_IDLE_FAST,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId(IntfIdFields::CapDataXferSizeSupport),
-            CRB_INTF_CAP_XFER_SIZE_64,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId(IntfIdFields::CapFIFO),
-            CRB_INTF_CAP_FIFO_NOT_SUPPORTED,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId(IntfIdFields::CapCRB),
-            CRB_INTF_CAP_CRB_SUPPORTED,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId(IntfIdFields::InterfaceSelector),
-            CRB_INTF_IF_SELECTOR_CRB,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId(IntfIdFields::Rid),
-            0b0000,
-        );
-        set_reg_field(
-            &mut self.regs,
-            CrbRegister::IntfId2(IntfId2Fields::Vid),
-            PCI_VENDOR_ID_IBM,
-        );
-
-        self.regs[CRB_CTRL_CMD_SIZE_REG as usize] = CRB_CTRL_CMD_SIZE as u32;
-        self.regs[CRB_CTRL_CMD_LADDR as usize] = TPM_CRB_ADDR_BASE + CRB_DATA_BUFFER;
-        self.regs[CRB_CTRL_RSP_SIZE as usize] = CRB_CTRL_CMD_SIZE as u32;
-        self.regs[CRB_CTRL_RSP_ADDR as usize] = TPM_CRB_ADDR_BASE + CRB_DATA_BUFFER;
-
-        self.backend_buff_size = cmp::min(cur_buff_size, TPM_CRB_BUFFER_MAX);
-
-        if let Err(e) = self.emulator.startup_tpm(self.backend_buff_size) {
-            return Err(Error::Init(anyhow!(
-                "Failed while running Startup TPM. Error: {:?}",
-                e
-            )));
-        }
-        Ok(())
-    }
-}
-
-impl BusDevice for Tpm {
-    fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
-        let mut offset: u32 = offset as u32;
-        let read_len: usize = data.len();
-
-        if offset >= CRB_DATA_BUFFER
-            && (offset + read_len as u32) < (CRB_DATA_BUFFER + self.data_buff.len() as u32)
-        {
-            // Read from Data Buffer
-            let start: usize = (offset as usize) - (CRB_DATA_BUFFER as usize);
-            let end: usize = start + read_len;
-            data[..].clone_from_slice(&self.data_buff[start..end]);
-        } else {
-            offset &= 0xff;
-            let mut val = self.regs[offset as usize];
-
-            if offset == CRB_LOC_STATE && !self.emulator.get_established_flag() {
-                val |= 0x1;
-            }
-
-            if data.len() <= 4 {
-                data.clone_from_slice(val.to_ne_bytes()[0..read_len].as_ref());
-            } else {
-                error!(
-                    "Invalid tpm read: offset {:#X}, data length {:?}",
-                    offset,
-                    data.len()
-                );
-            }
-        }
-        debug!(
-            "MMIO Read: offset {:#X} len {:?} val = {:02X?}  ",
-            offset,
-            data.len(),
-            data
-        );
-    }
-
-    fn write(&mut self, _base: u64, offset: u64, data: &[u8]) -> Option<Arc<Barrier>> {
-        debug!(
-            "MMIO Write: offset {:#X} len {:?} input data {:02X?}",
-            offset,
-            data.len(),
-            data
-        );
-        let mut offset: u32 = offset as u32;
-        if offset < CRB_DATA_BUFFER {
-            offset &= 0xff;
-        }
-        let locality = locality_from_addr(offset) as u32;
-        let write_len = data.len();
-
-        if offset >= CRB_DATA_BUFFER
-            && (offset + write_len as u32) < (CRB_DATA_BUFFER + self.data_buff.len() as u32)
-        {
-            let start: usize = (offset as usize) - (CRB_DATA_BUFFER as usize);
-            if start == 0 {
-                // If filling data_buff at index 0, reset length to 0
-                self.data_buff_len = 0;
-                self.data_buff.fill(0);
-            }
-            let end: usize = start + data.len();
-            self.data_buff[start..end].clone_from_slice(data);
-            self.data_buff_len += data.len();
-        } else {
-            // Ctrl Commands that take more than 4 bytes as input are not yet supported
-            // CTRL_RSP_ADDR usually gets 8 byte write request. Last 4 bytes are zeros.
-            if write_len > 4 && offset != CRB_CTRL_RSP_ADDR {
-                error!(
-                    "Invalid tpm write: offset {:#X}, data length {}",
-                    offset,
-                    data.len()
-                );
-                return None;
-            }
-
-            let mut input: [u8; 4] = [0; 4];
-            input.copy_from_slice(&data[0..4]);
-            let v = u32::from_le_bytes(input);
-
-            match offset {
-                CRB_CTRL_CMD_SIZE_REG => {
-                    self.regs[CRB_CTRL_CMD_SIZE_REG as usize] = v;
-                }
-                CRB_CTRL_CMD_LADDR => {
-                    self.regs[CRB_CTRL_CMD_LADDR as usize] = v;
-                }
-                CRB_CTRL_CMD_HADDR => {
-                    self.regs[CRB_CTRL_CMD_HADDR as usize] = v;
-                }
-                CRB_CTRL_RSP_SIZE => {
-                    self.regs[CRB_CTRL_RSP_SIZE as usize] = v;
-                }
-                CRB_CTRL_RSP_ADDR => {
-                    self.regs[CRB_CTRL_RSP_ADDR as usize] = v;
-                }
-                CRB_CTRL_REQ => match v {
-                    CRB_CTRL_REQ_CMD_READY => {
-                        set_reg_field(
-                            &mut self.regs,
-                            CrbRegister::CtrlSts(CtrlStsFields::TpmIdle),
-                            0,
-                        );
-                    }
-                    CRB_CTRL_REQ_GO_IDLE => {
-                        set_reg_field(
-                            &mut self.regs,
-                            CrbRegister::CtrlSts(CtrlStsFields::TpmIdle),
-                            1,
-                        );
-                    }
-                    _ => {
-                        error!("Invalid value passed to CRTL_REQ register");
-                        return None;
-                    }
-                },
-                CRB_CTRL_CANCEL => {
-                    if v == CRB_CANCEL_INVOKE
-                        && (self.regs[CRB_CTRL_START as usize] & CRB_START_INVOKE != 0)
-                    {
-                        if let Err(e) = self.emulator.cancel_cmd() {
-                            error!("Failed to run cancel command. Error: {:?}", e);
-                        }
-                    }
-                }
-                CRB_CTRL_START => {
-                    if v == CRB_START_INVOKE
-                        && ((self.regs[CRB_CTRL_START as usize] & CRB_START_INVOKE) == 0)
-                        && self.get_active_locality() == locality
-                    {
-                        self.regs[CRB_CTRL_START as usize] |= CRB_START_INVOKE;
-
-                        let mut cmd = BackendCmd {
-                            buffer: &mut self.data_buff,
-                            input_len: cmp::min(self.data_buff_len, TPM_CRB_BUFFER_MAX),
-                        };
-
-                        let status = self.emulator.deliver_request(&mut cmd).is_ok();
-
-                        self.request_completed(status);
-                    }
-                }
-                CRB_LOC_CTRL => {
-                    warn!(
-                        "CRB_LOC_CTRL locality to write = {:?} val = {:?}",
-                        locality, v
-                    );
-                    match v {
-                        CRB_LOC_CTRL_RESET_ESTABLISHMENT_BIT => {}
-                        CRB_LOC_CTRL_RELINQUISH => {
-                            set_reg_field(
-                                &mut self.regs,
-                                CrbRegister::LocState(LocStateFields::LocAssigned),
-                                0,
-                            );
-                            set_reg_field(
-                                &mut self.regs,
-                                CrbRegister::LocSts(LocStsFields::Granted),
-                                0,
-                            );
-                        }
-                        CRB_LOC_CTRL_REQUEST_ACCESS => {
-                            set_reg_field(
-                                &mut self.regs,
-                                CrbRegister::LocSts(LocStsFields::Granted),
-                                1,
-                            );
-                            set_reg_field(
-                                &mut self.regs,
-                                CrbRegister::LocSts(LocStsFields::BeenSeized),
-                                0,
-                            );
-                            set_reg_field(
-                                &mut self.regs,
-                                CrbRegister::LocState(LocStateFields::LocAssigned),
-                                1,
-                            );
-                        }
-                        _ => {
-                            error!("Invalid value to write in CRB_LOC_CTRL {:#X} ", v);
-                        }
-                    }
-                }
-                _ => {
-                    error!(
-                        "Invalid tpm write: offset {:#X}, data length {:?}",
-                        offset,
-                        data.len()
-                    );
-                }
-            }
-        }
-        None
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_set_get_reg_field() {
-        let mut regs: [u32; TPM_CRB_R_MAX] = [0; TPM_CRB_R_MAX];
-        set_reg_field(&mut regs, CrbRegister::IntfId(IntfIdFields::Rid), 0xAC);
-        assert_eq!(
-            get_reg_field(&regs, CrbRegister::IntfId(IntfIdFields::Rid)),
-            0xAC,
-            concat!("Test: ", stringify!(set_get_reg_field))
-        );
-    }
-}

docs/COPYING.docs

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

docs/api.md

@@ -1,21 +1,21 @@
 - [Cloud Hypervisor API](#cloud-hypervisor-api)
-  - [External API](#external-api)
-    - [REST API](#rest-api)
-    - [Location and availability](#location-and-availability)
-    - [Endpoints](#endpoints)
-      - [Virtual Machine Manager (VMM) Actions](#virtual-machine-manager-vmm-actions)
-      - [Virtual Machine (VM) Actions](#virtual-machine-vm-actions)
-    - [REST API Examples](#rest-api-examples)
-      - [Create a Virtual Machine](#create-a-virtual-machine)
-      - [Boot a Virtual Machine](#boot-a-virtual-machine)
-      - [Dump a Virtual Machine Information](#dump-a-virtual-machine-information)
-      - [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)
-  - [Internal API](#internal-api)
-    - [Goals and Design](#goals-and-design)
-  - [End to End Example](#end-to-end-example)
+  * [External API](#external-api)
+    + [REST API](#rest-api)
+      - [Location and availability](#location-and-availability)
+      - [Endpoints](#endpoints)
+		* [Virtual Machine Manager (VMM) Actions](#virtual-machine-manager-vmm-actions)
+		* [Virtual Machine (VM) Actions](#virtual-machine-vm-actions)
+      - [REST API Examples](#rest-api-examples)
+        * [Create a Virtual Machine](#create-a-virtual-machine)
+	    * [Boot a Virtual Machine](#boot-a-virtual-machine)
+        * [Dump a Virtual Machine Information](#dump-a-virtual-machine-information)
+        * [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 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)
 
 # Cloud Hypervisor API
 
@@ -71,47 +71,25 @@ The Cloud Hypervisor API exposes the following actions through its endpoints:
 
 #### Virtual Machine Manager (VMM) Actions
 
-| Action                              | Endpoint        | Request Body | Response Body              | Prerequisites      |
-| ----------------------------------- | --------------- | ------------ | -------------------------- | ------------------ |
-| Check for the REST API availability | `/vmm.ping`     | N/A          | `/schemas/VmmPingResponse` | N/A                |
-| Shut the VMM down                   | `/vmm.shutdown` | N/A          | N/A                        | The VMM is running |
+Action                              | Endpoint        | Request Body | Response Body              | Prerequisites
+------------------------------------|-----------------|--------------|----------------------------|---------------------------
+Check for the REST API availability | `/vmm.ping`     | N/A          | `/schemas/VmmPingResponse` | N/A
+Shut the VMM down                   | `/vmm.shutdown` | N/A          | N/A                        | The VMM is running
 
 #### 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                                       |
-| Trigger power button of the VM     | `/vm.power-button`      | 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                                       |
-| Task a snapshot of the VM          | `/vm.snapshot`          | `/schemas/VmSnapshotConfig`     | N/A                      | The VM is paused                                       |
-| Perform a coredump of the VM*      | `/vm.coredump`          | `/schemas/VmCoredumpData`       | N/A                      | The VM is paused                                       |
-| Restore the VM from a snapshot     | `/vm.restore`           | `/schemas/RestoreConfig`        | N/A                      | The VM is created but not booted                       |
-| 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 userspace PCI device to the VM | `/vm.add-user-device`   | `/schemas/VmAddUserDevice`      | `/schemas/PciDeviceInfo` | The VM is booted                                       |
-| Add vdpa device to the VM          | `/vm.add-vdpa`          | `/schemas/VdpaConfig`           | `/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                                       |
-| Prepare to receive a migration     | `/vm.receive-migration` | `/schemas/ReceiveMigrationData` | N/A                      | N/A                                                    |
-| Start to send migration to target  | `/vm.send-migration`    | `/schemas/SendMigrationData`    | N/A                      | The VM is booted and (shared mem or hugepages enabled) |
-
-* The `vmcoredump` action is available exclusively for the `x86_64`
-architecture and can be executed only when the `guest_debug` feature is
-enabled. Without this feature, the corresponding REST API endpoint is not
-available.
+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
 
@@ -136,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
@@ -150,8 +128,9 @@ curl --unix-socket /tmp/cloud-hypervisor.sock -i \
      -H 'Content-Type: application/json'         \
      -d '{
          "cpus":{"boot_vcpus": 4, "max_vcpus": 4},
-         "payload":{"kernel":"/opt/clh/kernel/vmlinux-virtio-fs-virtio-iommu", "cmdline":"console=ttyS0 console=hvc0 root=/dev/vda1 rw"},
-         "disks":[{"path":"/opt/clh/images/focal-server-cloudimg-amd64.raw"}],
+         "kernel":{"path":"/opt/clh/kernel/vmlinux-virtio-fs-virtio-iommu"},
+         "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"}]
          }'
@@ -224,11 +203,11 @@ From the CLI, one can either:
 The REST API and the CLI both rely on a common, [internal API](#internal-api).
 
 The CLI options are parsed by the
-[argh crate](https://docs.rs/argh/latest/argh/) and then translated into
+[clap crate](https://docs.rs/clap/2.33.0/clap/) and then translated into
 [internal API](#internal-api) commands.
 
 The REST API is processed by an HTTP thread using the
-[Firecracker's `micro_http`](https://github.com/firecracker-microvm/micro-http)
+[Firecracker's `micro_http`](https://github.com/firecracker-microvm/firecracker/tree/master/src/micro_http)
 crate. As with the CLI, the HTTP requests eventually get translated into
 [internal API](#internal-api) commands.
 
@@ -252,7 +231,7 @@ As a summary, the REST API and the CLI are essentially frontends for the
                        |                                      |      +------------------------+
                        |            +----------+              |                 VMM
                        |     CLI    |          |              |
-                       +----------->+   argh   +--------------+
+                       +----------->+   clap   +--------------+
                                     |          |
                                     +----------+
 
@@ -288,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:
 
@@ -317,8 +296,9 @@ APIs work together, let's look at a complete VM creation flow, from the
 		-H 'Content-Type: application/json'         \
 		-d '{
 			"cpus":{"boot_vcpus": 4, "max_vcpus": 4},
-			"payload":{"kernel":"/opt/clh/kernel/vmlinux-virtio-fs-virtio-iommu", "cmdline":"console=ttyS0 console=hvc0 root=/dev/vda1 rw"},
-			"disks":[{"path":"/opt/clh/images/focal-server-cloudimg-amd64.raw"}],
+			"kernel":{"path":"/opt/clh/kernel/vmlinux-virtio-fs-virtio-iommu"},
+			"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"}]
 			}'
@@ -367,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)?;
 	   }
    ```
@@ -386,5 +366,6 @@ APIs work together, let's look at a complete VM creation flow, from the
    ```
 1. The Cloud Hypervisor HTTP thread sends the formed HTTP response back to the
    user. This is abstracted by the
-   [micro_http](https://github.com/firecracker-microvm/micro-http)
+   [micro_http](https://github.com/firecracker-microvm/firecracker/tree/master/src/micro_http)
    crate.
+   

docs/balloon.md

@@ -1,76 +0,0 @@
-# Balloon
-
-Cloud Hypervisor implements a balloon device based on the VIRTIO specification.
-Its main purpose is to provide the host a way to reclaim memory by controlling
-the amount of memory visible to the guest. But it also provides some interesting
-features related to guest memory management.
-
-## Parameters
-
-`BalloonConfig` (known as `--balloon` from the CLI perspective) contains the
-list of parameters available for the balloon device.
-
-```rust
-struct BalloonConfig {
-    pub size: u64,
-    pub deflate_on_oom: bool,
-    pub free_page_reporting: bool,
-}
-```
-
-```
---balloon <balloon>	Balloon parameters "size=<balloon_size>,deflate_on_oom=on|off,free_page_reporting=on|off"
-```
-
-### `size`
-
-Size of the balloon device. It is subtracted from the VM's total size. For
-instance, if creating a VM with 4GiB of RAM, along with a balloon of 1GiB, the
-guest will be able to use 3GiB of accessible memory. The guest sees all the RAM
-and unless it is balloon enlightened is entitled to all of it.
-
-This parameter is mandatory.
-
-Value is an unsigned integer of 64 bits corresponding to the balloon size in
-bytes.
-
-_Example_
-
-```
---balloon size=1G
-```
-
-### `deflate_on_oom`
-
-Allow the guest to deflate the balloon if running Out Of Memory (OOM). Assuming
-the balloon size is greater than 0, this means the guest is allowed to reduce
-the balloon size all the way down to 0 if this can help recover from the OOM
-event.
-
-This parameter is optional.
-
-Value is a boolean set to `off` by default.
-
-_Example_
-
-```
---ballloon size=2G,deflate_on_oom=on
-```
-
-### `free_page_reporting`
-
-Allow the guest to report lists of free pages. This feature doesn't require the
-balloon to be of any specific size as it doesn't impact the balloon size. The
-guest can let the VMM know about pages that are free after they have been used.
-Based on this information, the VMM can advise the host that it doesn't need
-these pages anymore.
-
-This parameter is optional.
-
-Value is a boolean set to `off` by default.
-
-_Example_
-
-```
---ballloon size=0,free_page_reporting=on
-```

docs/building.md

@@ -1,86 +0,0 @@
-- [Building Cloud Hypervisor](#building-cloud-hypervisor)
-  - [Preparation](#preparation)
-  - [Install prerequisites](#install-prerequisites)
-  - [Clone and build](#clone-and-build)
-    - [Containerized builds and tests](#containerized-builds-and-tests)
-
-# Building Cloud Hypervisor
-
-We recommend users use the pre-built binaries that are mentioned in the README.md file in the root of the repository. Building from source is only necessary if you wish to make modifications.
-
-## Preparation
-
-We create a folder to build and run `cloud-hypervisor` at `$HOME/cloud-hypervisor`
-
-```shell
-$ export CLOUDH=$HOME/cloud-hypervisor
-$ mkdir $CLOUDH
-```
-
-## Install prerequisites
-
-You need to install some prerequisite packages in order to build and test Cloud
-Hypervisor. Here, all the steps are based on Ubuntu, for other Linux
-distributions please replace the package manager and package name.
-
-```shell
-# Install basic packages needed. For a package list targeting for more
-# functionalities for example the test, please see resources/Dockerfile.
-$ sudo apt-get update
-$ sudo apt install git build-essential m4 bison flex uuid-dev qemu-utils musl-tools
-# Install rust tool chain
-$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-# If you want to build statically linked binary please add musl target
-$ rustup target add x86_64-unknown-linux-musl  # x86-64
-$ rustup target add aarch64-unknown-linux-musl # AArch64
-```
-
-## Clone and build
-
-First you need to clone and build the Cloud Hypervisor repository:
-
-```shell
-$ pushd $CLOUDH
-$ git clone https://github.com/cloud-hypervisor/cloud-hypervisor.git
-$ cd cloud-hypervisor
-$ cargo build --release
-
-# We need to give the cloud-hypervisor binary the NET_ADMIN capabilities for it to set TAP interfaces up on the host.
-$ sudo setcap cap_net_admin+ep ./target/release/cloud-hypervisor
-
-# If you want to build statically linked binary
-$ cargo build --release --target=x86_64-unknown-linux-musl --all  # x86-64
-$ cargo build --release --target=aarch64-unknown-linux-musl --all # AArch64
-$ popd
-```
-
-This will build a `cloud-hypervisor` binary under
-`$CLOUDH/cloud-hypervisor/target/release/cloud-hypervisor`.
-
-### Containerized builds and tests
-
-If you want to build and test Cloud Hypervisor without having to install all the
-required dependencies (The rust toolchain, cargo tools, etc), you can also use
-Cloud Hypervisor's development script: `dev_cli.sh`. Please note that upon its
-first invocation, this script will pull a fairly large container image.
-
-For example, to build the Cloud Hypervisor release binary:
-
-```shell
-$ pushd $CLOUDH
-$ cd cloud-hypervisor
-$ ./scripts/dev_cli.sh build --release
-```
-
-With `dev_cli.sh`, one can also run the Cloud Hypervisor CI locally. This can be
-very convenient for debugging CI errors without having to fully rely on the
-Cloud Hypervisor CI infrastructure.
-
-For example, to run the Cloud Hypervisor unit tests:
-
-```shell
-$ ./scripts/dev_cli.sh tests --unit
-```
-
-Run the `./scripts/dev_cli.sh --help` command to view all the supported
-development script commands and their related options.

docs/cpu.md

@@ -1,211 +0,0 @@
-# CPU
-
-Cloud Hypervisor has many options when it comes to the creation of virtual
-CPUs. 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.
-
-## Options
-
-`CpusConfig` or what is known as `--cpus` from the CLI perspective is the way
-to set vCPUs options for Cloud Hypervisor.
-
-```rust
-struct CpusConfig {
-    boot_vcpus: u8,
-    max_vcpus: u8,
-    topology: Option<CpuTopology>,
-    kvm_hyperv: bool,
-    max_phys_bits: u8,
-    affinity: Option<Vec<CpuAffinity>>,
-    features: CpuFeatures,
-}
-```
-
-```
---cpus boot=<boot_vcpus>,max=<max_vcpus>,topology=<threads_per_core>:<cores_per_die>:<dies_per_package>:<packages>,kvm_hyperv=on|off,max_phys_bits=<maximum_number_of_physical_bits>,affinity=<list_of_vcpus_with_their_associated_cpuset>,features=<list_of_features_to_enable>
-```
-
-### `boot`
-
-Number of vCPUs present at boot time.
-
-This option allows to define a specific number of vCPUs to be present at the
-time the VM is started. This option is mandatory when using the `--cpus`
-parameter. If `--cpus` is not specified, this option takes the default value
-of `1`, starting the VM with a single vCPU.
-
-Value is an unsigned integer of 8 bits.
-
-_Example_
-
-```
---cpus boot=2
-```
-
-### `max`
-
-Maximum number of vCPUs.
-
-This option defines the maximum number of vCPUs that can be assigned to the VM.
-In particular, this option is used when looking for CPU hotplug as it lets the
-provide an indication about how many vCPUs might be needed later during the
-runtime of the VM.
-For instance, if booting the VM with 2 vCPUs and a maximum of 6 vCPUs, it means
-up to 4 vCPUs can be added later at runtime by resizing the VM.
-
-The value must be greater than or equal to the number of boot vCPUs.
-The value is an unsigned integer of 8 bits.
-
-By default this option takes the value of `boot`, meaning vCPU hotplug is not
-expected and can't be performed.
-
-_Example_
-
-```
---cpus max=3
-```
-
-### `topology`
-
-Topology of the guest platform.
-
-This option gives the user a way to describe the exact topology that should be
-exposed to the guest. It can be useful to describe to the guest the same
-topology found on the host as it allows for proper usage of the resources and
-is a way to achieve better performances.
-
-The topology is described through the following structure:
-
-```rust
-struct CpuTopology {
-    threads_per_core: u8,
-    cores_per_die: u8,
-    dies_per_package: u8,
-    packages: u8,
-}
-```
-
-or the following syntax through the CLI:
-
-```
-topology=<threads_per_core>:<cores_per_die>:<dies_per_package>:<packages>
-```
-
-By default the topology will be `1:1:1:1`.
-
-_Example_
-
-```
---cpus boot=2,topology=1:1:2:1
-```
-
-### `kvm_hyperv`
-
-Enable KVM Hyper-V emulation.
-
-When turned on, this option relies on KVM to emulate the synthetic interrupt
-controller (SynIC) along with synthetic timers expected by a Windows guest.
-A Windows guest usually runs on top of Microsoft Hyper-V, therefore expects
-these synthetic devices to be present. That's why KVM provides a way to emulate
-them and avoids failures running a Windows guest with Cloud Hypervisor.
-
-By default this option is turned off.
-
-_Example_
-
-```
---cpus kvm_hyperv=on
-```
-
-### `max_phys_bits`
-
-Maximum size for guest's addressable space.
-
-This option defines the maximum number of physical bits for all vCPUs, which
-sets a limit for the size of the guest's addressable space. This is mainly
-useful for debug purpose.
-
-The value is an unsigned integer of 8 bits.
-
-_Example_
-
-```
---cpus max_phys_bits=40
-```
-
-### `affinity`
-
-Affinity of each vCPU.
-
-This option gives the user a way to provide the host CPU set associated with
-each vCPU. It is useful for achieving CPU pinning, ensuring multiple VMs won't
-affect the performance of each other. It might also be used in the context of
-NUMA as it is way of making sure the VM can run on a specific host NUMA node.
-In general, this option is used to increase the performances of a VM depending
-on the host platform and the type of workload running in the guest.
-
-The affinity is described through the following structure:
-
-```rust
-struct CpuAffinity {
-    vcpu: u8,
-    host_cpus: Vec<u8>,
-}
-```
-
-or the following syntax through the CLI:
-
-```
-affinity=[<vcpu_id1>@[<host_cpu_id1>, <host_cpu_id2>], <vcpu_id2>@[<host_cpu_id3>, <host_cpu_id4>]]
-```
-
-The outer brackets define the list of vCPUs. And for each vCPU, the inner
-brackets attached to `@` define the list of host CPUs the vCPU is allowed to
-run onto.
-
-Multiple values can be provided to define each list. Each value is an unsigned
-integer of 8 bits.
-
-For instance, if one needs to run vCPU 0 on host CPUs from 0 to 4, the syntax
-using `-` will help define a contiguous range with `affinity=0@[0-4]`. The
-same example could also be described with `affinity=0@[0,1,2,3,4]`.
-
-A combination of both `-` and `,` separators is useful when one might need to
-describe a list containing host CPUs from 0 to 99 and the host CPU 255, as it
-could simply be described with `affinity=0@[0-99,255]`.
-
-As soon as one tries to describe a list of values, `[` and `]` must be used to
-demarcate the list.
-
-By default each vCPU runs on the entire host CPU set.
-
-_Example_
-
-```
---cpus boot=3,affinity=[0@[2,3],1@[0,1]]
-```
-
-In this example, assuming the host has 4 CPUs, vCPU 0 will run exclusively on
-host CPUs 2 and 3, while vCPU 1 will run exclusively on host CPUs 0 and 1.
-Because nothing is defined for vCPU 2, it can run on any of the 4 host CPUs.
-
-### `features`
-
-Set of CPU features to enable.
-
-This option allows the user to enable a set of CPU features that are disabled
-by default otherwise.
-
-The currently available feature set is: `amx`.
-
-The `amx` feature will enable the x86 extension adding hardware units for
-matrix operations (int and float dot products). The goal of the extension is to
-provide performance enhancements for these common operations.
-
-_Example_
-
-```
---cpus features=amx
-```
-
-In this example the amx CPU feature will be enabled for the VMM.

docs/custom-image.md

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

docs/debug-port.md

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

docs/device_model.md

@@ -6,35 +6,31 @@ This document describes the device model supported by `cloud-hypervisor`.
 
 | Device | Build configurable | Enabled by default | Runtime configurable |
 | :----: | :----: | :----: | :----: |
-| Serial port | :x: | :x: | :heavy_check_mark: |
-| RTC/CMOS | :heavy_check_mark: | :heavy_check_mark: | :x: |
-| I/O APIC | :x: | :x: | :heavy_check_mark: |
-| i8042 shutdown/reboot | :x: | :x: | :x: |
-| ACPI shutdown/reboot | :x: | :heavy_check_mark: | :x: |
-| virtio-blk | :x: | :x: | :heavy_check_mark: |
-| virtio-console | :x: | :x: | :heavy_check_mark: |
-| virtio-iommu | :x: | :x: | :heavy_check_mark: |
-| virtio-net | :x: | :x: | :heavy_check_mark: |
-| virtio-pmem | :x: | :x: | :heavy_check_mark: |
-| virtio-rng | :x: | :x: | :heavy_check_mark: |
-| virtio-vsock | :x: | :x: | :heavy_check_mark: |
-| vhost-user-blk | :x: | :x: | :heavy_check_mark: |
-| vhost-user-fs | :x: | :x: | :heavy_check_mark: |
-| vhost-user-net | :x: | :x: | :heavy_check_mark: |
-| VFIO | :heavy_check_mark: | :x: | :heavy_check_mark: |
+| Serial port | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| RTC/CMOS | :heavy_check_mark: | :heavy_check_mark: | :negative_squared_cross_mark: |
+| I/O APIC | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| i8042 shutdown/reboot | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :negative_squared_cross_mark: |
+| ACPI shutdown/reboot | :negative_squared_cross_mark: | :heavy_check_mark: | :negative_squared_cross_mark: |
+| virtio-blk | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| virtio-console | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| virtio-iommu | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| virtio-net | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| virtio-pmem | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| virtio-rng | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| virtio-vsock | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| vhost-user-blk | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| vhost-user-fs | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| vhost-user-net | :negative_squared_cross_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
+| VFIO | :heavy_check_mark: | :negative_squared_cross_mark: | :heavy_check_mark: |
 
 ## Legacy devices
 
 ### 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,10 +75,12 @@ feature is enabled by default.
 
 ## Virtio devices
 
-For all virtio devices listed below, only `virtio-pci` transport layer is
-supported. Cloud Hypervisor supports multiple PCI segments, and users can
-append `,pci_segment=<PCI_segment_number>` to the device flag in the Cloud
-Hypervisor command line to assign devices to a specific PCI segment.
+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
 
@@ -115,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
@@ -185,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`.
@@ -207,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

@@ -1,27 +1,23 @@
 # How to use virtio-fs
 
-In the context of virtualization, it is always convenient to be able to share a
-directory from the host with the guest.
+In the context of virtualization, it is always convenient to be able to share a directory from the host with the guest.
 
-__virtio-fs__, also known as __vhost-user-fs__ is a virtual device defined by
-the VIRTIO specification which allows any VMM to perform filesystem sharing.
+__virtio-fs__, also known as __vhost-user-fs__ is a virtual device defined by the VIRTIO specification which allows any VMM to perform filesystem sharing.
 
 ## Pre-requisites
 
 ### The daemon
 
-This virtual device relies on the _vhost-user_ protocol, which assumes the
-backend (device emulation) is handled by a dedicated process running on the
-host. This daemon is called __virtiofsd__ and needs to be present on the host.
+This virtual device relies on the _vhost-user_ protocol, which assumes the backend (device emulation) is handled by a dedicated process running on the host. This daemon is called __virtiofsd__ and needs to be present on the host.
 
 _Build virtiofsd_
 ```bash
-git clone https://gitlab.com/virtio-fs/virtiofsd
-pushd virtiofsd
-cargo build --release
-sudo setcap cap_sys_admin+epi target/release/virtiofsd
+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`
+sudo setcap cap_sys_admin+epi "virtiofsd"
 ```
-
 _Create shared directory_
 ```bash
 mkdir /tmp/shared_dir
@@ -29,70 +25,64 @@ mkdir /tmp/shared_dir
 _Run virtiofsd_
 ```bash
 ./virtiofsd \
-    --log-level debug \
+    -d \
     --socket-path=/tmp/virtiofs \
-    --shared-dir=/tmp/shared_dir \
-    --cache=never \
-    --thread-pool-size=$N
+    -o source=/tmp/shared_dir \
+    -o cache=none
 ```
 
-The `cache=never` option is the default when using `virtiofsd` with
-Cloud Hypervisor. This prevents from using the host page cache, reducing the
-overall footprint on host memory. This increases the maximum density of virtual
-machines that can be launched on a single host.
+The `cache=none` option should be the default when using `virtiofsd` with the __cloud-hypervisor__ VMM. This prevents from using the guest page cache, which reduces the memory footprint of the guest. When running multiple virtual machines on the same host, this will let the host deal with page cache, which will increase the density of virtual machines which can be launched.
 
-The `cache=always` option will allow the host page cache to be used, which can
-result in better performance for the guest's workload at the cost of increasing
-the footprint on host memory.
+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.
 
-The `thread-pool-size` option controls how many IO threads are spawned. For
-very fast storage like NVMe spawning enough worker threads is critical to
-getting an acceptable performance compared to native.
+### The kernel
 
-### Kernel support
+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.
 
-Modern Linux kernels (at least v5.10) have support for virtio-fs. Use of older
-kernels, with additional patches, are not supported.
+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.
 
-Once the daemon is running, the option `--fs` from Cloud Hypervisor needs
-to be used.
+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.
 
-Both direct kernel boot and EFI firmware can be used to boot a VM with
-virtio-fs, given that the cloud image contains a recent enough kernel.
+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.
 
-Correct functioning of `--fs` requires `--memory shared=on` to facilitate
-interprocess memory sharing.
-
-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=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=virtiofs,sock=/tmp/virtiofs,num_queues=1,queue_size=512,dax=off
+
 ```
 
 ### Mount the shared directory
-
-The last step is to mount the shared directory inside the guest, using the
-`virtiofs` filesystem type.
-
+The last step is to mount the shared directory inside the guest, using the `virtiofs` filesystem type.
 ```bash
 mkdir mount_dir
-mount -t virtiofs myfs mount_dir/
+mount -t virtiofs -o dax myfs mount_dir/
 ```
+The `tag` needs to be consistent with what has been provided through the __cloud-hypervisor__ command line, which happens to be `myfs` in this example.
 
-The `tag` needs to be consistent with what has been provided through the
-Cloud Hypervisor command line, which happens to be `myfs` in this example.
-
-## DAX feature
-
-Given the DAX feature is not stable yet from a daemon standpoint, it is not
-available in Cloud Hypervisor.
+The `-o dax` option must be removed in case the shared cache region is not enabled from the VMM.

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 `block` fuzzer using all available CPUs:
-
-```
-cargo fuzz run block -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/gdb.md

@@ -1,47 +0,0 @@
-# GDB Support
-
-This feature allows remote guest debugging using GDB. Note that this feature is only supported on x86_64/KVM.
-
-To enable debugging with GDB, build with the `guest_debug` feature enabled:
-
-```bash
-cargo build --features guest_debug
-```
-
-To use the `--gdb` option, specify the Unix Domain Socket with `path` that Cloud Hypervisor will use to communicate with the host's GDB:
-
-```bash
-./cloud-hypervisor \
-    --kernel hypervisor-fw \
-    --disk path=bionic-server-cloudimg-amd64.raw \
-    --cpus boot=1 \
-    --memory size=1024M \
-    --net "tap=,mac=,ip=,mask=" \
-    --console off \
-    --serial tty \
-    --gdb path=/tmp/ch-gdb-sock
-```
-
-Cloud Hypervisor will listen for GDB on the host side before starting the guest.
-On the host side, connect to the GDB remote server as follows:
-
-```bash
-gdb -q
-(gdb) target remote /tmp/ch-gdb-sock
-Remote debugging using /tmp/ch-gdb-sock
-warning: No executable has been specified, and target does not support
-determining executable automatically. Try using the "file" command.
-0x000000000011217e in ?? ()
-```
-
-You can set up to four hardware breakpoints using the x86 debug register:
-
-```bash
-(gdb) hb *0x1121b7
-Hardware assisted breakpoint 1 at 0x1121b7
-(gdb) c
-Continuing.
-
-Breakpoint 1, 0x00000000001121b7 in ?? ()
-(gdb)
-```

docs/heap-profiling.md

@@ -1,41 +0,0 @@
-# Heap profiling
-
-Cloud Hypervisor supports generating a profile using
-[dhat](https://docs.rs/dhat/latest/dhat/) of the heap allocations made during
-the runtime of the process.
-
-## Building a suitable binary
-
-This adds the symbol information to the release binary but does not otherwise
-affect the performance.
-
-```
-$ cargo build --profile profiling --features "dhat-heap"
-```
-
-## Generating output
-
-Cloud Hypervisor can then be run as usual. However it is necessary to run with `--seccomp false` as the profiling requires extra syscalls.
-
-```
-$ target/profiling/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 \
-        --seccomp false
-```
-
-When the VMM exits a message like the following will be shown:
-
-```
-dhat: Total:     384,582 bytes in 3,512 blocks
-dhat: At t-gmax: 133,885 bytes in 379 blocks
-dhat: At t-end:  12,160 bytes in 20 blocks
-dhat: The data has been saved to dhat-heap.json, and is viewable with dhat/dh_view.html
-```
-
-The JSON output can then be uploaded to [the dh_view tool](https://nnethercote.github.io/dh_view/dh_view.html) for analysis.
-

docs/hotplug.md

@@ -1,15 +1,17 @@
 # Cloud Hypervisor Hot Plug
 
-Currently Cloud Hypervisor supports hot plugging of CPUs devices (x86 only), PCI devices and memory resizing.
+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
+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.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
 
-Extra vCPUs can be added and removed from a running `cloud-hypervisor` instance. This is controlled by two mechanisms:
+Extra vCPUs can be added and removed from a running Cloud Hypervisor instance. This is controlled by two mechanisms:
 
 1. Specifying a number of maximum potential vCPUs that is greater than the number of default (boot) vCPUs.
 2. Making a HTTP API request to the VMM to ask for the additional vCPUs to be added.
@@ -20,23 +22,22 @@ 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
 ```
 
-Notice the addition of `--api-socket /tmp/ch-socket` and a `max` parameter on `--cpus boot=4,max=8`.
+Notice the addition of `--api-socket=/tmp/ch-socket` and a `max` parameter on `--cpus boot=4.max=8`.
 
 To ask the VMM to add additional vCPUs then use the resize API:
 
 ```shell
-./ch-remote --api-socket /tmp/ch-socket resize --cpus 8
+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,137 +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.
-
-Note: On AArch64 platform, PCI device hotplug can only be achieved using ACPI. Please refer to the [documentation](uefi.md#building-uefi-firmware-for-aarch64) for more information.
-
-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_vepc`, 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 id=epc0,size=64M,prefault=on id=epc1,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_vepc
-```
-
-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 as yet another device, which means it should
-appear at the end of the guest address space.

docs/intel_tdx.md

@@ -1,177 +0,0 @@
-# Intel TDX
-
-Intel® Trust Domain Extensions (Intel® TDX) is an Intel technology designed to
-isolate virtual machines from the VMM, hypervisor and any other software on the
-host platform. Here are some useful links:
-
-* [TDX Homepage](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-trust-domain-extensions.html):
-more information about TDX technical aspects, design and specification
-
-* [KVM TDX tree](https://github.com/intel/tdx/tree/kvm): the required
-  Linux kernel changes for the host side
-
-* [Guest TDX tree](https://github.com/intel/tdx/tree/guest): the Linux
-  kernel changes for the guest side
-
-* [EDK2 project](https://github.com/tianocore/edk2): the TDVF firmware
-
-* [Confidential Containers project](https://github.com/confidential-containers/td-shim):
-  the TDShim firmware
-
-* [TDX Tools](https://github.com/intel/tdx-tools): a collection of tools
-  and scripts to setup TDX environment for testing purpose (such as
-  installing required packages on the host, creating guest images, and
-  building the custom Linux kernel for TDX host and guest)
-
-## Cloud Hypervisor support
-
-It is required to use a machine with TDX enabled in hardware and
-with the host OS compiled from the [KVM TDX tree](https://github.com/intel/tdx/tree/kvm).
-The host environment can also be setup with the [TDX Tools](https://github.com/intel/tdx-tools).
-
-Cloud Hypervisor can run TDX VM (Trust Domain) by loading a TD firmware ([TDVF](https://github.com/tianocore/edk2)),
-which will then load the guest kernel from the image. The image must be custom
-as it must include a kernel built from the [Guest TDX tree](https://github.com/intel/tdx/tree/guest).
-Cloud Hypervisor can also boot a TDX VM with direct kernel boot using [TDshim](https://github.com/confidential-containers/td-shim).
-The custom Linux kernel for the guest can be built with the [TDX Tools](https://github.com/intel/tdx-tools).
-
-> **Note**
-> The latest version of custom host and guest kernel being tested is
-> from [TDX Tools - 2023ww01](https://github.com/intel/tdx-tools/commits/2023ww01).
-
-### TDVF
-
-> **Note**
-> The latest version of TDVF being tested is [_13b9773_](https://github.com/tianocore/edk2/commit/13b97736c876919b9786055829caaa4fa46984b7).
-
-The firmware can be built as follows:
-
-```bash
-git clone https://github.com/tianocore/edk2.git
-cd edk2
-git checkout 13b97736c876919b9786055829caaa4fa46984b7
-git submodule update --init --recursive
-make -C BaseTools
-source ./edksetup.sh
-build -p OvmfPkg/IntelTdx/IntelTdxX64.dsc -a X64 -t GCC5 -b RELEASE
-```
-
-If debug logs are needed, here is the alternative command:
-
-```bash
-build -p OvmfPkg/IntelTdx/IntelTdxX64.dsc -a X64 -t GCC5 -D DEBUG_ON_SERIAL_PORT=TRUE
-```
-
-On the Cloud Hypervisor side, all you need is to build the project with the
-`tdx` feature enabled:
-
-```bash
-cargo build --features tdx
-```
-
-And run a TDX VM by providing the firmware previously built, along with the
-guest image containing the TDX enlightened kernel. The latest image
-`td-guest-rhel8.5.raw` contains `console=hvc0` on the kernel boot parameters,
-meaning it will be printing guest kernel logs to the `virtio-console` device.
-
-```bash
-./cloud-hypervisor \
-    --platform tdx=on
-    --firmware edk2/Build/IntelTdx/RELEASE_GCC5/FV/OVMF.fd \
-    --cpus boot=1 \
-    --memory size=1G \
-    --disk path=tdx_guest_img
-```
-
-And here is the alternative command when looking for debug logs from the
-firmware:
-
-```bash
-./cloud-hypervisor \
-    --platform tdx=on
-    --firmware edk2/Build/IntelTdx/DEBUG_GCC5/FV/OVMF.fd \
-    --cpus boot=1 \
-    --memory size=1G \
-    --disk path=tdx_guest_img \
-    --serial file=/tmp/ch_serial \
-    --console tty
-```
-
-### TDShim
-
-> **Note**
-> The latest version of TDShim being tested is [_66bb334_](https://github.com/confidential-containers/td-shim/tree/66bb33451befbf1291abe3cfea7ee9e99d922b0d).
-
-This is a lightweight version of the TDVF, written in Rust and designed for
-direct kernel boot, which is useful for containers use cases.
-
-To build TDShim from source, it is required to install `Rust`, `NASM`,
-and `LLVM` first. The TDshim can be build as follows:
-```bash
-git clone https://github.com/confidential-containers/td-shim
-cd td-shim
-git checkout 66bb33451befbf1291abe3cfea7ee9e99d922b0d
-cargo install cargo-xbuild
-export CC=clang
-export AR=llvm-ar
-export CC_x86_64_unknown_none=clang
-export AR_x86_64_unknown_none=llvm-ar
-git submodule update --init --recursive
-./sh_script/preparation.sh
-cargo xbuild -p td-shim --target x86_64-unknown-none --release --features=main,tdx
-cargo run -p td-shim-tools --bin td-shim-ld --features=linker -- target/x86_64-unknown-none/release/ResetVector.bin target/x86_64-unknown-none/release/td-shim -o target/release/final.bin
-```
-
-If debug logs from the TDShim is needed, here are the alternative
-commands:
-```bash
-cargo xbuild -p td-shim --target x86_64-unknown-none --features=main,tdx
-cargo run -p td-shim-tools --bin td-shim-ld --features=linker -- target/x86_64-unknown-none/debug/ResetVector.bin target/x86_64-unknown-none/debug/td-shim -o target/debug/final.bin
-```
-
-And run a TDX VM by providing the firmware previously built, along with a guest
-kernel built from the [Guest TDX tree](https://github.com/intel/tdx/tree/guest)
-or the [TDX Tools](https://github.com/intel/tdx-tools).
-The appropriate kernel boot options must be provided through the `--cmdline`
-option as well.
-
-```bash
-./cloud-hypervisor \
-    --platform tdx=on
-    --firmware td-shim/target/release/final.bin \
-    --kernel bzImage \
-    --cmdline "root=/dev/vda3 console=hvc0 rw"
-    --cpus boot=1 \
-    --memory size=1G \
-    --disk path=tdx_guest_img
-```
-
-And here is the alternative command when looking for debug logs from the
-TDShim:
-
-```bash
-./cloud-hypervisor \
-    --platform tdx=on
-    --firmware td-shim/target/debug/final.bin \
-    --kernel bzImage \
-    --cmdline "root=/dev/vda3 console=hvc0 rw"
-    --cpus boot=1 \
-    --memory size=1G \
-    --disk path=tdx_guest_img
-```
-
-### Guest kernel limitations
-
-#### Serial ports disabled
-
-The latest guest kernel that can be found in the latest image
-`td-guest-rhel8.5.raw` disabled the support for serial ports. This means adding
-`console=ttyS0` will have no effect and will not print any log from the guest.
-
-#### PCI hotplug through ACPI
-
-Unless you run the guest kernel with the parameter `tdx_disable_filter`, ACPI
-devices responsible for handling PCI hotplug (PCI hotplug controller, PCI
-Express Bus and Generic Event Device) will not be allowed, therefore the
-corresponding drivers will not be loaded and the PCI hotplug feature will not
-be supported.

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), `ops_one_time_burst` (I/O operations),
-and `ops_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
@@ -121,29 +121,6 @@ lspci
 00:04.0 Unassigned class [ffff]: Red Hat, Inc. Virtio RNG
 ```
 
-### Work with FDT on AArch64
-
-On AArch64 architecture, the virtual IOMMU can still be used even if ACPI is not
-enabled. But the effect is different with what the aforementioned test showed.
-
-When ACPI is disabled, virtual IOMMU is supported through Flattened Device Tree
-(FDT). In this case, the guest kernel can not tell which device should be
-IOMMU-attached and which should not. No matter how many devices you attached to
-the virtual IOMMU by setting `iommu=on` option, all the devices on the PCI bus
-will be attached to the virtual IOMMU (except the IOMMU itself). Each of the
-devices will be added into a IOMMU group.
-
-As a result, the directory content of `/sys/kernel/iommu_groups` would be:
-
-```bash
-ls /sys/kernel/iommu_groups/0/devices/
-0000:00:02.0
-ls /sys/kernel/iommu_groups/1/devices/
-0000:00:03.0
-ls /sys/kernel/iommu_groups/2/devices/
-0000:00:04.0
-```
-
 ## Faster mappings
 
 By default, the guest memory is mapped with 4k pages and no huge pages, which
@@ -186,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
 ```
 
@@ -203,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
 ```
 
@@ -217,52 +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
 ```
-
-### Dedicated IOMMU PCI segments
-
-To facilitate hotplug of devices that require being behind an IOMMU it is
-possible to mark entire PCI segments as behind the IOMMU.
-
-This is accomplished through `--platform
-num_pci_segments=<number_of_segments>,iommu_segments=<range of segments>` or
-via the equivalents in `PlatformConfig` for the API.
-
-e.g.
-
-```bash
-./cloud-hypervisor \
-    --api-socket /tmp/api \
-    --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" \
-    --platform num_pci_segments=2,iommu_segments=1
-```
-
-This adds a second PCI segment to the platform behind the IOMMU. A VFIO device
-requiring the IOMMU then may be hotplugged:
-
-e.g.
-
-```bash
-./ch-remote --api-socket /tmp/api add-device path=/sys/bus/pci/devices/0000:00:04.0,iommu=on,pci_segment=1
-```
-
-Devices that cannot be placed behind an IOMMU (e.g. lacking an `iommu=` option)
-cannot be placed on the IOMMU segments.
-

docs/live_migration.md

@@ -1,139 +0,0 @@
-# Live Migration
-
-This document gives two examples of how to use the live migration
-support in Cloud Hypervisor:
-
-1. local migration - migrating between two VMs running on the same
-   machine;
-1. nested-vm migration - migrating between two nested VMs whose host VMs
-   are running on the same machine.
-
-## Local Migration (Suitable for Live Upgrade of VMM)
-Launch the source VM (on the host machine):
-```bash
-$ target/release/cloud-hypervisor
-    --kernel ~/workloads/vmlinux \
-    --disk path=~/workloads/focal.raw \
-    --cpus boot=1 --memory size=1G,shared=on \
-    --cmdline "root=/dev/vda1 console=ttyS0"  \
-    --serial tty --console off --api-socket /tmp/api1
-```
-
-Launch the destination VM from the same directory (on the host machine):
-```bash
-$ target/release/cloud-hypervisor --api-socket /tmp/api2
-```
-
-Get ready for receiving migration for the destination VM (on the host machine):
-```bash
-$ target/release/ch-remote --api-socket /tmp/api2 receive-migration unix:/tmp/sock
-```
-
-Start to send migration for the source VM (on the host machine):
-```bash
-$ target/release/ch-remote --api-socket /tmp/api1 send-migration --local unix:/tmp/sock
-```
-
-When the above commands completed, the source VM should be successfully
-migrated to the destination VM. Now the destination VM is running while
-the source VM is terminated gracefully.
-
-## Nested-VM Migration
-
-Launch VM 1 (on the host machine) with an extra virtio-blk device for
-exposing a guest image for the nested source VM:
-> Note: the example below also attached an additional virtio-blk device
-> with a dummy image for testing purpose (which is optional).
-```bash
-$ head -c 1M < /dev/urandom > tmp.img # create a dummy image for testing
-$ sudo /target/release/cloud-hypervisor \
-        --serial tty --console off \
-        --cpus boot=1 --memory size=512M \
-        --kernel vmlinux \
-        --cmdline "root=/dev/vda1 console=ttyS0"  \
-        --disk path=focal-1.raw path=focal-nested.raw --disk path=tmp.img\
-        --net ip=192.168.101.1
-```
-
-Launch VM 2 (on the host machine) with an extra virtio-blk device for
-exposing the same guest image for the nested destination VM:
-```bash
-$ sudo /target/release/cloud-hypervisor \
-        --serial tty --console off \
-        --cpus boot=1 --memory size=512M \
-        --kernel vmlinux \
-        --cmdline "root=/dev/vda1 console=ttyS0"  \
-        --disk path=focal-2.raw path=focal-nested.raw --disk path=tmp.img\
-        --net ip=192.168.102.1
-```
-
-Launch the nested source VM (inside the guest OS of the VM 1) :
-```bash
-vm-1:~$ sudo ./cloud-hypervisor \
-        --serial tty --console off \
-        --memory size=128M \
-        --kernel vmlinux \
-        --cmdline "console=ttyS0 root=/dev/vda1" \
-        --disk path=/dev/vdb --disk path=/dev/vdc \
-        --api-socket /tmp/api1 \
-        --net ip=192.168.100.1
-vm-1:~$ # setup the guest network if needed
-vm-1:~$ sudo ip addr add 192.168.101.2/24 dev ens4
-vm-1:~$ sudo ip link set up dev ens4
-vm-1:~$ sudo ip r add default via 192.168.101.1
-```
-Optional: Run the guest workload below (on the guest OS of the nested source VM),
-which performs intensive virtio-blk operations. Now the console of the nested
-source VM should repeatedly print `"equal"`, and our goal is migrating
-this VM and the running workload without interruption.
-```bash
-#/bin/bash
-
-# On the guest OS of the nested source VM
-
-input="/dev/vdb"
-result=$(md5sum $input)
-tmp=$(md5sum $input)
-
-while  [[ "$result" == "$tmp" ]]
-do
-    echo "equal"
-    tmp=$(md5sum $input)
-done
-
-echo "not equal"
-echo "result = $result"
-echo "tmp = $tmp"
-```
-
-Launch the nested destination VM (inside the guest OS of the VM 2):
-```bash
-vm-2:~$ sudo ./cloud-hypervisor --api-socket /tmp/api2
-vm-2:~$ # setup the guest network with the following commands if needed
-vm-2:~$ sudo ip addr add 192.168.102.2/24 dev ens4
-vm-2:~$ sudo ip link set up dev ens4
-vm-2:~$ sudo ip r add default via 192.168.102.1
-vm-2:~$ ping 192.168.101.2 # This should succeed
-```
-> Note: If the above ping failed, please check the iptables rule on the
-> host machine, e.g. whether the policy for the `FORWARD` chain is set
-> to `DROP` (which is the default setting configured by Docker).
-
-Get ready for receiving migration for the nested destination VM (inside
-the guest OS of the VM 2):
-```bash
-vm-2:~$ sudo ./ch-remote --api-socket /tmp/api2 receive-migration unix:/tmp/sock2
-vm-2:~$ sudo socat TCP-LISTEN:6000,reuseaddr UNIX-CLIENT:/tmp/sock2
-```
-
-Start to send migration for the nested source VM (inside the guest OS of
-the VM 1):
-```bash
-vm-1:~$ sudo socat UNIX-LISTEN:/tmp/sock1,reuseaddr TCP:192.168.102.2:6000
-vm-1:~$ sudo ./ch-remote --api-socket /tmp/api1 send-migration unix:/tmp/sock1
-```
-
-When the above commands completed, the source VM should be successfully
-migrated to the destination VM without interrupting our testing guest
-workload. Now the destination VM is running the testing guest workload
-while the source VM is terminated gracefully.

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 `-v -v` 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 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,578 +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,
-    hotplug_method: HotplugMethod,
-    hotplug_size: Option<u64>,
-    hotplugged_size: Option<u64>,
-    shared: bool,
-    hugepages: bool,
-    hugepage_size: Option<u64>,
-    prefault: bool,
-    thp: bool
-    zones: Option<Vec<MemoryZoneConfig>>,
-}
-```
-
-```
---memory <memory>	Memory parameters "size=<guest_memory_size>,mergeable=on|off,shared=on|off,hugepages=on|off,hugepage_size=<hugepage_size>,hotplug_method=acpi|virtio-mem,hotplug_size=<hotpluggable_memory_size>,hotplugged_size=<hotplugged_memory_size>,prefault=on|off,thp=on|off" [default: size=512M,thp=on]
-```
-
-### `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
-```
-
-### `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
-```
-
-### `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.
-
-If `hugepages=on` then the value of this field is ignored as huge pages always
-requires `MAP_SHARED`.
-
-_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, e.g. error with `ReadKernelImage` is common. If there is a strange
-error with `hugepages` enabled, just disable it or check whether there are enough
-huge pages.
-
-If `hugepages=on` then the value of `shared` is ignored as huge pages always
-requires `MAP_SHARED`.
-
-By default this option is turned off.
-
-_Example_
-
-```
---memory size=1G,hugepages=on,hugepage_size=2M
-```
-
-### `prefault`
-
-Specifies if the memory must be `mmap(2)` with `MAP_POPULATE` flag.
-
-By triggering prefault, one can allocate all required physical memory and create
-its page tables while calling `mmap`. With physical memory allocated, the number
-of page faults will decrease during running, and performance will also improve.
-
-Note that boot of VM will be slower with `prefault` enabled because of allocating
-physical memory and creating page tables in advance, and physical memory of the
-specified size will be consumed quickly.
-
-This option only takes effect at boot of VM. There is also a `prefault` option in
-restore and its choice will overwrite `prefault` in memory.
-
-By default this option is turned off.
-
-_Example_
-
-```
---memory size=1G,prefault=on
-```
-
-### `thp`
-
-Specifies if private anonymous memory for the guest (i.e. `shared=off` and no
-backing file) should be labelled `MADV_HUGEPAGE` with `madvise(2)` indicating
-to the kernel that this memory may be backed with huge pages transparently.
-
-The use of transparent huge pages can improve the performance of the guest as
-there will fewer virtualisation related page faults. Unlike using
-`hugepages=on` a specific number of huge pages do not need to be allocated by
-the kernel.
-
-By default this option is turned on.
-
-_Example_
-
-```
---memory size=1G,thp=on
-```
-
-## Advanced Parameters
-
-`MemoryZoneConfig` or what is known as `--memory-zone` from the CLI perspective
-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,
-    hugepage_size: Option<u64>,
-    host_numa_node: Option<u32>,
-    hotplug_size: Option<u64>,
-    hotplugged_size: Option<u64>,
-    prefault: bool,
-}
-```
-
-```
---memory-zone <memory-zone>	User defined memory zone parameters "size=<guest_memory_region_size>,file=<backing_file>,shared=on|off,hugepages=on|off,hugepage_size=<hugepage_size>,host_numa_node=<node_id>,id=<zone_identifier>,hotplug_size=<hotpluggable_memory_size>,hotplugged_size=<hotplugged_memory_size>,prefault=on|off"
-```
-
-This parameter expects one or more occurences, allowing for a list of memory
-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. The file will be opened and 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.
-
-If `hugepages=on` then the value of this field is ignored as huge pages always
-requires `MAP_SHARED`.
-
-By default this option is turned off, which result in performing `mmap(2)`
-with `MAP_PRIVATE` flag.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,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, e.g. error with `ReadKernelImage` is common. If there is a strange
-error with `hugepages` enabled, just disable it or check whether there are enough
-huge pages.
-
-If `hugepages=on` then the value of `shared` is ignored as huge pages always
-requires `MAP_SHARED`.
-
-By default this option is turned off.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G,hugepages=on,hugepage_size=2M
-```
-
-### `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
-```
-
-### `prefault`
-
-Specifies if the memory must be `mmap(2)` with `MAP_POPULATE` flag.
-
-By triggering prefault, one can allocate all required physical memory and create
-its page tables while calling `mmap`. With physical memory allocated, the number
-of page faults will decrease during running, and performance will also improve.
-
-Note that boot of VM will be slower with `prefault` enabled because of allocating
-physical memory and creating page tables in advance, and physical memory of the
-specified size will be consumed quickly.
-
-This option only takes effect at boot of VM. There is also a `prefault` option in
-restore and its choice will overwrite `prefault` in memory.
-
-By default this option is turned off.
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G,prefault=on
-```
-
-## 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 {
-    guest_numa_id: u32,
-    cpus: Option<Vec<u8>>,
-    distances: Option<Vec<NumaDistance>>,
-    memory_zones: Option<Vec<String>>,
-    sgx_epc_sections: Option<Vec<String>>,
-}
-```
-
-```
---numa <numa>	Settings related to a given NUMA node "guest_numa_id=<node_id>,cpus=<cpus_id>,distances=<list_of_distances_to_destination_nodes>,memory_zones=<list_of_memory_zones>,sgx_epc_sections=<list_of_sgx_epc_sections>"
-```
-
-### `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]`.
-
-As soon as one tries to describe a list of values, `[` and `]` must be used to
-demarcate the list.
-
-_Example_
-
-```
---cpus boot=8
---numa guest_numa_id=0,cpus=[1-3,7] 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.
-
-As soon as one tries to describe a list of values, `[` and `]` must be used to
-demarcate the list.
-
-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] 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.
-
-As soon as one tries to describe a list of values, `[` and `]` must be used to
-demarcate the list.
-
-Note that a memory zone must belong to a single NUMA node. The following
-configuration is incorrect, therefore not allowed:
-`--numa guest_numa_id=0,memory_zones=mem0 --numa guest_numa_id=1,memory_zones=mem0`
-
-_Example_
-
-```
---memory size=0
---memory-zone id=mem0,size=1G id=mem1,size=1G --memory-zone id=mem2,size=1G
---numa guest_numa_id=0,memory_zones=[mem0,mem2] --numa guest_numa_id=1,memory_zones=mem1
-```
-
-### `sgx_epc_sections`
-
-List of SGX EPC sections attached to the guest NUMA node identified by the
-`guest_numa_id` option. This allows for describing a list of SGX EPC sections
-which must be seen by the guest as belonging to the NUMA node `guest_numa_id`.
-
-Multiple values can be provided to define the list. Each value is a string
-referring to an existing SGX EPC section identifier. Values are separated from
-each other with the `,` separator.
-
-As soon as one tries to describe a list of values, `[` and `]` must be used to
-demarcate the list.
-
-_Example_
-
-```
---sgx-epc id=epc0,size=32M id=epc1,size=64M id=epc2,size=32M
---numa guest_numa_id=0,sgx_epc_sections=epc1 --numa guest_numa_id=1,sgx_epc_sections=[epc0,epc2]
-```
-
-### PCI bus
-
-Cloud Hypervisor supports only one PCI bus, which is why it has been tied to
-the NUMA node 0 by default. It is the user responsibility to organize the NUMA
-nodes correctly so that vCPUs and guest RAM which should be located on the same
-NUMA node as the PCI bus end up on the NUMA node 0.

docs/networking.md

@@ -0,0 +1,201 @@
+# 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-hypevisor.
+
+## 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.
+
+It will gain better performance for guest that has multiple queues defined for net devices while it has multiple net sessions running in userspace.
+
+To enable multiple queue support in cloud-hypervisor, multiple queue pairs will be defined, while multiple tap fds will be opened for the same tap device, it will also have multiple threads started, each thread will monitor and handle the events from each virtqueue pairs and the associated tap fd.
+
+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 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
+
+Use one `--net` command-line argument from cloud-hypervisor to specify the emulation of one or more virtual NIC's. The example below instructs cloud-hypervisor to emulate for instance 2 virtual NIC's:
+
+```bash
+./cloud-hypervisor \
+    --cpus 4 \
+    --memory "size=512M" \
+    --disk path=my-root-disk.img \
+    --kernel my-vmlinux.bin \
+    --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       |
+
+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.
+
+If the tap device is pre-created on host before guest boot up. To use multiple queue support for net device in guest, the tap device should be opened like this from host.
+
+```bash
+[root@localhost ~]# ip tuntap add name ich0 mode tap multi_queue
+```
+
+
+## Configure the tap devices
+
+After starting cloud-hypervisor as shown above, 2 tap devices with state down will become available at the host:
+
+```bash
+root@host:~# ip link show ich0
+78: ich0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
+    link/ether 72:54:12:ff:ce:6f brd ff:ff:ff:ff:ff:ff
+root@host:~# ip link show ich1
+79: ich1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
+    link/ether 06:7a:fc:1b:9a:67 brd ff:ff:ff:ff:ff:ff
+```
+
+Set the tap devices to up state:
+
+```bash
+root@host:~# ip link set up ich0
+root@host:~# ip link set up ich1
+
+root@host:~# ip link show ich0
+78: ich0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UNKNOWN mode DEFAULT group default qlen 1000
+    link/ether 72:54:12:ff:ce:6f brd ff:ff:ff:ff:ff:ff
+root@host:~# ip link show ich1
+79: ich1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UNKNOWN mode DEFAULT group default qlen 1000
+    link/ether 06:7a:fc:1b:9a:67 brd ff:ff:ff:ff:ff:ff
+```
+
+## Connect tap devices
+
+Different networking models can be used to provide external connectivity. In this example we will
+use 2 linux bridges emulating 2 different networks. The integration bridge (ich-int) in this example will also be used
+for external connectivity.
+
+Create the bridges and connect the cloud-hypervisor tap devices to the bridges:
+
+```bash
+root@host:~# brctl addbr ich-int
+root@host:~# brctl addbr ich-dpl
+root@host:~# ip link set up ich-int
+root@host:~# ip link set up ich-dpl
+root@host:~# brctl addif ich-int ich0
+root@host:~# brctl addif ich-dpl ich1
+root@host:~# brctl show
+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
+
+### Hypervisor host
+
+On the hypervisor host add the network gateway IP address of each network to the 2 linux bridges:
+
+```bash
+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
+root@host:~# route -n
+Kernel IP routing table
+Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
+0.0.0.0         192.168.178.1   0.0.0.0         UG    600    0        0 wlan1
+10.0.1.0        0.0.0.0         255.255.255.0   U     0      0        0 ich-dpl
+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.   
+
+```bash
+root@guest:~# ip link set up enp0s2
+root@guest:~# ip link set up enp0s3
+root@guest:~# ip addr add 192.168.4.2/24 dev enp0s2
+root@guest:~# ip addr add 10.0.1.2/24 dev enp0s3
+```
+
+IP connectivity between the virtual machine and the hypervisor-host can be verified by sending
+ICMP requests to the hypervisor-host for the gateway IP address from within the virtual machine:
+
+```bash
+root@guest:~# ping 192.168.4.1
+PING 192.168.4.1 (192.168.4.1) 56(84) bytes of data.
+64 bytes from 192.168.4.1: icmp_seq=1 ttl=64 time=0.456 ms
+64 bytes from 192.168.4.1: icmp_seq=2 ttl=64 time=0.226 ms
+root@guest:~# ping 10.0.1.1
+PING 10.0.1.1 (10.0.1.1) 56(84) bytes of data.
+64 bytes from 10.0.1.1: icmp_seq=1 ttl=64 time=0.449 ms
+64 bytes from 10.0.1.1: icmp_seq=2 ttl=64 time=0.393 ms
+```
+
+The connection can now be used for instance to log into the virtual machine with
+ssh under the precondition that the machine has an ssh daemon provisioned:
+
+```bash
+root@host:~# ssh root@192.168.4.2
+The authenticity of host '192.168.4.2 (192.168.4.2)' can't be established.
+ECDSA key fingerprint is SHA256:qNAUmTtDMW9pNuZARkpLQhfw+Yc1tqUDBrQp7aZGSjw.
+Are you sure you want to continue connecting (yes/no)? yes
+Warning: Permanently added '192.168.4.2' (ECDSA) to the list of known hosts.
+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.                                                         
+
+
+Last login: Fri Jul 12 13:27:56 2019 from 192.168.4.1
+root@guest:~#
+```
+
+## Internet connectivity
+
+To enable internet connectivity a default gw and a nameserver has to be set within
+the virtual machine:
+
+```bash
+root@guest:~# ip route add default via 192.168.4.1
+root@guest:~# cat /etc/resolv.conf
+options timeout:2
+domain vallis.nl
+search vallis.nl
+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       
+Server:         192.168.178.1
+Address:        192.168.178.1#53
+
+Non-authoritative answer:
+cdn-fastly.deb.debian.org       canonical name = prod.debian.map.fastly.net.
+Name:   prod.debian.map.fastly.net
+Address: 151.101.36.204
+
+root@guest:~# apt-get update
+Ign:1 http://cdn-fastly.deb.debian.org/debian stretch InRelease
+Get:2 http://cdn-fastly.deb.debian.org/debian stretch Release [118 kB]
+Get:3 http://cdn-fastly.deb.debian.org/debian stretch Release.gpg [2434 B]
+Fetched 120 kB in 1s (110 kB/s)
+```

docs/performance_metrics.md

@@ -1,29 +0,0 @@
-# Performance Metrics
-
-Cloud Hypervisor provides a [performance metrics](https://github.com/cloud-hypervisor/cloud-hypervisor/tree/main/performance-metrics)
-binary for users to generate metrics data from their own
-environment. This document describes how to generate metrics data
-quickly by using Cloud Hypervisor's development script,
-e.g. `dev_cli.sh`. The only prerequisite is [Docker installation](https://docs.docker.com/engine/install/).
-Please note that upon its first invocation, this script will pull a
-fairly large container image.
-
-To generate metrics data for all available performance tests (including
-boot time, block I/O throughput, and network throughput & latency) and
-output the result into a json file:
-
-```
-$ ./scripts/dev_cli.sh tests --metrics -- -- --report-file /tmp/metrics.json
-```
-
-To get a list of available performance tests:
-
-```
-$ ./scripts/dev_cli.sh tests --metrics -- -- --list-tests
-```
-
-To generate metrics data for selected performance tests, e.g. boot time only:
-
-```
-$ ./scripts/dev_cli.sh tests --metrics -- -- --report-file /tmp/metrics.json --test-filter boot_time
-```

docs/profiling.md

@@ -1,56 +0,0 @@
-# Profiling
-
-`perf` can be used to profile the `cloud-hypervisor` binary but it is necessary to make some modifications to the build in order to produce a binary that gives useful results.
-
-## Building a suitable binary
-
-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 --profile profiling
-```
-
-## Profiling
-
-`perf` may then be used in the usual manner:
-
-e.g.
-
-```
-$ perf record -g target/profiling/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.
-
-## Userspace only profiling with LBR
-
-The use of LBR (Last Branch Record; available since Haswell) offers lower
-overhead if only userspace profiling is required. This lower overhead can allow
-a higher frequency of sampling. This also removes the requirement to compile
-with custom `RUSTFLAGS` however debug symbols should still be included:
-
-e.g.
-
-```
-$ perf record --call-graph lbr --all-user --user-callchains -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
-```