Phase 17: Stability, Security & Finishing

┌─────────────────────────────────────────────────────────────────────────────┐
│        COMPLETE OPERATING SYSTEM - YOUR CREATION                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐        │
│  │ User App  │  │ User App  │  │   Shell   │  │    GUI    │  User   │
│  └─────┬─────┘  └─────┬─────┘  └─────┬─────┘  └─────┬─────┘  Space  │
│        └──────────────┴──────────────┴──────────────┘                      │
│                              │ System Calls                               │
│  ══════════════════════════════════════════════════════════════════  │
│  ┌─────────────────────────────────────────────────────────────────┐  │
│  │                    KERNEL                                   │  │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌──────────┐   │  │
│  │  │Scheduler│ │ Memory  │ │Filesystem│ │ Drivers  │   │  │
│  │  └─────────┘ └─────────┘ └─────────┘ └──────────┘   │  │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌──────────┐   │  │
│  │  │ Debug   │ │Security │ │  Error  │ │  Init/   │   │  │
│  │  │ Tools   │ │Hardening│ │ Handling│ │ Shutdown │   │  │
│  │  └─────────┘ └─────────┘ └─────────┘ └──────────┘   │  │
│  │            ↑ PHASE 17 ADDITIONS ↑                         │  │
│  └─────────────────────────────────────────────────────────────────┘  │
│  ══════════════════════════════════════════════════════════════════  │
│  ┌─────────────────────────────────────────────────────────────────┐  │
│  │                    HARDWARE                                 │  │
│  │    CPU  •  RAM  •  Disk  •  GPU  •  Keyboard  •  Mouse       │  │
│  └─────────────────────────────────────────────────────────────────┘  │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│   YOUR OS COMPONENT INVENTORY                                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   BOOT SYSTEM (Phases 1-4)                                                 │
│   ├── Bootloader (Stage 1 + Stage 2)                                       │
│   ├── Real Mode → Protected Mode transition                                │
│   ├── GDT Setup                                                            │
│   └── UEFI Boot (modern systems)                                           │
│                                                                             │
│   KERNEL CORE (Phases 5-6)                                                 │
│   ├── Interrupt Descriptor Table (IDT)                                     │
│   ├── Exception Handlers                                                   │
│   ├── Physical Memory Manager (PMM)                                        │
│   ├── Virtual Memory Manager (VMM)                                         │
│   └── Heap Allocator (kmalloc/kfree)                                       │
│                                                                             │
│   STORAGE & FILES (Phases 7, 9-10)                                         │
│   ├── Block Device Layer                                                   │
│   ├── FAT Filesystem Driver                                                │
│   ├── Virtual Filesystem (VFS)                                             │
│   ├── ELF Executable Loader                                                │
│   └── Standard C Library                                                   │
│                                                                             │
│   PROCESSES & MULTITASKING (Phase 8)                                       │
│   ├── Process Control Block (PCB)                                          │
│   ├── Context Switching                                                    │
│   ├── User Mode / Kernel Mode                                              │
│   └── System Call Interface                                                │
│                                                                             │
│   USER INTERFACE (Phases 13-14)                                            │
│   ├── Framebuffer Graphics                                                 │
│   ├── Window Manager                                                       │
│   ├── Mouse Driver                                                         │
│   └── Event System                                                         │
│                                                                             │
│   HARDWARE DRIVERS (Phase 15)                                              │
│   ├── PCI Bus Enumeration                                                  │
│   ├── AHCI/SATA Driver                                                     │
│   ├── NVMe Driver                                                          │
│   └── Device Framework                                                     │
│                                                                             │
│   PHASE 17: STABILITY & SECURITY                                           │
│   ├── Stack Trace / Symbol Lookup                                          │
│   ├── Kernel Logging System                                                │
│   ├── NX Bit / DEP                                                         │
│   ├── SMEP / SMAP                                                          │
│   ├── Kernel Panic Handler                                                 │
│   └── Init/Shutdown Sequence                                               │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Debugging Tools

Debugging kernel code is fundamentally different from debugging user applications. There's no debugger running inside your OS to set breakpoints—you are the OS. When something goes wrong, you need infrastructure to understand what happened.

┌─────────────────────────────────────────────────────────────────┐
│           KERNEL DEBUGGING CHALLENGES                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  User-Space Debugging:       Kernel Debugging:              │
│  ──────────────────────       ───────────────────              │
│  • gdb sets breakpoints      • No debugger inside OS          │
│  • OS catches signals         • Triple fault = reboot          │
│  • printf() always works      • Screen may not exist yet       │
│  • Core dumps saved           • Must build own diagnostics     │
│  • Crash = app terminates     • Crash = entire system down     │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Stack Traces

