chyyuu/os_kernel_lab
Os Kernel Lab
This project is an educational framework and toolkit designed for developing and testing operating system kernels. It provides a structured environment for implementing fundamental system primitives, including virtual memory management, preemptive process scheduling, and filesystem organization, using Rust and C. The framework is specifically oriented toward RISC-V and x86 architectures, serving as a laboratory for learning how to build core system software from the ground up.
The project distinguishes itself by supporting both bare-metal deployment and hardware emulation, allowing developers to validate kernel logic on physical hardware or within simulated environments. It includes a comprehensive build toolchain that handles cross-architecture compilation and firmware initialization, ensuring that the kernel can be properly bootstrapped and executed across different target platforms.
The system covers a broad range of low-level capabilities, including hardware abstraction layers that decouple system logic from specific processor designs and system-call interfaces that manage the boundary between user-space applications and kernel services. It also incorporates observability features, such as runtime logging and execution monitoring, to assist in the analysis of system behavior during development.
Features
- Operating System Development - Builds and tests core operating system components like memory management, process scheduling, and file systems from scratch.
- RISC-V Kernel Implementations - Provides an educational framework for building and testing operating system kernels on RISC-V and x86 architectures.
- Hardware Abstraction Layers - Decouples core system logic from specific processor architectures by providing a unified interface for hardware interactions.
- Kernel Development - Provides core system primitives including process management, memory allocation, and file storage for kernel development.
- Educational Kernel Projects - Offers a collection of laboratory exercises for implementing core operating system primitives like process scheduling and memory management.
- Memory Management - Manages dynamic memory allocation and virtual address spaces for kernel operations and system processes.
- Kernel Memory Implementations - Implements virtual memory paging and address space isolation for kernel and user-space operations.
- Kernel Process Internals - Manages process lifecycles, thread support, and preemptive scheduling within the kernel.
- System Call Interfaces - Provides a secure boundary between user-space applications and kernel-level services through controlled software interrupts.
- Virtual Memory Mapping - Maps logical memory addresses to physical hardware locations to provide isolated and protected address spaces.
- Round-Robin Schedulers - Coordinates task execution using preemptive round-robin scheduling to ensure fair processor time distribution.
- Kernel Build Systems - Transforms source code into executable machine instructions compatible with target hardware architectures using specialized optimization utilities.
- Multi-Architecture Builds - Automates cross-compilation for multiple CPU targets using specialized toolchains and linker scripts.
- Cross-Platform Execution - Supports execution on both virtualized emulators and physical hardware platforms to ensure consistent performance and compatibility.
- Bare Metal Orchestration - Supports direct execution on physical hardware platforms to validate performance and functionality in real-world environments.
- Embedded Systems Education - Provides learning resources for implementing fundamental system software and hardware interactions in resource-constrained environments.
- RISC-V Software Development - Develops and debugs low-level software specifically designed to run on RISC-V hardware architectures and instruction sets.
- Bare Metal Deployment Environments - Executes compiled code directly on physical hardware platforms to validate system performance and low-level functionality.
- Custom Firmware Bootloaders - Initializes the hardware environment and loads the kernel image into memory during the system startup sequence.
- System Boot Initializers - Prepares the execution environment by loading firmware and establishing essential hardware-level interactions during system startup.
- Bare Metal Development - Provides a set of tools and source code for developing software that executes directly on hardware or within emulated environments.
- Hardware Emulators - Simulates processor and peripheral device behavior to verify software logic without requiring access to physical hardware.
- System Emulators - Simulates complex hardware environments to verify and debug kernel logic before deploying software to physical processor targets.
