Step 0-1: add a hello-world hypervisor

Author: equation314

.github/workflows/build.yml

@@ -0,0 +1,45 @@
+name: Build CI
+
+on: [push, pull_request]
+
+jobs:
+  clippy:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: [x86_64]
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: nightly-2022-11-03
+        override: true
+        components: rust-src, clippy, rustfmt
+    - name: Clippy
+      run: make -C hypervisor clippy ARCH=${{ matrix.arch }}
+    - name: Check code format
+      run: cd hypervisor && cargo fmt -- --check
+
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        arch: [x86_64]
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: nightly-2022-11-03
+        components: rust-src, llvm-tools-preview
+    - uses: actions-rs/install@v0.1
+      with:
+        crate: cargo-binutils
+        version: latest
+        use-tool-cache: true
+    - name: Build hypervisor
+      run: make -C hypervisor ARCH=${{ matrix.arch }}

.gitignore

@@ -1,3 +1,5 @@
 target
 .vscode
 .DS_Store
+rvm/Cargo.lock
+!hypervisor/Cargo.lock

README.md

@@ -1,3 +1,36 @@
 # RVM-Tutorial
 
 Let's write an x86 hypervisor in Rust from scratch!
+
+## Install Build Dependencies
+
+Install [cargo-binutils](https://github.com/rust-embedded/cargo-binutils) to use `rust-objcopy` and `rust-objdump` tools:
+
+```console
+$ cargo install cargo-binutils
+```
+
+## Build & Run Hypervisor
+
+```console
+$ cd hypervisor
+$ make run [LOG=warn|info|debug|trace]
+......
+Booting from ROM..
+
+    RRRRRR  VV     VV MM    MM
+    RR   RR VV     VV MMM  MMM
+    RRRRRR   VV   VV  MM MM MM
+    RR  RR    VV VV   MM    MM
+    RR   RR    VVV    MM    MM
+     ___    ____    ___    ___
+    |__ \  / __ \  |__ \  |__ \
+    __/ / / / / /  __/ /  __/ /
+   / __/ / /_/ /  / __/  / __/
+  /____/ \____/  /____/ /____/
+
+arch = x86_64
+build_mode = release
+log_level = info
+......
+```

hypervisor/Cargo.lock

@@ -0,0 +1,17 @@
+[package]
+name = "rvm-hypervisor"
+version = "0.1.0"
+edition = "2021"
+authors = ["Yuekai Jia <equation618@gmail.com>"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+log = "0.4"
+spin = "0.9"
+cfg-if = "1.0"
+bitflags = "1.3"
+
+[target.'cfg(target_arch = "x86_64")'.dependencies]
+x86 = "0.52"
+x86_64 = "0.14"

hypervisor/Cargo.toml

@@ -0,0 +1,63 @@
+# Arguments
+ARCH ?= x86_64
+MODE ?= release
+LOG ?= warn
+
+export ARCH
+export MODE
+export LOG
+
+# Paths
+target_elf := target/$(ARCH)/$(MODE)/rvm-hypervisor
+target_bin := $(target_elf).bin
+
+build_args := --target $(ARCH).json -Zbuild-std=core,alloc -Zbuild-std-features=compiler-builtins-mem
+ifeq ($(MODE), release)
+  build_args += --release
+endif
+
+# Binutils
+OBJDUMP := rust-objdump -d --print-imm-hex --x86-asm-syntax=intel
+OBJCOPY := rust-objcopy --binary-architecture=$(ARCH)
+GDB := gdb-multiarch
+
+# QEMU
+qemu := qemu-system-$(ARCH)
+qemu_args := -nographic -m 128M
+
+qemu_args += -cpu host -accel kvm
+
+ifeq ($(ARCH), x86_64)
+  qemu_args += \
+    -machine q35 \
+    -serial mon:stdio \
+    -kernel $(target_elf)
+endif
+
+build: $(target_bin)
+
+$(target_bin): elf
+	@$(OBJCOPY) $(target_elf) --strip-all -O binary $@
+
+elf:
+	@echo Arch: $(ARCH)
+	cargo build $(build_args)
+
+clean:
+	cargo clean
+
+clippy:
+	cargo clippy $(build_args)
+
+fmt:
+	cargo fmt
+
+disasm:
+	@$(OBJDUMP) $(target_elf) | less
+
+run: build justrun
+
+justrun:
+	$(qemu) $(qemu_args)
+
+.PHONY: build elf clean clippy disasm run justrun

hypervisor/Makefile

@@ -0,0 +1,55 @@
+OUTPUT_ARCH(x86_64)
+
+BASE_ADDRESS = 0xffffff8000200000;
+
+ENTRY(_start)
+SECTIONS
+{
+    . = BASE_ADDRESS;
+    skernel = .;
+
+    .text : {
+        stext = .;
+        *(.text.boot)
+        *(.text .text.*)
+        . = ALIGN(4K);
+        etext = .;
+    }
+
+    .rodata : {
+        srodata = .;
+        *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
+        . = ALIGN(4K);
+        erodata = .;
+    }
+
+    .data : {
+        sdata = .;
+        *(.data.boot_page_table)
+        *(.data .data.*)
+        *(.sdata .sdata.*)
+        *(.got .got.*)
+        . = ALIGN(4K);
+        edata = .;
+    }
+
+    .bss : {
+        boot_stack = .;
+        *(.bss.stack)
+        . = ALIGN(4K);
+        boot_stack_top = .;
+
+        sbss = .;
+        *(.bss .bss.*)
+        *(.sbss .sbss.*)
+        . = ALIGN(4K);
+        ebss = .;
+    }
+
+    ekernel = .;
+
+    /DISCARD/ : {
+        *(.eh_frame) *(.eh_frame_hdr)
+    }
+}

hypervisor/linker.lds

@@ -0,0 +1,6 @@
+cfg_if::cfg_if! {
+    if #[cfg(target_arch = "x86_64")] {
+        mod x86_64;
+        pub use self::x86_64::*;
+    }
+}

hypervisor/src/arch/mod.rs

@@ -0,0 +1,26 @@
+use core::arch::global_asm;
+
+use x86_64::registers::control::{Cr0Flags, Cr4Flags};
+use x86_64::registers::model_specific::EferFlags;
+
+use crate::config::{BOOT_KERNEL_STACK_SIZE, PHYS_VIRT_OFFSET};
+
+const CR0: u64 = Cr0Flags::PROTECTED_MODE_ENABLE.bits()
+    | Cr0Flags::MONITOR_COPROCESSOR.bits()
+    | Cr0Flags::TASK_SWITCHED.bits()
+    | Cr0Flags::NUMERIC_ERROR.bits()
+    | Cr0Flags::WRITE_PROTECT.bits()
+    | Cr0Flags::PAGING.bits();
+const CR4: u64 = Cr4Flags::PHYSICAL_ADDRESS_EXTENSION.bits() | Cr4Flags::PAGE_GLOBAL.bits();
+const EFER: u64 = EferFlags::LONG_MODE_ENABLE.bits() | EferFlags::NO_EXECUTE_ENABLE.bits();
+
+global_asm!(
+    include_str!("multiboot.S"),
+    main_entry = sym crate::main,
+    offset = const PHYS_VIRT_OFFSET,
+    boot_stack_size = const BOOT_KERNEL_STACK_SIZE,
+    cr0 = const CR0,
+    cr4 = const CR4,
+    efer_msr = const x86::msr::IA32_EFER,
+    efer = const EFER,
+);

hypervisor/src/arch/x86_64/boot.rs

@@ -0,0 +1,9 @@
+mod boot;
+
+pub mod uart16550;
+
+pub use uart16550 as uart;
+
+pub fn init_early() {
+    uart::init();
+}