When your kernel crashes (and it will during development), the most important question is: "Where did it crash?" A stack trace answers this by walking backwards through function calls, showing exactly what code path led to the failure.

┌─────────────────────────────────────────────────────────────────┐
│           STACK FRAME LAYOUT (x86-64)                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   High Address (Stack grows DOWN)                               │
│   ┌──────────────────────────────────────────────────┐        │
│   │           main() frame                    │        │
│   ├──────────────────────────────────────────────────┤        │
│   │ return address (to _start)            │  ← RBP  │
│   │ saved RBP (previous frame pointer)    │        │
│   │ local variables                       │        │
│   ├──────────────────────────────────────────────────┤        │
│   │           foo() frame                      │        │
│   ├──────────────────────────────────────────────────┤        │
│   │ return address (to main+0x42)         │        │
│   │ saved RBP ─────────────────────────┤        │
│   │ local variables                       │        │
│   ├──────────────────────────────────────────────────┤        │
│   │           bar() frame  ← CRASH HERE     │        │
│   ├──────────────────────────────────────────────────┤        │
│   │ return address (to foo+0x1A)          │  ← RSP  │
│   │ saved RBP ─────────────────────────┤        │
│   └──────────────────────────────────────────────────┘        │
│   Low Address                                                  │
│                                                                 │
│   Unwinding: bar → foo → main → _start                        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Here's our stack frame walker implementation that traverses the call chain:

/* Stack Frame Walker */
typedef struct stack_frame {
    struct stack_frame* ebp;  // Previous frame pointer
    uint32_t eip;             // Return address
} stack_frame_t;

/* Print stack trace */
void print_stack_trace(void) {
    stack_frame_t* frame;
    __asm__ volatile("mov %%ebp, %0" : "=r"(frame));
    
    kprintf("Stack trace:\n");
    for (int i = 0; i < 10 && frame; i++) {
        uint32_t eip = frame->eip;
        const char* name = symbol_lookup(eip);
        
        if (name) {
            kprintf("  [%d] %s (0x%08x)\n", i, name, eip);
        } else {
            kprintf("  [%d] 0x%08x\n", i, eip);
        }
        
        frame = frame->ebp;
    }
}

/* Symbol table for debugging */
typedef struct {
    uint32_t address;
    const char* name;
} symbol_t;

symbol_t symbols[] = {
    {0x00100000, "kernel_main"},
    {0x00100100, "kmalloc"},
    // ... loaded from kernel symbol table
};

Kernel Logging

Content will be populated here...

/* Log Levels */
enum log_level {
    LOG_DEBUG,
    LOG_INFO,
    LOG_WARN,
    LOG_ERROR,
    LOG_PANIC
};

/* Ring buffer for log storage */
#define LOG_BUFFER_SIZE 4096
char log_buffer[LOG_BUFFER_SIZE];
int log_head = 0;
int log_tail = 0;

/* Kernel log function */
void klog(enum log_level level, const char* fmt, ...) {
    static const char* level_names[] = {
        "DEBUG", "INFO", "WARN", "ERROR", "PANIC"
    };
    
    // Format: [LEVEL] timestamp: message
    char buf[256];
    va_list args;
    va_start(args, fmt);
    vsnprintf(buf, sizeof(buf), fmt, args);
    va_end(args);
    
    // Add to ring buffer
    kprintf("[%s] %llu: %s\n", level_names[level], get_ticks(), buf);
    
    // Also output to serial for debugging
    serial_printf("[%s] %s\n", level_names[level], buf);
}

#define KLOG_DEBUG(...) klog(LOG_DEBUG, __VA_ARGS__)
#define KLOG_INFO(...)  klog(LOG_INFO, __VA_ARGS__)
#define KLOG_WARN(...)  klog(LOG_WARN, __VA_ARGS__)
#define KLOG_ERROR(...) klog(LOG_ERROR, __VA_ARGS__)

Serial Debugging

Before graphics initialization, serial output is your only window into the kernel. Serial ports are simple, reliable, and available very early in boot—making them indispensable for debugging boot issues and kernel initialization.

