bzdula / core-os-riscv

🖥️ An xv6-like operating system on RISC-V with multi-core support. Documentation available online.

core-os-riscv

An xv6-like operating system in Rust.

This project is originally based on "The Adventures of OS: Making a RISC-V Operating System using Rust", and is now being made to have an xv6-like structure.

You may browse this repo with Sourcegraph.

Build Instructions

macOS

First of all, install GNU RISC-V tools and QEMU. Python3 is also required to generate some files automatically.

brew tap riscv/riscv
brew install riscv-tools
brew test riscv-tools
brew install qemu

Don't forget to add riscv-tools to PATH.

Then, install Rust and related components.

cargo default nightly
cargo install cargo-xbuild cargo-binutils
rustup component add rust-src llvm-tools-preview rustfmt
rustup target add riscv64gc-unknown-none-elf

Finally you may build and run this project.

make qemu

If you want to use readelf tools, etc., you may install pwntools on macOS.

Ubuntu

Use Linuxbrew.

Documentation

(documentation automatically built with travis)

Documentation of this repo is automatically built and deployed with Travis. You may view online version here, syscall specification here.

make && make docs

I'll continuously add Rust-specific implementations and how I made this project into documentation.

Roadmap

Update I haven't maintained this project for a while, as I'm busy with my course-works. The long-term plan of this project is that, I'll leverage Rust async features to schedule kernel threads, therefore eliminating the need of sleeplock.

The main goal of this project is to make an xv6-like operating system with the Rust programming language. And then, I'll separate arch-dependent part and make it into an OS supporting multiple architecture and multiple boards.

• Adapt code from http://osblog.stephenmarz.com/

• Virtual Memory and Management
  • Virtual Memory
  • Load ELF files from memory
  • Kernel Allocator
  • Remove direct call to allocator
  • (WIP) Add guard page around stack page
• Traps and Interrupt, Drivers
  • UART drivers
  • Machine-mode Timer Interrupt
  • External interrupt
  • Spinlock-based Virt-IO driver
  • Sleeplock-based Virt-IO driver (#2)
  • Handle signals in a Rust way (#1)
• Process and Scheduling
  • Switch to User-mode
  • Process
  • System call
  • Scheduling
  • Test multiple process scheduling
  • Fork system call
  • Timer-interrupt-based scheduling
  • Multi-core support
  • Use initcode instead of init binary
  • Allocator and stdlib in user-space
  • (WIP) Implement wait syscall
  • Simple shell
  • Investigate frequent kernel panic (#8)
  • Reimplement process scheduling system (#9)
• Filesystem
  • Fake fs and exec system call
  • Real spinlock instead of nulllock
  • Implement simple fs (#5)
  • Implement read, write, open, close, dup, etc. syscalls
  • Implement file-related syscalls on file system and eliminate use of Mutex (#5)
  • Implement pipe
  • Copyin and Copyout implementation
  • Don't use Box in fs implementation
• Miscellaneous
  • (WIP) Replace Makefile with pure Rust toolchain (cargo build script)
  • Use Option instead of panic!
  • Eliminate use of unsafe
  • Documentation
  • High-level abstractions (driver, vm, etc.)
  • Port to aarch64 and deploy on Raspi
  • Rewrite and credit code from other sources
  • RISC-V codegen issues (#6)
  • Security issues (#7)

Reference

• https://github.com/rust-embedded/rust-raspi3-OS-tutorials
• https://github.com/bztsrc/raspi3-tutorial/
• https://os.phil-opp.com/
• http://osblog.stephenmarz.com/
• https://github.com/mit-pdos/xv6-riscv/
• https://pdos.csail.mit.edu/6.828/2012/labs
• https://gist.github.com/cb372/5f6bf16ca0682541260ae52fc11ea3bb
• https://github.com/rcore-os/rCore

For how these projects are related to core-os, refer to #3.

License

MIT