Skip to content

Latest commit

 

History

History
68 lines (53 loc) · 3.19 KB

README.md

File metadata and controls

68 lines (53 loc) · 3.19 KB
Raw

ADVOS: RISC-V Operating System in Rust

Overview

ADVOS is an operating system developed for RISC-V architecture, particularly targeting SiFive's HiFive1 board. Written in Rust, ADVOS aims to leverage the safety and concurrency features of Rust to build a robust and efficient operating system. The project includes custom implementations for memory management, process scheduling, console I/O, and more, making it a comprehensive example of a modern OS.

Features

1. Memory Management

ADVOS implements a custom memory manager that includes functionalities for:

  • Allocation and deallocation of memory blocks (kmalloc, kfree).
  • Memory coalescing to manage fragmentation.

2. Process Scheduling

The scheduler in ADVOS uses a round-robin algorithm with the following features:

  • Support for multiple processes with context switching.
  • A simple process control block (PCB) structure to manage process states.
  • System call handling to support process exit and other operations.

3. Console I/O

The console module provides basic input/output functionalities via UART, including:

  • Writing strings and characters to the console.
  • Reading characters from the console.

4. Trap Handling

ADVOS includes a comprehensive trap handling mechanism to manage:

  • Timer interrupts for context switching.
  • Software and hardware interrupts.
  • Exception handling to maintain system stability.

5. Filesystem

A simple filesystem interface to interact with storage, providing:

  • Superblock reading to gather filesystem metadata.
  • Inode reading for accessing file data.
  • Support for printing data blocks and handling indirect block pointers.

Repository Structure

The repository is structured as follows:

  • Makefile: Build automation script using make.
  • Cargo.toml: Rust package configuration.
  • Xargo.toml: Xargo configuration for cross-compilation.
  • asm/: Assembly files for bootstrapping and low-level operations.
    • start.S: Entry point and initial setup.
    • mem.S: Memory layout definitions.
    • trap.S: Trap and interrupt handling.
    • fs.S: Filesystem definitions.
  • lds/: Linker script for memory layout.
    • hifive.lds: Linker script for SiFive HiFive1 board.
  • src/: Rust source files.
    • lib.rs: Main module and entry point for the OS.
    • global_constants.rs: Constants used throughout the OS.
    • memman/mod.rs: Memory manager implementation.
    • scheduler/mod.rs: Scheduler and process management.
    • sys/: System call handling.
    • lock/mod.rs: Synchronization primitives like mutexes and barriers.
    • console/mod.rs: Console input/output.
    • filesystem/mod.rs: Filesystem management.
    • utils/mod.rs: Utility modules, including custom data structures.

License

This project is licensed under the MIT License. See the LICENSE file for details.

ADVOS demonstrates the potential of using Rust for systems programming, providing a modern and safe approach to building an operating system. Whether you are an enthusiast or a professional, exploring ADVOS will give you insights into low-level programming and OS development on RISC-V architecture.