┌─────────────────────────────────────────────────────────────────┐
│              SERIAL PORT I/O                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────┐     ┌──────────────────┐     ┌──────────┐     │
│  │  Kernel  │ ─→─ │  UART 16550     │ ─── │ Serial   │     │
│  │  Code    │     │  (I/O 0x3F8)    │     │ Cable    │  ───  │
│  └──────────┘     └──────────────────┘     └──────────┘     │
│                                                      │          │
│                                                      ↓          │
│                                             ┌──────────────┐    │
│                                             │  Host PC     │    │
│                                             │  terminal    │    │
│                                             │  (minicom/   │    │
│                                             │   screen)    │    │
│                                             └──────────────┘    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

/* Serial Port I/O Ports */
#define SERIAL_COM1_BASE    0x3F8
#define SERIAL_COM2_BASE    0x2F8

/* UART Registers (offset from base) */
#define SERIAL_DATA         0   // Data register (read/write)
#define SERIAL_INTR_ENABLE  1   // Interrupt enable
#define SERIAL_FIFO_CTRL    2   // FIFO control
#define SERIAL_LINE_CTRL    3   // Line control (baud rate, parity)
#define SERIAL_MODEM_CTRL   4   // Modem control
#define SERIAL_LINE_STATUS  5   // Line status

/* Line Status Register bits */
#define SERIAL_LSR_DR       (1 << 0)  // Data ready
#define SERIAL_LSR_THRE     (1 << 5)  // Transmit holding register empty

/* Initialize serial port */
void serial_init(uint16_t port) {
    outb(port + SERIAL_INTR_ENABLE, 0x00);  // Disable interrupts
    outb(port + SERIAL_LINE_CTRL, 0x80);    // Enable DLAB (baud divisor)
    outb(port + SERIAL_DATA, 0x03);         // Divisor low byte (38400 baud)
    outb(port + SERIAL_INTR_ENABLE, 0x00);  // Divisor high byte
    outb(port + SERIAL_LINE_CTRL, 0x03);    // 8 bits, no parity, 1 stop bit
    outb(port + SERIAL_FIFO_CTRL, 0xC7);    // Enable FIFO, 14-byte threshold
    outb(port + SERIAL_MODEM_CTRL, 0x0B);   // IRQs enabled, RTS/DSR set
    
    KLOG_INFO("Serial port 0x%x initialized", port);
}

/* Check if transmit buffer is empty */
static int serial_is_transmit_empty(uint16_t port) {
    return inb(port + SERIAL_LINE_STATUS) & SERIAL_LSR_THRE;
}

/* Write single character to serial port */
void serial_putc(uint16_t port, char c) {
    while (!serial_is_transmit_empty(port)) {
        // Busy wait - fine for debugging
        __asm__ volatile("pause");
    }
    outb(port + SERIAL_DATA, c);
}

/* Write string to serial port */
void serial_puts(uint16_t port, const char* str) {
    while (*str) {
        if (*str == '\n') {
            serial_putc(port, '\r');  // Newline needs carriage return
        }
        serial_putc(port, *str++);
    }
}

/* Printf to serial port (for early debugging) */
void serial_printf(const char* fmt, ...) {
    char buf[256];
    va_list args;
    va_start(args, fmt);
    vsnprintf(buf, sizeof(buf), fmt, args);
    va_end(args);
    
    serial_puts(SERIAL_COM1_BASE, buf);
}

/* Very early boot debugging (can call before anything else) */
void early_debug(const char* msg) {
    // Minimal initialization - just enough to send chars
    outb(SERIAL_COM1_BASE + SERIAL_LINE_CTRL, 0x03);  // 8N1
    serial_puts(SERIAL_COM1_BASE, "[EARLY] ");
    serial_puts(SERIAL_COM1_BASE, msg);
    serial_puts(SERIAL_COM1_BASE, "\n");
}

Example usage in QEMU:

# Run with serial output to terminal
qemu-system-x86_64 -kernel myos.bin -serial stdio

# Or redirect to file for later analysis
qemu-system-x86_64 -kernel myos.bin -serial file:serial.log

Security Hardening

Modern CPUs include hardware security features designed to prevent common exploitation techniques. These features make it significantly harder for attackers to turn bugs into exploits, even when your code has vulnerabilities.

