tiny_os

Tiny OS

Introduction

Tiny OS is an operating system running on the x86_64 architecture.

Environment configuration

Development Platform

This project is developed on linux system. On windows systems, you can run linux subsystem by installing WSL .

If you are using WSL :

• Install an X Server in windows ; it is recommended to install Xming or VcXsvr.
  • You need to start X Server through -ac , or check disable access control through the GUI.
• In WSL :
  • If using WSL (version 1):

   export DISPLAY=:0

  • If using WSL2 (version 2):

   export DISPLAY= $( cat /etc/resolv.conf | grep nameserver | awk ' {print $2} ' ) :0

  If you don't want to enter the above statement every time you open a terminal, add it to the end of the ~/.bashrc or ~/.profile file.
• If an error like Could not initialize SDL (No available video device) ... or any errors about GTK, check if your X Server is started and if the environment variable DISPLAY is set correctly.

Rust

Rust is a modern system-level programming language, and this project is mainly developed using Rust language. Download and install it through the Rust official website. Note: This project requires the installation of nightly version of the toolchain.

After the installation is complete, install llvm-tools via rustup :

rustup component add llvm-tools-preview

Install some useful tools through cargo for development:

cargo install cargo-binutils

Install bochs emulator

Simulation via bochs simulator. Source code download link: Source Forge -- Bochs x86 PC emulator. After downloading, compile and install.

Compile the kernel

The command is as follows:

cargo run --release

The compiled kernel image path is target/os.img .

Prepare for mirroring

Create an os.img file in the ./bochs directory through bximage :

bximage -func=create -hd=10M -imgmode=flat ./bochs/os.img -q

Engrave ./target/os.img into ./bochs/os.img through the dd tool:

 # 注意下面的参数 count 要根据生成的 target/os.img 文件的大小进行调整
dd if=target/os.img of=bochs/os.img bs=512 count=250 conv=notrunc

Run bochs

bochs/conf has the following configuration files in the directory:

• bochsdbg-gdb.bxrc : You can remotely debug through gdb and bind localhost:1234 (you need to enable --enable-gdb-stub when compiling bochs )
• bochsdbg-win : Open bochs debugger with graphical interface on the window platform
• bochsrc.bxrc : The most basic bochs configuration file, without debug function

Run bochs to enable simulation:

bochs -q -f bochs/conf/bochsrc.bxrc

Run qemu

Unlike bochs , qemu can directly load the generated target/os.img :

qemu-system-x86_64 -drive format=raw,file=bochs/os.img -boot c

Makefile

There is a Makefile file in the root directory of the project, which defines some running and debugging commands:

• clean : used to clean the generated files
• build-release : used to compile release version kernel images
• build-debug : used to compile debug version kernel images (not completed)
• run-bochs : Used to compile kernel images and start bochs simulation
• run-qemu : Used to compile kernel images and start qemu simulation
• debug-bochs : Used to compile kernel images, start bochs and remote debug via rust-gdb
• debug-qemu : Used to compile kernel images, start qemu and remote debug via rust-gdb

Project structure

This project is mainly divided into 4 parts:

• builder : Located in the src directory, it is mainly used to compile and build kernel images
• boot : Located in the boot directory, it is bootloader for tiny OS
• boot_info : Located in the boot_info directory, it provides BootInfo structure
• kernel : Located in the kernel directory, it is the kernel code of tiny OS

Development Plan

• bootloader
  • Enter protection mode
  • Turn on paging management
  • Turn on the VGA graphics display mode
  • Get memory_map via 0xE820 BIOS function
  • Enter long mode
  • Prepare the BootInfo structure for passing information from bootloader stage to kernel
  • Loading kernel elf file
  • Map the virtual address for the kernel code and jump to the kernel to run
• kernel
  • Prepare logger (used to implement tiny os printing functions and debug during kernel development)
  • Handle various exceptions and interrupts
    • Preliminary processing of clock interrupts
    • Preliminary processing of keyboard input
    • Preliminary processing Page Fault
    • Preliminary processing of GP Fault
    • Handle Double Fault
  • Implement dynamic memory allocator
    • Implement preliminary memory allocation through linked_list_allocator
    • Implement buddy system memory allocator
  • Implement multitasking (preemptive scheduling)
  • Implement kernel-level collaborative scheduling
    • Preliminary implementation
    • Better scheduling algorithm
    • Implement globally available spawn
  • Implementing FAT32 file system
  • Implement shell
• Compilation
  • Implement a more flexible Builder (you can choose to compile debug and release images)
  • Generate a kernel image that bochs can be loaded directly, instead of engraving it into bochs/os.img through the dd tool

References

• AMD64 Architecture Programmer's Manual Volume 2: System Programming
• Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3 (3A, 3B, 3C & 3D): System Programming Guide
• "Restore of the Operating System" Zheng Gang
• Coding Master Series Video: bilibili -- Coding Master
• OsDev: OsDev
• blog os: Writing an OS in Rust