Let's write an OS which can run on x86_64 in Rust from scratch

Overview

rCore-Tutorial-v3

rCore-Tutorial version 3.5. See the Documentation in Chinese.

news

  • 2021.11.20: Now we are updating our labs. Please checkout chX-dev Branches for our current new labs. (Notice: please see the [Dependency] section in the end of this doc)

Overview

This project aims to show how to write an Unix-like OS running on RISC-V platforms from scratch in Rust for beginners without any background knowledge about computer architectures, assembly languages or operating systems.

Features

  • Platform supported: qemu-system-riscv64 simulator or dev boards based on Kendryte K210 SoC such as Maix Dock
  • OS
    • concurrency of multiple processes
    • preemptive scheduling(Round-Robin algorithm)
    • dynamic memory management in kernel
    • virtual memory
    • a simple file system with a block cache
    • an interactive shell in the userspace
  • only 4K+ LoC
  • A detailed documentation in Chinese in spite of the lack of comments in the code(English version is not available at present)

Run our project

TODO:

Working in progress

Now we are still updating our project, you can find latest changes on branches chX-dev such as ch1-dev. We are intended to publish first release 3.5.0 after completing most of the tasks mentioned below.

Overall progress: ch7

Completed

  • automatically clean up and rebuild before running our project on a different platform
  • fix power series application in early chapters, now you can find modulus in the output
  • use UPSafeCell instead of RefCell or spin::Mutex in order to access static data structures and adjust its API so that it cannot be borrowed twice at a time(mention & .exclusive_access().task[0] in run_first_task)
  • move TaskContext into TaskControlBlock instead of restoring it in place on kernel stack(since ch3), eliminating annoying task_cx_ptr2
  • replace llvm_asm! with asm!
  • expand the fs image size generated by rcore-fs-fuse to 128MiB
  • add a new test named huge_write which evaluates the fs performance(qemu~500KiB/s k210~50KiB/s)
  • flush all block cache to disk after a fs transaction which involves write operation
  • replace spin::Mutex with UPSafeCell before SMP chapter
  • add codes for a new chapter about synchronization & mutual exclusion(uniprocessor only)

Todo(High priority)

  • support Allwinner's RISC-V D1 chip
  • bug fix: we should call find_pte rather than find_pte_create in PageTable::unmap
  • bug fix: check validity of level-3 pte in find_pte instead of checking it outside this function
  • use old fs image optionally, do not always rebuild the image
  • add new system calls: getdents64/fstat
  • shell functionality improvement(to be continued...)
  • give every non-zero process exit code an unique and clear error type
  • effective error handling of mm module

Todo(Low priority)

  • rewrite practice doc and remove some inproper questions
  • provide smooth debug experience at a Rust source code level
  • format the code using official tools

Crates

We will add them later.

You might also like...
A language-based OS to run Rust on bare metal

RustOS A simple, language-based OS. Current features: Simple VGA for seeing output Some Rust libraries (core, alloc, collections) already in Working (

A library that makes it VERY easy to run Holochain as a library, from your own binary, with great defaults

embedded-holochain-runner A library that makes it VERY easy to run Holochain as a library, from your own binary, with great defaults How it will work

A lightweight microkernel/IPC based operating system built with Rust which is not a clone of any existing operating system
A lightweight microkernel/IPC based operating system built with Rust which is not a clone of any existing operating system

Noble Operating System Noble is a lightweight microkernel and IPC based operating system built with Rust which is not a clone of any existing operatin

A Rust-based userland which also adds compile-time assurances to seL4 development.

ferros Overview A Rust library to add extra assurances to seL4 development. ferros provides smart type-safe wrappers around seL4 features with an emph

A comparison of operating systems written in Rust

Rust OS comparison A comparison of operating systems written in Rust. There are several open source operating systems written in Rust. Most of them ar

An OS kernel written in rust. Non POSIX

"Tifflin" Experimental Kernel (and eventually Operating System) This is an experiment in writing an OS Kernel in rust (http://rust-lang.org). Mostly t

A hobby operating system, in Rust

intermezzOS: kernel intermezzOS is a hobby operating system. This repository is for its kernel. See the website for more. License This project is dual

A Rust version of the Weenix OS

Reenix This is the start of a unix like operating system written in Rust. It is based on the Weenix Operating system written for Brown's CS167/9. At t

A tiny 32 bit kernel written in Rust
A tiny 32 bit kernel written in Rust

rustboot A tiny 32 bit kernel written in Rust. I was inspired to download Rust and try to do this after seeing zero.rs - a stub that lets Rust program

Owner
rCore OS
THU Rust operating system workshop. (mirror: https://gitee.com/rcore-os)
rCore OS
RCore-Tutorial-v3 - Let's write an OS which can run on RISC-V in Rust from zero!

rCore-Tutorial-v3 rCore-Tutorial version 3.5. See the Documentation in Chinese. Official QQ group number: 735045051 news 2021.11.20: Now we are updati

rCore OS 786 Jan 2, 2023
Distrod is a meta-distro for WSL 2 which runs Systemd as init process. You can run Ubuntu, Arch, and et.c with systemd in a minute. Distrod also has built-in auto-start feature on Windows startup and port forwarding abiltiy.

Distrod - WSL2 Distros with Systemd! Distrod is a systemd-based meta-distro for WSL2 that allows you to install Ubuntu, Arch Linux, Gentoo and many ot

Takaya Saeki 1.6k Jan 9, 2023
Minimal x86_64 OS kernel written in Rust

rkernel A minimal x86_64 Rust OS kernel. Multiboot2 VGA driver PIC PIT PS/2 Keyboard driver PS/2 Mouse driver TSC RTC Allocator ATA PIO (In progress..

Divy Srivastava 36 Apr 26, 2022
Rux - An x86_64 toy operating system kernel written in Rust

Rux - An x86_64 toy operating system kernel written in Rust. Rux is a port of the Hux kernel, my x86 32-bit single-CPU toy kernel written in C, following the OSTEP book structure and terminology.

Guanzhou Jose Hu 6 Feb 26, 2022
💻 An x86_64 kernel in the works

BruhOS a basic x86_64 kernel in the works. cool stuff written in rust boots with any stivale2-compliant bootloader framebuffer bitmap font renderer pm

Safin Singh 9 Jun 8, 2021
Revons Os is a new OS written from scratch in Rust to experiment with novel OS structure

Revons Os is a new OS written from scratch in Rust to experiment with novel OS structure, better state management, and how to leverage intralingual design principles to shift OS responsibilities like resource management into the compiler.

Fayssal Chokri 1 Jul 2, 2022
RevonsOs is a new OS written from scratch in Rust to experiment with novel OS structure, better state management

RevonsOs is a new OS written from scratch in Rust to experiment with novel OS structure, better state management, and how to leverage intralingual design principles to shift OS responsibilities like resource management into the compiler.

Revons Community 3 Mar 14, 2022
Learn to write an embedded OS in Rust

Operating System development tutorials in Rust on the Raspberry Pi

Rust Embedded 9.9k Jan 6, 2023
Examples on how to write Windows kernel drivers in Rust

windows-kernel-rs Note: this is still work in progress! This is a Windows kernel framework in Rust that consists of windows-kernel-sys, a crate that p

S.J.R. van Schaik 77 Dec 28, 2022
A language-based OS to run Rust on bare metal

RustOS A simple, language-based OS. Current features: Simple VGA for seeing output Some Rust libraries (core, alloc, collections) already in Working (

null 402 Dec 8, 2022