┌─────────────────────────────────────────────────────────────────┐
│           CPU SECURITY FEATURES                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   Without Security            With Security               │
│   ────────────────────            ───────────────────               │
│                                                                 │
│   Buffer Overflow:            Buffer Overflow:            │
│   ┌────────────────┐            ┌────────────────┐            │
│   │ Shellcode runs  │            │ NX blocks exec │            │
│   │ from stack      │            │ from data      │            │
│   └───────┬────────┘            └───────┬────────┘            │
│           ↓                             ↓                      │
│   ROP Attack:                 ROP Attack:                 │
│   ┌────────────────┐            ┌────────────────┐            │
│   │ Known address   │            │ ASLR randomizes│            │
│   │ of gadgets      │            │ all addresses  │            │
│   └───────┬────────┘            └───────┬────────┘            │
│           ↓                             ↓                      │
│   Kernel Exploit:             Kernel Exploit:             │
│   ┌────────────────┐            ┌────────────────┐            │
│   │ Jump to user   │            │ SMEP/SMAP      │            │
│   │ shellcode       │            │ blocks access  │            │
│   └────────────────┘            └────────────────┘            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

NX Bit (DEP)

The NX (No-Execute) bit, also called DEP (Data Execution Prevention), marks memory pages as either executable or non-executable. This prevents the classic buffer overflow attack where an attacker overwrites a return address to jump into their own code stored in a data area.

Without NX, an attacker who finds a buffer overflow can:

1. Inject shellcode (malicious machine code) into a buffer
2. Overwrite the return address to point to their shellcode
3. When the function returns, execution jumps to the shellcode

With NX enabled and data pages marked non-executable, step 3 triggers a page fault—the CPU refuses to execute code from a non-executable page, and the attack fails.

/* Enable NX (No-Execute) bit in page tables */
#define PAGE_NX (1ULL << 63)  // No-execute bit

/* Mark page as non-executable */
void page_set_nx(uint64_t* pte) {
    *pte |= PAGE_NX;
}

/* Enable NX support via IA32_EFER MSR */
void enable_nx_bit(void) {
    uint64_t efer = rdmsr(0xC0000080);  // IA32_EFER
    efer |= (1 << 11);  // NXE bit
    wrmsr(0xC0000080, efer);
}

/* Protect kernel code: executable, read-only */
void protect_kernel_code(void) {
    for (uint64_t addr = KERNEL_CODE_START; 
         addr < KERNEL_CODE_END; 
         addr += PAGE_SIZE) {
        uint64_t* pte = get_pte(addr);
        *pte &= ~PAGE_WRITE;  // Read-only
        *pte &= ~PAGE_NX;     // Executable
    }
    
    // Flush TLB
    flush_tlb();
}

/* Protect kernel data: writable, non-executable */
void protect_kernel_data(void) {
    for (uint64_t addr = KERNEL_DATA_START;
         addr < KERNEL_DATA_END;
         addr += PAGE_SIZE) {
        uint64_t* pte = get_pte(addr);
        *pte |= PAGE_NX;  // Non-executable
    }
    flush_tlb();
}

Address Space Layout

ASLR (Address Space Layout Randomization) makes exploitation harder by randomizing where code and data are loaded in memory. Even if an attacker finds a vulnerability, they don't know where their target functions or gadgets are located.

┌─────────────────────────────────────────────────────────────────┐
│           ASLR: MEMORY LAYOUT RANDOMIZATION               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   Without ASLR (predictable)   With ASLR (randomized)     │
│                                                                 │
│   0xFFFF...  ┌──────────┐     0xFFFF...  ┌──────────┐        │
│             │  Kernel  │                │  Kernel  │        │
│   0x8000... └──────────┘     0x????... └──────────┘        │
│             ┌──────────┐                ┌──────────┐        │
│   0x7FFF... │  Stack   │     0x????... │  Stack   │        │
│             └──────────┘                └──────────┘        │
│             ┌──────────┐                ┌──────────┐        │
│   0x4000... │  Heap    │     0x????... │  Heap    │        │
│             └──────────┘                └──────────┘        │
│             ┌──────────┐                ┌──────────┐        │
│   0x0040... │  Code    │     0x????... │  Code    │        │
│             └──────────┘                └──────────┘        │
│                                                                 │
│   Attacker knows: 0x00401234  Attacker sees: 0x????1234    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

/* Simple ASLR Implementation */

/* Random number generator (use hardware RNG if available) */
static uint64_t aslr_seed;

void aslr_init(void) {
    // Seed from RDTSC (timestamp counter) - not cryptographically secure
    // but good enough for basic ASLR
    aslr_seed = rdtsc() ^ (rdtsc() >> 17);
    
    // Better: use RDRAND if available
    if (cpu_has_rdrand()) {
        __asm__ volatile("rdrand %0" : "=r"(aslr_seed));
    }
}

uint64_t aslr_random(void) {
    // xorshift64 - fast PRNG
    aslr_seed ^= aslr_seed >> 12;
    aslr_seed ^= aslr_seed << 25;
    aslr_seed ^= aslr_seed >> 27;
    return aslr_seed * 0x2545F4914F6CDD1DULL;
}

