Architecture and "Philosophy" of the project

Unlike kernels such as Microsoft's NT kernel (Hybrid), Redox-OS (Microkernel), or the same MINIX kernel (microkernel), IR0 is based on a more similar architecture to what Linux has, which is monolithic.
However, my main argument is that of performance. I understand that someone could come and point out that, like any monolith, if a subcomponent breaks, the entire system crashes (and they would be right) but what I respond to that is "What good does it do me that the kernel supports continuing without filesystem if I can't do anything practical without it?", that is, it doesn't make sense that the kernel continues functioning without one of its key components running.

That's why I don't see a better alternative (for now) than the monolithic pattern. And it also saves me from having to interconnect key subsystems with each other via IPC, which impacts performance of the Operating System. It's not perfect, but it's stable. It's not entirely traceable and requires scaling little by little, but if it scales well it performs a lot.

However, I also have disagreements with the UNIX philosophy. They (among other things and very briefly) consider that if something fails, let it fail well. Which in kernel terms would be: If the scheduler breaks, Panic() directly. If you have memory corruption (in kernel space), Panic.
And it's not that I question it for no reason, I simply ask (although without solutions yet) "Why not rescue the system during Panic()?, or at least try".
Beyond the philosophical point and to summarize, the kernel is monolithic because it's more performant and I feel that the key pieces of the kernel must work without overhead.
However, if in the future I needed to integrate some specific subsystem in a hybrid way, I would surely be pragmatic.

Kernel Space is sacred

I know I talk as if IR0 were used by thousands of people and all the history, but I'm going to give myself the luxury of opining about it.
So, the point is that kernel space has to be only habitable by subsystems that work in that Environment, nothing else.
I understand that there are certain manufacturers concerned about their clients' security who, coincidentally, have access to every interruption that the user makes (they know what keys you press, your session time every time you turn on the computer, etc.) And all that because they have software running in the kernel space with all the privileges that implies.
RING 0 is only for the kernel. Everything that comes from RING 3 communicates with syscalls(), end of statement.

Network Approach: Basic but Functional

For IR0 to work as support for basic servers and IoT applications, I need fundamental network support but without the massive complexity of Linux's complete stack.

In the Linux Kernel there are more or less 1,500,000 lines of code ONLY THE COMPLETE NETWORK STACK. Instead of trying to port all of that, I've decided to use a more pragmatic approach:

Basic implementation with IoT library:

• Lightweight and functional TCP/IP stack
• Support for basic network connectivity
• Simplified socket interface
• Essential Ethernet drivers
• Minimalist approach that keeps the kernel manageable

Advantages of the Basic Approach

• Keeps the kernel lightweight and manageable
• Significantly reduces code complexity
• Allows network functionality without millions of additional lines
• Easier to debug and maintain
• Sufficient for basic use cases and IoT

Directory Structure

How the file structure can change constantly, I prefer you consult it in the GitHub Repository.

Git Workflow

How is merging from feature to mainline?

Project Status

Version: v0.0.01 pre-release candidate 1
Architecture: x86-64 (primary), x86-32 (experimental), ARM (in development)
License: GNU GPL v3.0
Type: Monolithic Modular Kernel

🏗️ Core Architecture

✅ Kernel Architecture

• Monolithic modular design with HAL abstraction
• Multi-target build system (Desktop/Server/IoT/Embedded)
• Ring 0 (kernel) / Ring 3 (user) separation
• x86-64 primary support with multi-arch framework
• Freestanding C environment with custom libc

✅ Boot System

• GRUB multiboot specification compliance
• x86-64 long mode initialization
• GDT (Global Descriptor Table) setup
• TSS (Task State Segment) configuration
• IDT (Interrupt Descriptor Table) with 64 entries

✅ Memory Management

• Virtual memory with paging (MMU)
• Kernel heap allocator (simple + advanced WIP)
• Memory protection (Ring 0/3 isolation)
• Memory layout: Kernel (1MB-8MB), Heap (8MB-32MB), User (1GB+)
• Page fault handling with CR2 fault address reading

⚙️ Process Management

✅ Process System

• Complete process lifecycle management
• Process states: READY, RUNNING, BLOCKED, ZOMBIE
• PID assignment starting from PID 1
• Process creation with fork() syscall
• Process termination with exit() syscall
• Parent-child relationships with waitpid()

✅ Scheduler

