A teaching operating system written in Rust
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.cargo add support of paging and a simple demo for process creation Jan 1, 2019
demo add demo application Jan 24, 2019
img increase image size Jan 26, 2019
src remove obsolete statement Feb 7, 2019
.gitignore add *.o to the list of ignored files Jan 25, 2019
.gitmodules remove submodule x86 Jan 4, 2019
.travis.yml enable submodule support Sep 4, 2018
Cargo.toml add basic user-space support and an interface to Linux Jan 24, 2019
LICENSE simplify KVM support, add first draft of macOS support Sep 3, 2018
Makefile remove label "demo" Jan 25, 2019
README.md
azure-pipelines.yml install also eHyve on all test systems Nov 2, 2018
rust-toolchain remove ehyve from repository Sep 26, 2018
setup_tests.sh
tests_inside_docker.sh install ehyve within the docker containers Dec 5, 2018
x86_64-eduos.json remove ehyve from repository Sep 26, 2018

README.md

eduOS-rs - A teaching operating system written in Rust

Status

Build & Test
all OS' Build & Test
Linux only Build & Test

Introduction

eduOS-rs is a Unix-like operating system based on a monolithic architecture for educational purposes. It is developed for the course Operating Systems at RWTH Aachen University and includes a modified hypervisor that simplifies the boot process to increase the intelligibility of the OS. eduOS-rs is derived from following tutorials and software distributions:

  1. Philipp Oppermann's excellent series of blog posts.
  2. Erik Kidd's toyos-rs, which is an extension of Philipp Opermann's kernel.
  3. The original version of eduOS, which was the old teaching kernel written in C.

Requirements to build eduOS-rs

eduOS-rs is tested under Linux, macOS, and Windows.

macOS

Apple's Command Line Tools must be installed. The Command Line Tool package gives macOS terminal users many commonly used tools and compilers, that are usually found in default Linux installations. Following terminal command installs these tools without Apple's IDE Xcode:

$ xcode-select --install

Windows

To build eduOS-rs you have to install a linker, make and a git client. We tested the eduOS-rs with the linker from Visual Studio. Consequently, we suggest installing Visual Studio in addition to make and git.

Linux

Linux users should install common developer tools. For instance, on Ubuntu 18.04 the following command installs the required tools:

$ apt-get install -y curl wget nasm make autotools-dev gcc g++ build-essential

Common for macOS, Windows and Linux

It is required to install the Rust toolchain. Please visit the Rust website and follow the installation instructions for your operating system. It is important that the nightly channel is used to install the toolchain. This is queried during installation and should be answered as appropriate.

Afterwards the installation of cargo-xbuild and the source code of Rust runtime are required to build the kernel:

$ cargo install cargo-xbuild
$ rustup component add rust-src

eduOS-rs is able to run within ehyve, which a specialized hypervisor for eduOS-rs. Therefore ehyve must be installed.

$ cargo install --git https://github.com/RWTH-OS/ehyve.git

Please check if your system fullfil ehyve's system requirements.

Building

The final step is to create a copy of the repository and to build the kernel:

$ # Get our source code.
$ git clone https://github.com/RWTH-OS/eduOS-rs.git
$ cd eduOS-rs

$ # Build kernel
$ make

From here, we should be able to run the kernel in ehyve:

$ make run

Overview of all branches

Step by step (here branch by branch) the operating system design will be introduced. This tutorial shows the steps to develop from a minimal kernel to a Unix-like computer operating system. Currently, following stages of development are available:

  1. stage0 - Smallest HelloWorld of the World

    Description of loading a minimal 64bit kernel

  2. stage1 - Cooperative/non-preemptive multitasking

    Introduction into a simple form of multitasking, where no interrupts are required.

  3. stage2 - Priority-based cooperative/non-preemptive multitasking

    Introduction into a simple form of priority-based multitasking, where no interrupts are required.

  4. stage3 - Synchronization primitives

    Introduce basic synchronization primitives

  5. stage 4 - Preemptive multitasking

    Introduction into preemptive multitasking and interrupt handling

  6. stage 5 - Support of user-level tasks

    Add support of user-level tasks with an small interface for basic system calls

  7. stage 6 - Support of paging

    Add support of paging and a simple demo for process creation

  8. stage 7 - Integration of an in-memory file system

    Introduce a virtual file system with an in-memory file system as example file system.

  9. stage8 - Run Linux application as common process

    Start a simple Linux application (HelloWorld) on top of eduOS-rs. The application is a position-independent executable (PIE) and use musl-libc as standard C library.

Useful Links

  1. http://www.gnu.org/software/grub/manual/multiboot/
  2. http://www.osdever.net/tutorials/view/brans-kernel-development-tutorial
  3. http://www.jamesmolloy.co.uk/tutorial_html/index.html
  4. http://techblog.lankes.org/tutorials/
  5. http://www.os.rwth-aachen.de
  6. http://www.noteblok.net/2014/06/14/bachelor
  7. https://sourceware.org/newlib/
  8. http://rwth-os.github.io/eduOS/
  9. https://intermezzos.github.io

Licensing

eduOS-rs is licensed under the MIT license.