/* Randomize base addresses for process loading */
uint64_t aslr_mmap_base(void) {
    // Randomize with 28 bits of entropy (256M possibilities)
    uint64_t offset = (aslr_random() & 0x0FFFFFFF) << PAGE_SHIFT;
    return MMAP_BASE_DEFAULT + offset;
}

uint64_t aslr_stack_base(void) {
    // Randomize stack with 22 bits of entropy
    uint64_t offset = (aslr_random() & 0x003FFFFF) << PAGE_SHIFT;
    return STACK_BASE_DEFAULT - offset;
}

uint64_t aslr_heap_base(void) {
    // Randomize heap start
    uint64_t offset = (aslr_random() & 0x001FFFFF) << PAGE_SHIFT;
    return HEAP_BASE_DEFAULT + offset;
}

/* During process creation */
task_t* create_process_with_aslr(const char* path) {
    task_t* task = alloc_task();
    
    // Randomize memory layout
    task->mmap_base = aslr_mmap_base();
    task->stack_base = aslr_stack_base();
    task->heap_start = aslr_heap_base();
    
    // Load executable at randomized address
    load_elf_at(path, task->mmap_base);
    
    return task;
}

SMEP/SMAP

SMEP (Supervisor Mode Execution Prevention) and SMAP (Supervisor Mode Access Prevention) are CPU features that prevent the kernel from executing code or accessing data in user-space memory. These stop a common kernel exploitation technique where an attacker places shellcode in user memory, then tricks the kernel into jumping to it.

┌─────────────────────────────────────────────────────────────────┐
│           SMEP/SMAP PROTECTION                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│              User Space          Kernel Space              │
│              (Ring 3)              (Ring 0)                    │
│                                                                 │
│           ┌───────────┐       ┌───────────┐                   │
│           │ User Code │       │  Kernel   │                   │
│           │ (attacker │  ✗    │   Code    │                   │
│           │ shellcode)│ ──   │           │ SMEP: No exec     │
│           └───────────┘       └───────────┘ of user pages     │
│                                                                 │
│           ┌───────────┐       ┌───────────┐                   │
│           │ User Data │       │  Kernel   │                   │
│           │ (attacker │  ✗    │   Data    │                   │
│           │ payload)  │ ──   │           │ SMAP: No access   │
│           └───────────┘       └───────────┘ of user pages     │
│                                                                 │
│   Legitimate access via STAC/CLAC (copy_from_user)              │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

The stac() and clac() instructions temporarily disable SMAP for legitimate kernel access to user memory (like copying data to/from user buffers). This creates a small, auditable window where the kernel can access user memory:

/* Enable SMEP (Supervisor Mode Execution Prevention) */
void enable_smep(void) {
    uint32_t cr4;
    __asm__ volatile("mov %%cr4, %0" : "=r"(cr4));
    cr4 |= (1 << 20);  // SMEP bit
    __asm__ volatile("mov %0, %%cr4" :: "r"(cr4));
    KLOG_INFO("SMEP enabled");
}

/* Enable SMAP (Supervisor Mode Access Prevention) */
void enable_smap(void) {
    uint32_t cr4;
    __asm__ volatile("mov %%cr4, %0" : "=r"(cr4));
    cr4 |= (1 << 21);  // SMAP bit
    __asm__ volatile("mov %0, %%cr4" :: "r"(cr4));
    KLOG_INFO("SMAP enabled");
}

/* Temporarily allow user memory access */
static inline void stac(void) {
    __asm__ volatile("stac" ::: "memory");
}

/* Restore SMAP protection */
static inline void clac(void) {
    __asm__ volatile("clac" ::: "memory");
}

/* Safe copy from user space */
int copy_from_user(void* dst, const void* src, size_t n) {
    stac();
    memcpy(dst, src, n);
    clac();
    return 0;
}

Error Handling

In user-space programming, errors can often be recovered from—catch an exception, display an error message, maybe restart the operation. In kernel code, some errors are so severe that the only safe response is to stop everything. Other errors are serious but potentially recoverable. Distinguishing between these cases is crucial for building a reliable OS.