• CFS (Completely Fair Scheduler) implementation
• Red-Black Tree runqueue for O(log n) operations
• Virtual runtime (vruntime) tracking for fairness
• Nice values support (-20 to +19)
• Preemptive multitasking with timer integration
• Context switching in optimized x86-64 assembly

✅ Init System

• PID 1 init process (mini-systemd)
• Service management and respawning
• User mode switching from kernel
• Shell service management

🔧 System Calls

✅ Syscall Interface (23 syscalls implemented)

SYS_EXIT(0)         - Process termination
SYS_WRITE(1)        - Write to file descriptor
SYS_READ(2)         - Read from file descriptor
SYS_GETPID(3)       - Get process ID
SYS_GETPPID(4)      - Get parent process ID
SYS_LS(5)           - List directory contents
SYS_MKDIR(6)        - Create directory
SYS_PS(7)           - Show process list
SYS_WRITE_FILE(8)   - Write file to filesystem
SYS_CAT(9)          - Display file contents
SYS_TOUCH(10)       - Create empty file
SYS_RM(11)          - Remove file
SYS_FORK(12)        - Create child process
SYS_WAITPID(13)     - Wait for child process
SYS_RMDIR(40)       - Remove directory
SYS_MALLOC_TEST(50) - Memory allocation test
SYS_BRK(51)         - Change heap break
SYS_SBRK(52)        - Increment heap break
SYS_MMAP(53)        - Memory mapping
SYS_MUNMAP(54)      - Unmap memory
SYS_MPROTECT(55)    - Change memory protection
SYS_EXEC(56)        - Execute program

✅ Syscall Mechanism

• INT 0x80 software interrupt interface
• Register-based parameter passing
• Kernel/user mode transition
• Error handling and return values

⚡ Interrupt System

✅ Interrupt Handling

• Complete IDT setup with 64 interrupt vectors
• PIC (Programmable Interrupt Controller) remapping
• ISR (Interrupt Service Routines) in assembly
• IRQ handling for hardware devices
• Timer interrupt integration
• Keyboard interrupt (IRQ 1)
• Mouse interrupt (IRQ 12)
• Audio interrupt (IRQ 5)

✅ Exception Handling

• Page fault handler with CR2 address reading
• General protection fault handling
• Division by zero exception
• Invalid opcode exception
• Stack fault handling

🖥️ Hardware Drivers

✅ Input Devices

• PS/2 Keyboard driver with circular buffer
• PS/2 Mouse driver with 3/5 button + scroll wheel support
• Mouse type detection (standard/wheel/5-button)
• Configurable sample rates and resolution

✅ Storage Devices

• ATA/IDE hard disk driver
• CD-ROM support
• Basic disk I/O operations
• Sector-based read/write

✅ Audio System

• Sound Blaster 16 driver
• 8-bit/16-bit audio support
• Mono/Stereo playback
• DMA-based audio transfer (channels 1 and 5)
• Volume control (master and PCM)
• Sample rate configuration
• Audio format detection

✅ Video System

• VGA text mode (80x25)
• VBE (VESA BIOS Extensions) graphics support
• Framebuffer access
• Basic graphics primitives

✅ Serial Communication

• COM1/COM2 serial port drivers
• Debug output via serial
• Configurable baud rates
• Serial interrupt handling

✅ Timer Systems

• PIT (Programmable Interval Timer)
• RTC (Real Time Clock)
• HPET (High Precision Event Timer)
• LAPIC (Local APIC Timer)
• Unified clock system abstraction
• Timer cascade with best available timer selection

✅ DMA Controller

• 8-channel DMA support (0-7)
• 8-bit and 16-bit transfer modes
• Audio DMA integration
• Channel enable/disable control

📁 File System

✅ Virtual File System (VFS)

• Unified filesystem abstraction layer
• Multiple filesystem support framework
• Standard file operations (open, read, write, close)
• Directory operations (mkdir, rmdir, ls)
• File metadata handling

✅ MINIX Filesystem

• Complete MINIX filesystem implementation
• Inode-based file storage
• Directory structure support
• File creation, deletion, and modification
• Integrated with VFS layer

✅ File Operations

• File creation (touch)
• File deletion (rm)
• Directory creation (mkdir)
• Directory removal (rmdir)
• File content display (cat)
• Directory listing (ls)
• File writing capabilities

👤 User Space

✅ C Library (LibC)

