phil-opp/blog_os
Blog Os
This project is a freestanding kernel written in Rust that boots on x86 hardware without a standard library. It serves as a low-level system implementation focusing on the creation of a bare metal operating system.
The system implements a bootable disk image toolchain that transforms source code into binaries compatible with a bootloader. It features a custom memory allocator for dynamic memory management and an x86 kernel implementation that includes paging, interrupt handling, and VGA text mode.
The project covers several core capability areas, including low-level memory management through paging and frame allocation, CPU interrupt handling for exception management, and the development of a multitasking system using asynchronous execution patterns. It also provides a workflow for building freestanding binaries, managing build environments via containers, and verifying kernel logic through integration tests.
The compiled disk images can be executed on physical hardware via USB drives or run within virtual machines and emulators for testing.
Features
- Bare Metal Development - Creates freestanding binaries that boot and execute directly on x86 hardware without an underlying operating system.
- Freestanding Kernels - Implements a freestanding kernel written in Rust that boots on x86 hardware without a standard library.
- OS Binary Compilation - Compiles code without a standard library to create minimal executables for bare metal hardware.
- Task Schedulers - Implements task switching and asynchronous execution to run multiple kernel processes concurrently.
- Interrupt Handling - Uses a processor descriptor table to capture hardware interrupts and CPU exceptions.
- Kernel Development - Provides the complete workflow for building operating system kernels and bootloaders from scratch.
- Custom Memory Allocators - Implements a custom heap allocator for dynamic memory management in a freestanding environment.
- System Memory Allocation - Implements paging, frame allocation, and system-level memory abstractions during kernel initialization.
- Operating System Development - Implements the core processes of designing and building a multitasking operating system from the kernel up.
- Operating System Kernel Build Tools - Provides a toolchain for compiling a minimal operating system kernel and binary without a standard library.
- Paged Memory Management - Maps virtual addresses to physical memory frames using a hierarchical page table structure.
- x86 Kernel Implementations - Implements core x86 system functionality including paging, interrupt handling, and VGA text mode.
- Embedded Rust - Implements core operating system components in Rust without a standard library for bare-metal execution.
- Asynchronous Execution Patterns - Implements asynchronous execution patterns to manage concurrent task execution within the kernel.
- Process Exception Interception - Captures and processes hardware interrupts and processor exceptions to prevent system crashes.
- Cooperative Schedulers - Implements a cooperative multitasking scheduler using asynchronous patterns to share CPU resources.
- Disk Image Imports - Loads compiled disk images into virtualization environments to verify kernel functionality.
- USB Boot Media Creation - Provides the capability to write compiled disk images to USB drives to boot on real machines.
- Bootable Disk Image Toolchains - Provides a build toolchain that transforms Rust source code into binaries compatible with a bootloader for physical or emulated hardware.
- Binary Layout Formatting - Organizes compiled binaries into a binary structure that bootloaders can identify and load.
- Hardware Text Buffers - Implements screen output by writing characters directly to hardware-specific VGA text buffers.
- Bootable Disk Layouts - Implements the formatting of binaries into specific disk image layouts compatible with bootloaders.
- Bootable Image Creation - Formats compiled kernels into disk images that can be loaded onto hardware or emulators.
- OS Image Execution - Runs compiled disk images in emulators or boots them on physical hardware.
- Boot Image Generation - Generates complete bootable disk images tailored for x86 architecture to be written to physical storage.
- VGA Text Mode Drivers - Controls the display by writing characters directly to the VGA text buffer memory addresses.
- Hardware Emulators - Uses hardware emulators to simulate physical components for testing kernel behavior and boot images.
- Floppy Disk Emulation - Executes compiled disk images within virtual machines to test kernel behavior.
- System Emulators - Launches compiled disk images in virtual machines to test kernel behavior.
- Virtual Machines - Executes generated kernel disk images within virtualized environments to verify system behavior.
- Component Testing - Includes component testing to verify the logic and interoperability of system modules.
- System Integration Test Runners - Executes system-level integration tests within the kernel environment to validate hardware interactions.
- Integration Testing Suites - Provides integration testing suites to verify the interoperability of kernel-level software units.
- Unit Testing - Provides unit testing to verify the correctness and stability of individual kernel components.
- Unit Testing Frameworks - Uses automated unit testing frameworks to validate kernel source code functionality before deployment.