┌─────────────────────────────────────────────────────────────────┐
│           KERNEL ERROR SEVERITY LEVELS                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   WARNING ──── OOPS ──── BUG() ──── PANIC                   │
│     ↓                ↓            ↓            ↓               │
│   Log and        Kill bad  Kernel bug  System              │
│   continue       process   detected    halted              │
│                                                                 │
│   Examples:       Examples:     Examples:     Examples:          │
│   - Low memory    - Page fault  - Invalid     - Memory           │
│   - Deprecated    - NULL deref    state       corruption         │
│     API used      - Division    - Assertion   - Stack            │
│   - Timeout         by zero       fail          smash           │
│                                               - Hardware        │
│                                                 failure          │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Kernel Panic

A kernel panic is the kernel's last resort when it detects an unrecoverable error. Continuing would risk data corruption, security breaches, or unpredictable behavior. The safest action is to stop immediately, display diagnostic information, and halt the system.

A well-designed panic handler should:

1. Disable interrupts - Prevent further code execution that might worsen the situation
2. Display the error - Show what went wrong and where
3. Print CPU state - Register contents help debugging
4. Print stack trace - Show the call path that led to the panic
5. Halt the system - Stop all CPUs safely

/* Kernel panic - unrecoverable error */
__attribute__((noreturn))
void panic(const char* fmt, ...) {
    // Disable interrupts
    __asm__ volatile("cli");
    
    // Print panic message
    kprintf("\n\n");
    kprintf("================== KERNEL PANIC ==================\n");
    kprintf("Fatal error: ");
    
    va_list args;
    va_start(args, fmt);
    kvprintf(fmt, args);
    va_end(args);
    
    kprintf("\n\n");
    
    // Print register dump
    print_registers();
    
    // Print stack trace
    print_stack_trace();
    
    kprintf("==================================================\n");
    kprintf("System halted. Please restart your computer.\n");
    
    // Halt all CPUs
    for (;;) {
        __asm__ volatile("hlt");
    }
}

/* Assertion macro */
#define ASSERT(cond) do { \
    if (!(cond)) { \
        panic("Assertion failed: %s at %s:%d", \
              #cond, __FILE__, __LINE__); \
    } \
} while(0)

Soft Faults

Not every kernel error needs to crash the entire system. An OOPS (the term Linux uses) is a soft fault that indicates a serious error but one that might be recoverable. The kernel logs diagnostic information, kills the offending process if identifiable, and attempts to continue.

/* Kernel OOPS - serious but potentially recoverable error */
typedef struct {
    const char* message;      // Error message
    const char* file;         // Source file
    int line;                 // Line number
    uint64_t ip;             // Instruction pointer
    uint64_t sp;             // Stack pointer
    task_t* task;            // Current task (if any)
    bool in_interrupt;        // Were we in an interrupt?
} oops_info_t;

void kernel_oops(oops_info_t* info) {
    // Disable preemption - don't context switch during OOPS
    preempt_disable();
    
    // Log the error
    kprintf("\n========== KERNEL OOPS ==========\n");
    kprintf("Error: %s\n", info->message);
    kprintf("Location: %s:%d\n", info->file, info->line);
    kprintf("IP: 0x%016lx  SP: 0x%016lx\n", info->ip, info->sp);
    
    // Print registers
    print_registers();
    
    // Print stack trace
    print_stack_trace();
    
    // Can we recover?
    if (info->in_interrupt) {
        kprintf("OOPS in interrupt context - escalating to panic\n");
        panic("Unrecoverable OOPS in interrupt");
    }
    
    if (info->task == NULL || info->task == &idle_task) {
        kprintf("OOPS in kernel thread - escalating to panic\n");
        panic("Unrecoverable OOPS in kernel context");
    }
    
    // Kill the offending process
    kprintf("Killing process %d (%s)\n", 
            info->task->pid, info->task->name);
    kprintf("=================================\n\n");
    
    // Send SIGKILL to the process
    send_signal(info->task, SIGKILL);
    
    preempt_enable();
    schedule();  // Switch to another task
}

/* Macros for triggering OOPS */
#define WARN(msg) do { \
    KLOG_WARN("%s at %s:%d", msg, __FILE__, __LINE__); \
} while(0)

#define WARN_ON(cond) do { \
    if (unlikely(cond)) { \
        KLOG_WARN("WARN_ON(" #cond ") at %s:%d", __FILE__, __LINE__); \
        print_stack_trace(); \
    } \
} while(0)

#define BUG() do { \
    oops_info_t info = { \
        .message = "BUG() triggered", \
        .file = __FILE__, \
        .line = __LINE__, \
        .ip = (uint64_t)__builtin_return_address(0), \
        .sp = get_sp(), \
        .task = current_task, \
        .in_interrupt = in_interrupt_context() \
    }; \
    kernel_oops(&info); \
} while(0)