• Freestanding C library implementation
• Standard headers: stdio.h, stdlib.h, unistd.h, stdint.h, stddef.h
• I/O functions: printf(), puts(), putchar()
• Memory functions: malloc(), free()
• Process functions: exit(), getpid()
• System call wrappers

✅ Printf Implementation

• Format specifiers: %d (integers), %s (strings), %c (characters)
• Variable argument support
• Output to stdout

✅ User Programs

• Echo command implementation
• Shell integration for user programs
• ELF loader (basic implementation)

🐚 Shell System

✅ Interactive Shell

• Command-line interface in Ring 3 (user mode)
• Built-in commands: ls, ps, cat, mkdir, rmdir, touch, rm, fork, clear, help, exit, malloc, sbrk, exec

✅ Shell Features

• Command parsing and execution
• Process management integration
• Filesystem operation support
• Memory management testing
• Error handling and feedback

🌐 Network System

🔄 Basic TCP/IP Stack (In Development)

• Basic implementation using lightweight IoT library
• Fundamental TCP/IP support for connectivity
• Simplified socket interface
• Basic Ethernet driver framework
• Ping utility planned
• Minimalist approach to reduce complexity

Note: Opted for a basic implementation with IoT library instead of porting Linux's complete stack (1.5M lines) to keep the kernel lightweight and manageable.

🔧 Build System

✅ Multi-Target Build

• Desktop target (full features, 256MB heap, 1024 processes)
• Server target (optimized networking, 1GB heap, 4096 processes)
• IoT target (power management, 16MB heap, 64 processes)
• Embedded target (minimal features, 4MB heap, 16 processes)

✅ Multi-Architecture

• x86-64 production support
• x86-32 experimental support
• ARM development framework
• Architecture abstraction layer (HAL)

⚠️ Current Limitations

❌ Not Yet Implemented

• SMP (Symmetric Multiprocessing) support
• Dynamic kernel modules
• Advanced IPC (pipes, message queues)
• Network stack (TCP/IP)
• USB support
• Advanced GUI/Window manager
• Signal handling
• Copy-on-write memory
• Swap memory support
• Advanced filesystem features (ext2/3/4)

⚠️ Known Issues

• Fork() context switching needs refinement
• Limited ELF loader functionality
• No zombie process reaping in init
• Basic memory allocator (advanced versions in development)
• Single CPU support only

📊 Technical Specifications

Memory Layout

Kernel Space: 0x100000 - 0x800000 (1MB-8MB)
Heap Space:   0x800000 - 0x2000000 (8MB-32MB, 24MB total)
User Space:   0x40000000+ (1GB+)

Performance Metrics

• Context switch time: ~microseconds (assembly optimized)
• Scheduler complexity: O(log n) with Red-Black Tree
• Memory allocation: O(1) for simple allocator
• Interrupt latency: Minimal with optimized ISRs

Resource Limits (Desktop Target)

• Maximum processes: 1024
• Maximum threads: 4096
• Heap size: 256MB
• Scheduler quantum: 10ms
• I/O buffer size: 64KB

🎯 Roadmap

Short Term (Next Release)

• Fix fork() context switching issues
• Implement proper zombie reaping
• Integrate basic TCP/IP stack with IoT library
• Improve ELF loader
• Add USB framework

Medium Term

• SMP support
• Advanced GUI system
• Basic networking expansion (more protocols, optimizations)
• Dynamic kernel modules
• Advanced IPC mechanisms

Long Term

• Native application support (Doom, GCC, Bash)
• Complete POSIX compatibility
• Advanced filesystem support
• Hardware abstraction improvements
• Performance optimizations

What do you need to know to contribute?

Environment Setup

Required Dependencies:

How do I write code?

Naming Conventions:

• Functions: snake_case()
• Macros: UPPER_CASE
• Structs: struct_name_t
• Global variables: g_variable_name
• Constants: CONSTANT_NAME
• includes: #INCLUDE -ir0/Lib.h - (are being migrated to that format)

Comments:

• header files .h of documented functions
• Source code files with comments in some functions, but more limited
• Explanation of complex algorithms
• TO DO's clearly marked
• References to technical documentation

How to compile (for now)

🔄 Scheduler

The scheduler is the heart of the multiprocessing system. Currently implements a simple Round-Robin algorithm as fallback, but the goal is to migrate to a preemptive scheduler with priority scheme similar to Linux's CFS (Completely Fair Scheduler).