#define BUG_ON(cond) do { \
    if (unlikely(cond)) { \
        BUG(); \
    } \
} while(0)

/* Example usage in kernel code */
void* kmalloc(size_t size) {
    void* ptr = do_alloc(size);
    
    // Don't panic on allocation failure - OOPS instead
    if (ptr == NULL) {
        WARN("kmalloc failed - memory pressure");
        return NULL;
    }
    
    return ptr;
}

void process_list_add(task_t* task) {
    // This should never happen - indicates a bug
    BUG_ON(task == NULL);
    BUG_ON(task->state == TASK_DEAD);
    
    list_add(&task->list, &process_list);
}

Finishing Touches

A complete operating system needs proper lifecycle management. The kernel must initialize all subsystems in the right order, launch the first user process, and when the time comes, shut down cleanly without corrupting data. These bookend operations—startup and shutdown—are surprisingly complex.

Init Process

The init process (traditionally PID 1) is the ancestor of all user processes. After the kernel finishes internal initialization, it creates and launches init, which then spawns all other user-space services. If init dies, the system typically panics because the process hierarchy becomes orphaned.

┌─────────────────────────────────────────────────────────────────┐
│           KERNEL BOOT TO INIT SEQUENCE                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   BIOS/UEFI                                                     │
│       ↓                                                         │
│   Bootloader (stage1, stage2)                                   │
│       ↓                                                         │
│   Kernel Entry (start_kernel)                                   │
│       │                                                         │
│       ├── Memory init (PMM, VMM, heap)                          │
│       ├── Interrupt setup (IDT, PIC/APIC)                       │
│       ├── Timer init (PIT/HPET)                                 │
│       ├── Driver init (PCI scan, device probing)                │
│       ├── Filesystem init (VFS, mount root)                     │
│       ├── Scheduler init                                        │
│       │                                                         │
│       └── kernel_main()                                       │
│               │                                                 │
│               ├── Create init process (PID 1)                   │
│               ├── Enable interrupts                             │
│               └── Become idle process (PID 0)                   │
│                       ↓                                         │
│                   Scheduler runs                                │
│                       ↓                                         │
│                   Init starts spawning services                 │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

/* Kernel main - after all subsystems initialized */
void kernel_main(void) {
    // Final initialization
    KLOG_INFO("Kernel initialization complete");
    KLOG_INFO("Starting init process...");
    
    // Create init process (PID 1)
    task_t* init = create_process("/bin/init", 0, NULL);
    if (!init) {
        panic("Failed to start init process");
    }
    
    KLOG_INFO("Init process started (PID %d)", init->pid);
    
    // Enable interrupts and start scheduling
    __asm__ volatile("sti");
    
    // Become idle process (PID 0)
    for (;;) {
        __asm__ volatile("hlt");
    }
}

Clean Shutdown

Shutting down is just as important as booting up. An improper shutdown can corrupt filesystems, lose data in caches, and leave hardware in undefined states. The shutdown sequence must carefully unwind everything the boot sequence set up.

┌─────────────────────────────────────────────────────────────────┐
│           CLEAN SHUTDOWN SEQUENCE                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   1. Signal user processes (SIGTERM)                            │
│      └─ Applications save state and exit gracefully             │
│                                                                 │
│   2. Wait timeout (e.g., 5 seconds)                             │
│      └─ Give processes time to clean up                          │
│                                                                 │
│   3. Force kill remaining (SIGKILL)                             │
│      └─ No process survives SIGKILL                              │
│                                                                 │
│   4. Sync filesystems                                            │
│      └─ Flush dirty buffers to disk                              │
│                                                                 │
│   5. Unmount filesystems                                         │
│      └─ Mark filesystems cleanly unmounted                        │
│                                                                 │
│   6. Flush disk caches                                           │
│      └─ Block cache writeback, disk cache flush                   │
│                                                                 │
│   7. Power off via ACPI                                          │
│      └─ Signal power management to cut power                      │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

/* System shutdown sequence */
void system_shutdown(void) {
    KLOG_INFO("System shutdown initiated");
    
    // Stop all user processes
    KLOG_INFO("Terminating user processes...");
    kill_all_processes();
    
    // Sync filesystems
    KLOG_INFO("Syncing filesystems...");
    vfs_sync_all();
    
    // Unmount filesystems
    KLOG_INFO("Unmounting filesystems...");
    vfs_unmount_all();
    
    // Flush disk caches
    KLOG_INFO("Flushing disk caches...");
    block_cache_flush_all();
    
    KLOG_INFO("Shutdown complete. Power off now safe.");
    
    // ACPI power off
    acpi_power_off();
    
    // Fallback: halt
    __asm__ volatile("cli; hlt");
}

/* ACPI power off */
void acpi_power_off(void) {
    // Write SLP_TYPa and SLP_EN to PM1a_CNT
    outw(acpi_pm1a_cnt, (acpi_slp_typa << 10) | (1 << 13));
}

Series Summary: What You've Built

Over 18 phases, you've built every major component of a modern operating system from scratch. Let's celebrate what you've accomplished and the skills you've developed.

┌─────────────────────────────────────────────────────────────────────────────┐
│             🎉 YOUR COMPLETE OPERATING SYSTEM 🎉                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ╔═════════════════════════════════════════════════════════════════════╗  │
│  ║  USER APPLICATIONS                                                  ║  │
│  ║  Shell • GUI Apps • Games • User Programs                          ║  │
│  ╚═════════════════════════════════════════════════════════════════════╝  │
│                                    │                                        │
│  ╔═══════════════════╦═══════════════╦═══════════════════════════════╗  │
│  ║ C Library (libc)  ║ System Calls  ║ Window Manager               ║  │
│  ╚═══════════════════╩═══════════════╩═══════════════════════════════╝  │
│  ═══════════════════════════════════════════════════════════════════════  │
│  ╔═════════════════════════════════════════════════════════════════════╗  │
│  ║  KERNEL                                                             ║  │
│  ║  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐   ║  │
│  ║  │ Scheduler   │ │ Memory Mgr  │ │ VFS Layer   │ │ Security    │   ║  │
│  ║  │ (CFS/MLFQ)  │ │ (Paging)    │ │ (FAT/ext2)  │ │ (NX/SMEP)   │   ║  │
│  ║  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘   ║  │
│  ║  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐   ║  │
│  ║  │ Interrupts  │ │ Debug Tools │ │ Error Hdlr  │ │ Panic/OOPS  │   ║  │
│  ║  │ (IDT/APIC)  │ │ (Logging)   │ │ (Recovery)  │ │ (Safety)    │   ║  │
│  ║  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘   ║  │
│  ╚═════════════════════════════════════════════════════════════════════╝  │
│  ═══════════════════════════════════════════════════════════════════════  │
│  ╔═════════════════════════════════════════════════════════════════════╗  │
│  ║  DEVICE DRIVERS                                                     ║  │
│  ║  Keyboard • Mouse • VGA/Framebuffer • AHCI • NVMe • PCI • Timer    ║  │
│  ╚═════════════════════════════════════════════════════════════════════╝  │
│  ═══════════════════════════════════════════════════════════════════════  │
│  ╔═════════════════════════════════════════════════════════════════════╗  │
│  ║  HARDWARE                                                           ║  │
│  ║  CPU • RAM • Storage • Display • Input Devices                     ║  │
│  ╚═════════════════════════════════════════════════════════════════════╝  │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Skills You've Developed

Throughout this series, you haven't just learned about operating systems—you've developed skills that transfer to many areas of systems programming:

Phase-by-Phase Recap

Phase	Topic	Key Achievement
0	Orientation	Understanding OS architecture and kernel types
1	Boot Process	Understanding BIOS, UEFI, and how PCs start
2	Real Mode	Writing a working bootloader from scratch
3	Protected Mode	GDT setup and 32-bit mode transition
4	Display & I/O	VGA text mode and keyboard input
5	Interrupts	IDT, ISRs, and PIC programming
6	Memory	Paging, virtual memory, and heap allocator
7	Filesystems	FAT driver and VFS layer
8	Processes	Multitasking and system calls
9	ELF Loading	Loading and executing user programs
10	Shell & libc	Command-line shell and C library
11	64-Bit Mode	Long mode and 64-bit paging
12	UEFI	Modern boot services and memory maps
13	Graphics	Framebuffer and windowing system
14	Input & Timing	Mouse driver and high-precision timers
15	Hardware Drivers	PCI enumeration, AHCI, NVMe
16	Performance	Caching, scheduler tuning, profiling
17	Security & Finishing	Hardening, debugging, init/shutdown

What's Next

Your OS development journey doesn't end here. There are many directions you can take your operating system:

• Networking: TCP/IP stack, network drivers, socket API
• SMP: Multi-core processor support, per-CPU data
• Advanced Filesystems: ext2/ext4, journaling, NTFS
• USB Stack: Full USB support, mass storage, HID
• Audio: Sound card drivers, mixing, applications