Current Features:

• Round-Robin algorithm with fixed quantum
• Support for multiple priority levels
• Basic process state management (Ready, Running, Blocked)
• Optimized context switching in assembly

Upcoming Improvements:

• Preemptive scheduler implementation
• CFS algorithm for fair CPU distribution
• Real-time scheduling support
• Load balancing between cores

Files: scheduler/scheduler.c, scheduler/task.h, scheduler/switch/switch.asm

💾 Filesystem

Own filesystem based on EXT2 but with modern innovations. The distinctive feature is the integration of a vectorial database to optimize file search and indexing operations.

Technical Features:

• Hierarchical directory structure
• Support for files up to 2TB
• Journaling for failure recovery
• Transparent file compression
• Vectorial indexing for fast searches

Innovations:

• Integration with libvictor for semantic searches
• Intelligent cache based on access patterns
• Extended metadata support
• File-level encryption

Status: Active development

Files: fs/ext2.c, fs/victor_index.c, fs/journal.c

⚡ Interrupt System

Robust interrupt and exception handling system that ensures kernel stability and provides a clean interface for handling hardware and software events.

Main Components:

• IDT (Interrupt Descriptor Table): 256-entry table for interrupt mapping
• ISR (Interrupt Service Routines): Optimized handlers in assembly
• Exception Handler: Processor exception handling
• IRQ Manager: Hardware interrupt management

Features:

• Complete page fault handling with automatic recovery
• Nested interrupts with priorities
• Deferred interrupt processing
• Interrupt coalescing for optimization

Files: interrupt/idt.c, interrupt/interrupt.asm, interrupt/isr_handlers.c, interrupt/irq.c

🚀 Boot Subsystem

Initialization system that prepares the environment for kernel execution, handling the transition from bootloader to user space.

Boot Phases:

• Phase 1: Processor initialization and protected mode
• Phase 2: Paging and virtual memory configuration
• Phase 3: Critical subsystems initialization
• Phase 4: First process loading (init)

Features:

• Support for multiple architectures (x86-64, ARM64)
• Independent bootloader with UEFI support
• Automatic recovery from boot failures
• Integrated recovery mode

Files: boot/boot.asm, boot/kmain.c, boot/arch.c, boot/kernel_start.c

🛡️ Memory Management

Advanced memory management system that provides process isolation, performance optimization and protection against unauthorized access.

Components:

• Memory Manager: Physical and virtual page management
• Page Allocator: Efficient memory allocation
• Slab Allocator: Optimization for small objects
• Memory Protection: Access control and permissions

Features:

• 4-level paging (48-bit addressing)
• Transparent memory compression
• NUMA awareness for multi-socket systems
• Memory deduplication

Files: mm/page_alloc.c, mm/slab.c, mm/vmalloc.c, mm/protection.c

🌐 Network Subsystem

Complete network stack based on Linux but optimized for the IR0 kernel, providing support for modern protocols and specific optimizations.

Supported Protocols:

• Complete TCP/IP stack
• UDP with latency optimizations
• HTTP/2 and HTTP/3
• QUIC for fast connections
• IPv6 with automatic transition

Optimizations:

• Zero-copy networking
• Kernel bypass for high-performance applications
• Network function virtualization (NFV)
• Intelligent load balancing

Status: Integration with Linux networking stack

Files: net/tcp.c, net/udp.c, net/socket.c, net/protocols/

🔧 Driver Subsystem

Modular framework for hardware driver development and management, with support for hot-plugging and automatic device management.

Driver Types:

• Block Devices: Disks, SSDs, storage devices
• Character Devices: Terminals, input devices
• Network Devices: Network cards, WiFi, Bluetooth
• Graphics: GPUs, framebuffers, hardware acceleration

Features:

• Unified driver framework
• Hardware auto-detection
• Integrated power management
• Driver signing and verification

Files: drivers/core.c, drivers/block/, drivers/char/, drivers/net/

🔐 Security System

Comprehensive security framework that protects the kernel and user processes, implementing multiple layers of protection and security auditing.

Security Components:

• Access Control: Role-based access control (RBAC)
• Capability System: Granular capability system
• Seccomp: Syscall filtering for sandboxing
• LSM (Linux Security Modules): Interchangeable security modules

Features:

• ASLR (Address Space Layout Randomization)
• Stack canaries and buffer overflow protection
• Automatic kernel hardening
• Security event auditing
• TPM integration for integrity measurement

Files: security/capability.c, security/seccomp.c, security/lsm/, security/audit.c

⚡ Power Management

Advanced power management system that optimizes battery consumption in mobile devices and reduces energy consumption in servers while maintaining performance.

Power States:

• Suspend to RAM: Fast suspension with instant recovery
• Suspend to Disk: Complete hibernation
• Standby: Low-power standby mode
• Dynamic Frequency Scaling: Dynamic CPU frequency adjustment

Optimizations:

• Intelligent CPU idle management
• Wake-on-LAN and wake-on-timer
• Power capping for servers
• Automatic thermal management
• Battery health monitoring

Files: power/suspend.c, power/cpuidle.c, power/thermal.c, power/battery.c

🎯 Virtualization

Virtualization subsystem that allows running multiple operating systems simultaneously, with support for containers and complete virtual machines.

Virtualization Types:

• Containers: Light isolation with namespaces and cgroups
• KVM: Kernel-based Virtual Machine for complete VMs
• Xen: Type 1 hypervisor for bare-metal virtualization
• Docker/OCI: Support for container standards

Features:

• Hardware-assisted virtualization (Intel VT-x, AMD-V)
• Nested virtualization
• Live VM migration
• GPU passthrough for graphics acceleration
• Memory ballooning and overcommit

Files: virt/kvm/, virt/xen/, kernel/nsproxy.c, kernel/cgroup.c

📊 Monitoring and Debugging

Complete monitoring and debugging system that provides deep visibility into kernel operation and enables real-time problem diagnosis.

Debugging Tools:

• Kprobes: Dynamic insertion points in the kernel
• ftrace: Function and event tracer
• perf: Advanced performance profiler
• eBPF: Dynamic kernel programming

Metrics and Monitoring:

• CPU, memory and I/O profiling
• Network packet tracing
• System call monitoring
• Kernel panic analysis
• Performance counters

Files: kernel/trace/, kernel/debug/, kernel/profiling/, kernel/bpf/

🔧 Device Tree

Hardware description system that allows the kernel to automatically discover and configure hardware devices without needing hardcoded specific drivers.

Features:

• Declarative hardware description
• Support for multiple architectures
• Dynamic overlays for configuration
• UEFI/ACPI firmware compatibility

Benefits:

• Faster boot on embedded systems
• Automatic device configuration
• Cross-platform portability
• Reduction of platform-specific code

Files: drivers/of/, drivers/acpi/, drivers/firmware/

🎮 Graphics and Multimedia

Graphics subsystem that provides hardware acceleration, multi-monitor support and advanced multimedia capabilities.

Graphics Components:

• DRM (Direct Rendering Manager): Modern graphics management
• KMS (Kernel Mode Setting): Display mode configuration
• GEM (Graphics Execution Manager): Graphics memory management
• V4L2: Video4Linux for video capture

Features:

• Support for modern GPUs (NVIDIA, AMD, Intel)
• Hardware video acceleration
• Multi-head display
• HDR and color management
• VR/AR support

Files: drivers/gpu/drm/, drivers/media/, drivers/video/

🔊 Audio Subsystem

Advanced audio system that provides support for multiple formats, real-time audio processing and management of complex audio devices.

Audio Components:

• ALSA (Advanced Linux Sound Architecture): Main audio framework
• PulseAudio: Sound server for users
• JACK: Low-latency professional audio
• ASoC (ALSA System on Chip): Audio for embedded systems

Features:

• HD format support (24-bit, 192kHz)
• 7.1 surround audio
• Noise cancellation
• Bluetooth audio (A2DP, aptX)
• MIDI and audio synthesis

Files: sound/core/, sound/soc/, sound/pci/, sound/usb/

📱 Input/Output Subsystem

Unified input and output system that handles all user interface devices, from keyboards and mice to touchscreens and sensors.

Device Types:

• HID (Human Interface Devices): Keyboards, mice, gamepads
• Touchscreens: Capacitive and resistive touchscreens
• Sensors: Accelerometers, gyroscopes, magnetometers
• Haptic Feedback: Vibration and tactile feedback

Features:

• Multi-touch support
• Gesture recognition
• Accessibility features
• Automatic hot-plugging
• Device power management

Files: drivers/input/, drivers/hid/, drivers/iio/