Create pic.c

Implementation for pic.h

.clang-format

@@ -0,0 +1,24 @@
+BasedOnStyle: Google
+IndentWidth: 4
+TabWidth: 4
+UseTab: Never
+ColumnLimit: 80
+
+DerivePointerAlignment: false
+PointerAlignment: Right
+ReferenceAlignment: Right
+
+AlignConsecutiveMacros: Consecutive
+AlignTrailingComments:
+  Kind: Always
+  OverEmptyLines: 0
+
+IncludeBlocks: Regroup
+IncludeCategories:
+  # Std headers
+  - Regex: '<[[:alnum:]_.]+>'
+    Priority: 2
+
+  # Other headers
+  - Regex: '.*'
+    Priority: 1

.clangd

@@ -0,0 +1,6 @@
+CompileFlags:
+  CompilationDatabase: build
+
+Diagnostics:
+  UnusedIncludes: Strict
+  MissingIncludes: Strict

.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[Makefile]
+indent_style = tab
+indent_size = 8
+tab_width = 8

.gitignore

@@ -1,3 +1,5 @@
 .build.env
 build
 cross
+.cache/
+compile_commands.json

Makefile

@@ -6,6 +6,7 @@ QEMU= qemu-system-i386
 OBJCOPY = i386-elf-objcopy
 
 BUILD_DIR = build
+CROSS_DIR = cross
 DISK_IMG = $(BUILD_DIR)/disk.img
 STAGE2_SIZE = 2048
 
@@ -14,9 +15,12 @@ KERNEL_ASM_SRC = $(wildcard kernel/*.asm)
 KERNEL_OBJ = $(patsubst kernel/%.c, $(BUILD_DIR)/%.o, $(KERNEL_C_SRC))
 KERNEL_OBJ += $(patsubst kernel/%.asm, $(BUILD_DIR)/asm_%.o, $(KERNEL_ASM_SRC))
 
+KLIBC_SRC = $(wildcard klibc/src/*.c)
+KLIBC_OBJ = $(patsubst klibc/src/%.c, $(BUILD_DIR)/klibc/%.o, $(KLIBC_SRC))
+
+.PHONY: all stage1 stage2 kernel compile-commands $(BUILD_DIR)/compile_commands.json run gdb clean clean-cross clean-all
 all: $(DISK_IMG)
 
-.PHONY: stage1 stage2 kernel run gdb clean
 stage1: $(BUILD_DIR)
 	$(AS) $(ASFLAGS) -o $(BUILD_DIR)/$@.o bootloader/$@.asm
 	$(LD) -Ttext=0x7c00 -melf_i386 -o $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.o
@@ -26,7 +30,7 @@ stage1: $(BUILD_DIR)
 # Alternatively, convey the final stage2 size through other means to stage1.
 stage2: $(BUILD_DIR)
 	$(AS) $(ASFLAGS) -o $(BUILD_DIR)/stage2.o bootloader/stage2.asm
-	$(CC) -std=c11 -ffreestanding -nostdlib -fno-stack-protector -m32 -g -c -o $(BUILD_DIR)/stage2_load.o bootloader/stage2_load.c
+	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $(BUILD_DIR)/stage2_load.o bootloader/stage2_load.c
 	$(LD) -Tbootloader/stage2.ld -melf_i386 -o $(BUILD_DIR)/$@.elf $(BUILD_DIR)/stage2.o $(BUILD_DIR)/stage2_load.o
 	$(OBJCOPY) -O binary $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.bin
 	truncate -s $(STAGE2_SIZE) $(BUILD_DIR)/$@.bin
@@ -35,10 +39,13 @@ $(BUILD_DIR)/asm_%.o: kernel/%.asm
 	$(AS) $(ASFLAGS) -o $@ $<
 
 $(BUILD_DIR)/%.o: kernel/%.c
-	$(CC) -std=c11 -ffreestanding -nostdlib -fno-stack-protector -m32 -g -c -o $@ $<
+	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $@ $<
 
-kernel: $(KERNEL_OBJ) | $(BUILD_DIR)
-	$(LD) -melf_i386 -Tkernel/linker.ld -o $(BUILD_DIR)/kernel.elf $(KERNEL_OBJ)
+$(BUILD_DIR)/klibc/%.o: klibc/src/%.c
+	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $@ $<
+
+kernel: $(KERNEL_OBJ) | $(BUILD_DIR) $(KLIBC_OBJ)
+	$(LD) -melf_i386 -Tkernel/linker.ld -o $(BUILD_DIR)/kernel.elf $(KERNEL_OBJ) $(KLIBC_OBJ)
 
 $(DISK_IMG): stage1 stage2 kernel
 	dd if=$(BUILD_DIR)/stage1.bin of=$@
@@ -48,6 +55,11 @@ $(DISK_IMG): stage1 stage2 kernel
 
 $(BUILD_DIR):
 	mkdir -p $@
+	mkdir -p $(BUILD_DIR)/klibc
+
+compile-commands: $(BUILD_DIR)/compile_commands.json
+$(BUILD_DIR)/compile_commands.json: $(BUILD_DIR)
+	bear --output $@ -- make -B
 
 run:
 	qemu-system-i386 -s -S $(DISK_IMG)
@@ -57,4 +69,9 @@ gdb:
 
 clean:
 	rm -rf $(BUILD_DIR)
+
+clean-cross:
 	rm -rf $(CROSS_DIR)
+	rm -rf .build.env
+
+clean-all: clean clean-cross

bootloader/stage2.asm

@@ -24,75 +24,3 @@ _start:
     call load_kernel
 
     jmp eax
-
-; ----------------------------------------------------------------------------
-; ATA read sectors (LBA mode) 
-;
-; sysv32 abi signature:
-; void ata_lba_read(uint32_t lba, uint8_t nsect, void *addr);
-; ----------------------------------------------------------------------------
-ata_lba_read:
-    push ebp
-    mov ebp, esp
-
-    push ebx
-    push ecx
-    push edx
-    push edi
-
-    mov eax, [ebp+8]     ; arg #1 = LBA
-    mov cl, [ebp+12]     ; arg #2 = # of sectors
-    mov edi, [ebp+16]    ; arg #3 = buffer address
-    and eax, 0x0FFFFFFF
-
-    mov ebx, eax         ; Save LBA in RBX
-
-    mov edx, 0x01F6      ; Port to send drive and bit 24 - 27 of LBA
-    shr eax, 24          ; Get bit 24 - 27 in al
-    or al, 11100000b     ; Set bit 6 in al for LBA mode
-    out dx, al
-
-    mov edx, 0x01F2      ; Port to send number of sectors
-    mov al, cl           ; Get number of sectors from CL
-    out dx, al
-
-    mov edx, 0x1F3       ; Port to send bit 0 - 7 of LBA
-    mov eax, ebx         ; Get LBA from EBX
-    out dx, al
-
-    mov edx, 0x1F4       ; Port to send bit 8 - 15 of LBA
-    mov eax, ebx         ; Get LBA from EBX
-    shr eax, 8           ; Get bit 8 - 15 in AL
-    out dx, al
-
-    mov edx, 0x1F5       ; Port to send bit 16 - 23 of LBA
-    mov eax, ebx         ; Get LBA from EBX
-    shr eax, 16          ; Get bit 16 - 23 in AL
-    out dx, al
-
-    mov edx, 0x1F7       ; Command port
-    mov al, 0x20         ; Read with retry.
-    out dx, al
-
-    mov bl, cl          ; Save # of sectors in BL
-
-.wait_drq:
-    mov edx, 0x1F7
-.do_wait_drq:
-    in al, dx
-    test al, 8           ; the sector buffer requires servicing.
-    jz .do_wait_drq      ; keep polling until the sector buffer is ready.
-
-    mov edx, 0x1F0       ; Data port, in and out
-    mov ecx, 256
-    rep insw             ; in to [RDI]
-
-    dec bl               ; are we...
-    jnz .wait_drq        ; ...done?
-
-    pop edi
-    pop edx
-    pop ecx
-    pop ebx
-    pop ebp
-    ret

bootloader/stage2.ld

@@ -9,6 +9,4 @@ SECTIONS {
         *(.bss*)
         *(COMMON)
     }
-
-    read_buf = .;
 }

bootloader/stage2_load.c

@@ -1,11 +1,39 @@
+#include <stddef.h>
 #include <stdint.h>
 
+// ATA IO Ports
+#define ATA_PRIMARY_DATA            0x1F0
+#define ATA_PRIMARY_ERR_FEATURES    0x1F1
+#define ATA_PRIMARY_SEC_COUNT       0x1F2
+#define ATA_PRIMARY_LBA_LOW         0x1F3
+#define ATA_PRIMARY_LBA_MID         0x1F4
+#define ATA_PRIMARY_LBA_HIGH        0x1F5
+#define ATA_PRIMARY_DRIVE_SEL       0x1F6
+#define ATA_PRIMARY_COMM_STAT       0x1F7
+
+// ATA Commands
+#define ATA_CMD_READ_PIO            0x20
+#define ATA_CMD_WRITE_PIO           0x30
+
 // ELF Ident indexes
-#define EI_NIDENT 16
+#define EI_NIDENT                   16
 
 // Program header types
-#define PT_NULL    0
-#define PT_LOAD    1
+#define PT_NULL                     0
+#define PT_LOAD                     1
+
+// Disk sector size
+#define SECTOR_SIZE                 512
+#define PH_PER_SECTOR               (SECTOR_SIZE / sizeof(Elf32_Phdr))
+
+// Kernel start LBA
+#define KERN_START_SECT             5
+
+// VGA
+// Expects bios initialization for text mode (3), buffer at 0xb8000
+#define VGA_ADDRESS                 0xB8000
+#define VGA_COLS                    80
+#define VGA_ROWS                    25
 
 // ELF Header (32-bit)
 typedef struct {
@@ -37,82 +65,171 @@ typedef struct {
     uint32_t p_align;
 } __attribute__((packed)) Elf32_Phdr;
 
+static inline uint8_t inb(uint16_t port)
+{
+    uint8_t ret;
+    __asm__ volatile ("inb %1, %0"
+                      : "=a"(ret)
+                      : "Nd"(port));
+    return ret;
+}
+
+static inline void outb(uint16_t port, uint8_t val)
+{
+    __asm__ volatile ("outb %0, %1"
+                      :
+                      : "a"(val), "Nd"(port));
+}
+
+static inline uint16_t inw(uint16_t port)
+{
+    uint16_t ret;
+    __asm__ volatile ("inw %1, %0"
+                      : "=a"(ret)
+                      : "Nd"(port));
+    return ret;
+}
+
+static inline void ata_wait_bsy() {
+    while (inb(ATA_PRIMARY_COMM_STAT) & 0x80);
+}
+
+static inline void ata_wait_drq() {
+    while (!(inb(ATA_PRIMARY_COMM_STAT) & 0x08));
+}
+
+static void ata_read_sector(void *addr, uint32_t lba) {
+    ata_wait_bsy();
+
+    outb(ATA_PRIMARY_DRIVE_SEL, 0xE0 | ((lba >> 24) & 0x0F));
+    outb(ATA_PRIMARY_SEC_COUNT, 1);
+    outb(ATA_PRIMARY_LBA_LOW, (uint8_t)lba);
+    outb(ATA_PRIMARY_LBA_MID, (uint8_t)(lba >> 8));
+    outb(ATA_PRIMARY_LBA_HIGH, (uint8_t)(lba >> 16));
+    outb(ATA_PRIMARY_COMM_STAT, ATA_CMD_READ_PIO);
+
+    uint16_t* ptr = (uint16_t*)addr;
+    ata_wait_bsy();
+    ata_wait_drq();
+    for (int i = 0; i < 256; i++) {
+        *ptr++ = inw(ATA_PRIMARY_DATA);
+    }
+}
+
+static void ata_read_sectors(uint8_t *addr, uint32_t offset, uint32_t size)
+{
+    // Reads are offset from the starting sector of the kernel
+    uint32_t lba = KERN_START_SECT + offset / SECTOR_SIZE;
+    uint32_t off = offset % 512;
+    uint8_t data[512];
+
+    while (size > 0) {
+        ata_read_sector(data, lba);
+
+        uint32_t copy = 512 - off;
+        if (copy > size) {
+            copy = size;
+        }
+
+        for (uint32_t i = 0; i < copy; i++) {
+            addr[i] = data[off + i];
+        }
+
+        addr += copy;
+        size -= copy;
+        lba++;
+        off = 0;
+    }
+}
+
+static void on_error(const char *msg)
+{
+    uint16_t *ptr = (uint16_t *)VGA_ADDRESS;
+
+    // Clear
+    uint16_t val = 0x0f00 | (uint8_t)' ';
+    for (size_t i = 0; i < VGA_COLS * VGA_ROWS; i++) {
+        ptr[i] = val;
+    }
+
+    // Print error
+    for (size_t i = 0; msg[i]; i++) {
+        ptr[i] = 0xf00 | (uint8_t)msg[i];
+    }
+
+    // Halt
+    while (1) {
+        __asm__("hlt");
+    }
+}
+
 // Load an ELF executable into memory.
-static int elf_load(const void* data, void (*load_segment)(uint8_t *vaddr, uint32_t src, uint32_t size)) {
-    const Elf32_Ehdr* header = (const Elf32_Ehdr*)data;
-    const Elf32_Phdr* ph = (const Elf32_Phdr*)((uint8_t*)data + header->e_phoff);
+// NOTE: Only 32-byte program headers are supported.
+// Returns the entry point to the program.
+static void *elf_load(const void *data) {
+    const Elf32_Ehdr *header = (const Elf32_Ehdr*)data;
+
+    if (header->e_phentsize != sizeof(Elf32_Phdr)) {
+        // The bootloader only handles 32-byte program header entries
+        on_error("ERROR: Unsupported program header entry size, halting...");
+    }
+
+    // Buffer for the program headers
+    uint8_t file_buf[SECTOR_SIZE];
+
+    // Current file offset to the next program header
+    uint32_t file_offset = header->e_phoff;
 
     for (int i = 0; i < header->e_phnum; i++) {
-        if (ph[i].p_type != PT_LOAD)
+        // Check for sector boundary.
+        // Program headers are read in a sector at a time
+        // 512 / 32 = 16 PH per sector
+        if (i % PH_PER_SECTOR == 0) {
+            uint32_t count = (header->e_phnum - i) * sizeof(Elf32_Phdr);
+            if (count > SECTOR_SIZE) {
+                count = SECTOR_SIZE;
+            }
+
+            // Reads
+            ata_read_sectors(file_buf, file_offset, count);
+            file_offset += count;
+        }
+
+        // PH being processed currently, index mod 16 as headers
+        // are being loaded in sector by sector.
+        const Elf32_Phdr *ph = (const Elf32_Phdr *)file_buf + (i % PH_PER_SECTOR);
+
+        // Discard non-load segments
+        if (ph->p_type != PT_LOAD)
             continue;
 
-        uint32_t offset = ph[i].p_offset;
-        uint32_t vaddr = ph[i].p_vaddr;
-        uint32_t filesz = ph[i].p_filesz;
-        uint32_t memsz = ph[i].p_memsz;
-
-        // Copy data segment
-        //load_segment((uint8_t *)vaddr, offset, filesz);
-        load_segment((uint8_t *)vaddr, offset, filesz);
+        // Load in the segment
+        uint32_t offset = ph->p_offset;
+        uint32_t filesz = ph->p_filesz;
+        uint32_t memsz = ph->p_memsz;
+        uint8_t *vaddr = (uint8_t *)ph->p_vaddr;
+        ata_read_sectors(vaddr, offset, filesz);
 
         // Zero remaining BSS (if any)
         if (memsz > filesz) {
-            uint8_t* bss_start = (uint8_t*)(vaddr + filesz);
+            uint8_t* bss_start = vaddr + filesz;
             for (uint32_t j = 0; j < memsz - filesz; j++) {
                 bss_start[j] = 0;
             }
         }
     }
 
-    return header->e_entry;
-}
-
-#define KERN_START_SECT 5
-#define MAX(a, b) ((a)>(b) ? (a) : (b))
-
-extern void ata_lba_read(uint32_t lba, uint8_t nsect, void *addr);
-extern uint8_t read_buf[];
-
-static uint32_t
-total_header_size(const Elf32_Ehdr *header) {
-    uint32_t phend = header->e_phoff + header->e_phentsize*header->e_phnum;
-
-    // Align to 512
-    return (phend + 511) & ~511;
-}
-
-static void read_sectors(uint8_t *vaddr, uint32_t offset, uint32_t size) {
-    // # of sectors to read
-    uint32_t rem_nsect = ((size + 511) & ~511) / 512;
-
-    // Current lba address, offset by the first sector already read
-    uint32_t lba = KERN_START_SECT + offset / 512;
-
-    // Max 255 sectors at a time
-    while (rem_nsect) {
-        uint8_t nsect = rem_nsect > 255 ? 255 : rem_nsect;
-        ata_lba_read(lba, nsect, vaddr);
-
-        vaddr += nsect * 512;
-        rem_nsect -= nsect;
-        lba += nsect;
-    }
+    // Return the entry point
+    return (void *)header->e_entry;
 }
 
 void *load_kernel(void) {
-    // Read the first sector
-    ata_lba_read(KERN_START_SECT, 1, read_buf);
+    // ELF header buffer
+    uint8_t header_buf[SECTOR_SIZE];
 
-    const Elf32_Ehdr* header = (const Elf32_Ehdr*)read_buf;
+    // Read the first sector (contains the ELF header)
+    ata_read_sector(header_buf, KERN_START_SECT);
 
-    // Remaining data size, subtract the first 512B already read
-    uint32_t rem = total_header_size(header) - 512;
-
-    // Read the rest if necessary
-    if (rem)
-        read_sectors(read_buf+512, 512, rem);
-
-    elf_load(read_buf, read_sectors);
-
-    return (void *)header->e_entry;
+    // `elf_load()` returns the entry point
+    return elf_load(header_buf);
 }

kernel/ata.c

@@ -0,0 +1,119 @@
+#include "ata.h"
+#include "io.h"
+#include "print.h"
+
+#define ATA_TIMEOUT 100000
+
+static inline void ata_delay(void) {
+    /* 400ns delay by reading alternate status */
+    inb(ATA_PRIMARY_CTRL);
+    inb(ATA_PRIMARY_CTRL);
+    inb(ATA_PRIMARY_CTRL);
+    inb(ATA_PRIMARY_CTRL);
+}
+
+bool ata_wait_ready(void) {
+    for (int i = 0; i < ATA_TIMEOUT; i++) {
+        uint8_t status = inb(ATA_PRIMARY_IO + ATA_REG_STATUS);
+        /* Must NOT be busy AND must be ready */
+        if (!(status & ATA_SR_BSY) && (status & ATA_SR_DRDY))
+            return true;
+    }
+    return false;
+}
+
+static bool ata_wait(uint8_t mask) {
+    for (int i = 0; i < ATA_TIMEOUT; i++) {
+        uint8_t status = inb(ATA_PRIMARY_IO + ATA_REG_STATUS);
+        /* If ERR is set, stop waiting and return failure */
+        if (status & ATA_SR_ERR) return false;
+        
+        if (!(status & ATA_SR_BSY) && (status & mask))
+            return true;
+    }
+    return false;
+}
+
+bool ata_init(void) {
+    /* Select drive */
+    outb(ATA_PRIMARY_IO + ATA_REG_HDDEVSEL, ATA_MASTER);
+    ata_delay();
+
+    /* Check if drive exists */
+    uint8_t status = inb(ATA_PRIMARY_IO + ATA_REG_STATUS);
+    if (status == 0xFF || status == 0) return false;
+
+    outb(ATA_PRIMARY_IO + ATA_REG_COMMAND, ATA_CMD_IDENTIFY);
+    ata_delay();
+
+    if (!ata_wait(ATA_SR_DRQ))
+        return false;
+
+    uint16_t identify[256];
+    for (int i = 0; i < 256; i++)
+        identify[i] = inw(ATA_PRIMARY_IO);
+
+    print_string("[ATA] Primary master detected\n");
+    return true;
+}
+
+bool ata_read_sector(uint32_t lba, uint8_t* buffer) {
+    if (!buffer) return false;
+
+    /* 1. Wait for drive to be ready for command */
+    if (!ata_wait_ready()) return false;
+
+    /* 2. Setup Task File (LBA28) */
+    outb(ATA_PRIMARY_IO + ATA_REG_HDDEVSEL, 0xE0 | ((lba >> 24) & 0x0F));
+    outb(ATA_PRIMARY_IO + ATA_REG_SECCOUNT0, 1);
+    outb(ATA_PRIMARY_IO + ATA_REG_LBA0, (uint8_t)(lba));
+    outb(ATA_PRIMARY_IO + ATA_REG_LBA1, (uint8_t)(lba >> 8));
+    outb(ATA_PRIMARY_IO + ATA_REG_LBA2, (uint8_t)(lba >> 16));
+    
+    /* 3. Issue Read Command */
+    outb(ATA_PRIMARY_IO + ATA_REG_COMMAND, ATA_CMD_READ_PIO);
+
+    /* 4. Wait for Data Request (DRQ) */
+    if (!ata_wait(ATA_SR_DRQ))
+        return false;
+
+    /* 5. Transfer data */
+    for (int i = 0; i < 256; i++) {
+        uint16_t data = inw(ATA_PRIMARY_IO);
+        buffer[i * 2]     = data & 0xFF;
+        buffer[i * 2 + 1] = (data >> 8) & 0xFF;
+    }
+
+    ata_delay();
+    return true;
+}
+
+bool ata_write_sector(uint32_t lba, const uint8_t* buffer) {
+    if (!buffer) return false;
+
+    /* 1. Wait for drive to be ready for command */
+    if (!ata_wait_ready()) return false;
+
+    /* 2. Setup Task File */
+    outb(ATA_PRIMARY_IO + ATA_REG_HDDEVSEL, 0xE0 | ((lba >> 24) & 0x0F));
+    outb(ATA_PRIMARY_IO + ATA_REG_SECCOUNT0, 1);
+    outb(ATA_PRIMARY_IO + ATA_REG_LBA0, (uint8_t)(lba));
+    outb(ATA_PRIMARY_IO + ATA_REG_LBA1, (uint8_t)(lba >> 8));
+    outb(ATA_PRIMARY_IO + ATA_REG_LBA2, (uint8_t)(lba >> 16));
+    
+    /* 3. Issue Write Command */
+    outb(ATA_PRIMARY_IO + ATA_REG_COMMAND, ATA_CMD_WRITE_PIO);
+
+    /* 4. Wait for drive to request data */
+    if (!ata_wait(ATA_SR_DRQ))
+        return false;
+
+    /* 5. Transfer data */
+    for (int i = 0; i < 256; i++) {
+        uint16_t word = buffer[i * 2] | (buffer[i * 2 + 1] << 8);
+        outw(ATA_PRIMARY_IO, word);
+    }
+
+    ata_delay();
+    return true;
+}

kernel/ata.h

@@ -0,0 +1,44 @@
+#ifndef ATA_H
+#define ATA_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* ATA I/O ports */
+#define ATA_PRIMARY_IO     0x1F0
+#define ATA_PRIMARY_CTRL   0x3F6
+
+/* ATA registers */
+#define ATA_REG_DATA       0x00
+#define ATA_REG_ERROR      0x01
+#define ATA_REG_FEATURES   0x01
+#define ATA_REG_SECCOUNT0  0x02
+#define ATA_REG_LBA0       0x03
+#define ATA_REG_LBA1       0x04
+#define ATA_REG_LBA2       0x05
+#define ATA_REG_HDDEVSEL   0x06
+#define ATA_REG_COMMAND    0x07
+#define ATA_REG_STATUS     0x07
+
+/* ATA commands */
+#define ATA_CMD_READ_PIO   0x20
+#define ATA_CMD_WRITE_PIO  0x30
+#define ATA_CMD_IDENTIFY   0xEC
+
+/* Status flags */
+#define ATA_SR_BSY         0x80
+#define ATA_SR_DRDY        0x40
+#define ATA_SR_DRQ         0x08
+#define ATA_SR_ERR         0x01
+
+/* Drive select */
+#define ATA_MASTER         0xA0
+#define ATA_SLAVE          0xB0
+
+/* Public API */
+bool ata_init(void);
+bool ata_read_sector(uint32_t lba, uint8_t* buffer);
+bool ata_write_sector(uint32_t lba, const uint8_t* buffer);
+bool ata_wait_ready(void);
+
+#endif

kernel/context_switch.asm

@@ -1,4 +1,4 @@
-.global ctx_switch
+global ctx_switch
 
 ; void ctx_switch(uint32_t **old_sp_ptr, uint32_t *new_sp);
 ; Arguments on stack (cdecl convention):

kernel/cpu.c

@@ -2,36 +2,106 @@
 #include "serial.h"
 #include "terminal.h"
 #include "utils.h"
-#include "print.h"
 
-void cpuid(uint32_t function, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx) {
+void cpuid(uint32_t leaf, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx) {
     __asm__(
         "cpuid"
         : "=a"(*eax), "=b"(*ebx), "=c"(*ecx), "=d"(*edx)
-        : "a"(function)
+        : "a"(leaf)
     );
 }
 
+// Helper to print a labeled decimal value
+void print_val(const char* label, uint32_t val) {
+    char buf[12];
+    utoa(val, buf, 10);
+    terminal_write(label);
+    terminal_write(buf);
+    terminal_write(" ");
+}
+
+// Safely check if CPUID is supported by attempting to flip bit 21 of EFLAGS
+int check_cpuid_supported() {
+    uint32_t f1, f2;
+    __asm__ volatile (
+        "pushfl\n\t"
+        "pushfl\n\t"
+        "popl %0\n\t"
+        "movl %0, %1\n\t"
+        "xorl $0x200000, %0\n\t"
+        "pushl %0\n\t"
+        "popfl\n\t"
+        "pushfl\n\t"
+        "popl %0\n\t"
+        "popfl\n\t"
+        : "=&r" (f1), "=&r" (f2));
+    return ((f1 ^ f2) & 0x200000) != 0;
+}
+
 void identify_cpu() {
+    if (!check_cpuid_supported()) {
+        terminal_write("CPUID not supported. Likely a 386 or early 486.\n");
+        return;
+    }
+
     uint32_t eax, ebx, ecx, edx;
     char vendor[13];
 
+    // Leaf 0: Vendor String & Max Leaf
     cpuid(0, &eax, &ebx, &ecx, &edx);
-
+    uint32_t max_leaf = eax;
     *(uint32_t *)&vendor[0] = ebx;
     *(uint32_t *)&vendor[4] = edx;
     *(uint32_t *)&vendor[8] = ecx;
     vendor[12] = '\0';
 
-    terminal_write("CPU Vendor: ");
+    terminal_write("Vendor: ");
     terminal_write(vendor);
     terminal_write("\n");
 
-    serial_write("CPU Vendor: ");
-    serial_write(vendor);
-    serial_write("\n");
+    // Leaf 1: Family, Model, Stepping
+    if (max_leaf >= 1) {
+        cpuid(1, &eax, &ebx, &ecx, &edx);
+        
+        uint32_t stepping = eax & 0xF;
+        uint32_t model = (eax >> 4) & 0xF;
+        uint32_t family = (eax >> 8) & 0xF;
+        uint32_t type = (eax >> 12) & 0x3;
 
-    terminal_write("CPUID max leaf: ");
-    print_hex(eax, false, false);  // You must implement this (see below)
-    terminal_write("\n");
+        // Handle Extended Family/Model (Required for Pentium 4 and newer)
+        if (family == 0xF) {
+            family += (eax >> 20) & 0xFF;
+            model += ((eax >> 16) & 0xF) << 4;
+        }
+
+        print_val("Family:", family);
+        print_val("Model:", model);
+        print_val("Step:", stepping);
+        terminal_write("\n");
+    }
+
+    // Leaf 2: Cache Descriptors
+    if (max_leaf >= 2) {
+        cpuid(2, &eax, &ebx, &ecx, &edx);
+        
+        terminal_write("Cache Descriptors: ");
+        // Note: Leaf 2 returns a list of 1-byte descriptors in the registers.
+        // We look for common Intel ones:
+        uint32_t regs[4] = {eax, ebx, ecx, edx};
+        for (int i = 0; i < 4; i++) {
+            if (regs[i] & 0x80000000) continue; // Reserved bit
+            for (int j = 0; j < 4; j++) {
+                uint8_t desc = (regs[i] >> (j * 8)) & 0xFF;
+                if (desc == 0) continue;
+                
+                // Example decoding for specific chips you mentioned:
+                if (desc == 0x06) terminal_write("8KB L1 I-Cache ");
+                if (desc == 0x0A) terminal_write("8KB L1 D-Cache ");
+                if (desc == 0x41) terminal_write("128KB L2 ");
+                if (desc == 0x43) terminal_write("512KB L2 ");
+                if (desc == 0x2C) terminal_write("32KB L1 D-Cache ");
+            }
+        }
+        terminal_write("\n");
+    }
 }

kernel/cpu.h

@@ -2,8 +2,42 @@
 #define CPU_H
 
 #include <stdint.h>
+#include <stdbool.h>
 
-void cpuid(uint32_t function, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx);
+// Specific Intel Model Definitions for your targets
+#define INTEL_FAM4_486_DX      0x00 // Also 0x01
+#define INTEL_FAM4_486_SX      0x02
+#define INTEL_FAM4_486_DX2     0x03
+#define INTEL_FAM4_486_DX4     0x08
+#define INTEL_FAM5_PENTIUM     0x01 // P5
+#define INTEL_FAM5_PENTIUM_MMX 0x04 // P55C
+#define INTEL_FAM6_PENTIUM_PRO 0x01 // P6
+#define INTEL_FAM6_PENTIUM_II  0x05 // Deschutes
+#define INTEL_FAM6_PENTIUM_III 0x07 // Katmai/Coppermine
+#define INTEL_FAM15_P4_WILLY   0x00 // Willamette
+#define INTEL_FAM15_P4_NORTH   0x02 // Northwood
+#define INTEL_FAM15_P4_PRES    0x03 // Prescott
+
+typedef struct {
+    char vendor[13];
+    uint32_t family;
+    uint32_t model;
+    uint32_t stepping;
+    uint32_t type;
+    uint32_t max_leaf;
+    
+    // Feature flags (optional, but very helpful later)
+    bool has_fpu;
+    bool has_mmx;
+    bool has_sse;
+} cpu_info_t;
+
+// Function Prototypes
+void cpuid(uint32_t leaf, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx);
+bool cpu_check_cpuid_support(void);
 void identify_cpu(void);
 
+// Helper to get the current CPU info after identification
+cpu_info_t* cpu_get_info(void);
+
 #endif // CPU_H

kernel/display.c

@@ -1,36 +1,80 @@
+#include <string.h>
 #include "display.h"
-#include "io.h" // Include your I/O header for port access
+#include "io.h"
 #include "vga.h"
 
 // Initialize the display
 void init_display(void) {
-    // Initialize VGA settings, if necessary
-    // This could involve setting up the VGA mode, etc.
-    set_display_mode(0x13); // Example: Set to 320x200 256-color mode
+    // Initialize the VGA driver. This typically sets up the 80x25 text mode,
+    // clears the screen, and sets the cursor.
+    vga_init();
 }
 
 // Enumerate connected displays
 void enumerate_displays(void) {
-    // This is a simplified example. Actual enumeration may require
-    // reading from specific VGA registers or using BIOS interrupts.
+    // This function is often a complex operation in a real driver.
+    // In this simplified kernel/VGA text mode environment, we use printf
+    // to output a message and rely on the fact that VGA is present.
     
-    // For demonstration, we will just print a message
-    // In a real driver, you would check the VGA registers
-    // to determine connected displays.
-    clear_display();
-    // Here you would typically read from VGA registers to find connected displays
-    // For example, using inb() to read from VGA ports
+    // Clear the display before printing a message
+    vga_clear(vga_entry_color(VGA_COLOR_LIGHT_GREY, VGA_COLOR_BLACK));
+    
+    // Output a simplified enumeration message
+    vga_printf("Display: Standard VGA Text Mode (80x25) Detected.\n");
+    
+    // In a real driver, you would use inb() and outb() with specific VGA ports
+    // to read information (e.g., from the CRTC registers 0x3D4/0x3D5)
+    // to check for display presence or configuration.
 }
 
 // Set the display mode
+// NOTE: Setting arbitrary VGA modes (like 0x13 for 320x200) is very complex
+// and requires writing hundreds of register values, often done via BIOS in
+// real mode. Since we are in protected mode and have a simple text driver,
+// this function is kept simple or treated as a placeholder for full mode changes.
 void set_display_mode(uint8_t mode) {
-    // Set the VGA mode by writing to the appropriate registers
-    outb(VGA_PORT, mode); // Example function to write to a port
+    // Check if the requested mode is a known mode (e.g., VGA Text Mode 3)
+    // For this example, we simply acknowledge the call.
+    // A true mode set would involve complex register sequencing.
+    
+    // The provided vga.c is a Text Mode driver, so a graphical mode set
+    // like 0x13 (320x200 256-color) would break the existing vga_printf functionality.
+    
+    // A simplified text-mode-specific response:
+    if (mode == 0x03) { // Mode 3 is standard 80x25 text mode
+        vga_printf("Display mode set to 80x25 Text Mode (Mode 0x03).\n");
+        vga_init(); // Re-initialize the text mode
+    } else {
+        // Simple I/O example based on the original structure (Caution: Incomplete for full mode set)
+        outb(VGA_PORT, mode); // Example function to write to a port
+        vga_printf("Attempting to set display mode to 0x%x. (Warning: May break current display)\n", mode);
+    }
 }
 
 // Clear the display
 void clear_display(void) {
-    // Clear the display by filling it with a color
-    // This is a placeholder for actual clearing logic
-    // You would typically write to video memory here
+    // Use the VGA driver's clear function, typically clearing to black on light grey
+    // or black on black. We'll use the black on light grey from vga_init for consistency.
+    vga_clear(vga_entry_color(VGA_COLOR_BLACK, VGA_COLOR_LIGHT_GREY));
+    // Reset cursor to 0, 0
+    vga_set_cursor_position(0, 0);
+}
+
+// Helper function to write a string
+void display_write_string(const char* str) {
+    // Use the VGA driver's string writing function
+    vga_write_string(str, strlen(str));
+}
+
+// Helper function to print a formatted string
+void display_printf(const char* format, ...) {
+    // Use the VGA driver's printf function
+    va_list args;
+    va_start(args, format);
+    
+    // The vga_printf function already handles the va_list internally,
+    // so we can just call it directly.
+    vga_printf(format, args);
+    
+    va_end(args);
 }

kernel/display.h

@@ -2,13 +2,21 @@
 #define DISPLAY_H
 
 #include <stdint.h>
+#include "vga.h" // Include VGA functions
 
-#define VGA_PORT 0x3C0  // Base port for VGA
+#define VGA_PORT 0x3C0  // Base port for VGA (Often used for general control, though 0x3D4/0x3D5 are used for cursor)
 
 // Function prototypes
 void init_display(void);
 void enumerate_displays(void);
-void set_display_mode(uint8_t mode);
+void set_display_mode(uint8_t mode); // In this context, modes are typically BIOS or VESA modes, which are complex.
+                                      // We'll treat this as a placeholder/simple mode call.
 void clear_display(void);
 
+// New function to write a string using the VGA driver
+void display_write_string(const char* str);
+
+// New function to print a formatted string using the VGA driver
+void display_printf(const char* format, ...);
+
 #endif // DISPLAY_H

kernel/fat12.c

@@ -15,9 +15,16 @@ static uint8_t g_sector_buffer[FAT12_SECTOR_SIZE];
 static int k_memcmp(const void *s1, const void *s2, uint32_t n) {
     const uint8_t *p1 = (const uint8_t *)s1;
     const uint8_t *p2 = (const uint8_t *)s2;
+
     for (uint32_t i = 0; i < n; i++) {
-        if (p1[i] != p2[i]) return p1[i] - p2[i];
+        if (p1[i] != p2[i]) {
+            // Correct way to return the difference:
+            // If p1[i] > p2[i], returns positive.
+            // If p1[i] < p2[i], returns negative.
+            return (int)p1[i] - (int)p2[i];
+        }
     }
+
     return 0;
 }
 
@@ -182,3 +189,8 @@ uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t bytes_to_read) {
 
     return total_read;
 }
+
+int disk_read_sector(uint32_t lba, uint8_t *buffer) {
+    // For now, do nothing and return success
+    return 0; 
+}

kernel/fat12.h

@@ -58,7 +58,7 @@ typedef struct {
 
 // You must implement this in your disk driver (e.g., floppy.c)
 // Returns 0 on success, non-zero on error.
-extern int disk_read_sector(uint32_t lba, uint8_t *buffer);
+int disk_read_sector(uint32_t lba, uint8_t *buffer);
 
 void fat12_init();
 file_t fat12_open(const char *filename);

kernel/gui.c

@@ -0,0 +1,66 @@
+#include "gui.h"
+#include "vga.h"  // VGA functions for drawing and clearing screen
+#include "framebuffer.h"  // For pixel manipulation if needed
+
+// Initialize the GUI (could set up any global state or variables here)
+void gui_init(void) {
+    // Clear the screen with black or any color
+    gui_clear(vga_entry_color(VGA_COLOR_BLACK, VGA_COLOR_WHITE));
+}
+
+// Draw a window (simple rectangle with a title)
+void gui_draw_window(gui_window_t* window) {
+    // Draw the window's border
+    for (uint32_t y = 0; y < window->height; ++y) {
+        for (uint32_t x = 0; x < window->width; ++x) {
+            // Check if we are at the border
+            if (x == 0 || y == 0 || x == window->width - 1 || y == window->height - 1) {
+                vga_put_entry_at('#', vga_entry_color(VGA_COLOR_LIGHT_GREY, VGA_COLOR_BLACK), window->x + x, window->y + y);
+            } else {
+                // Fill the inside of the window
+                vga_put_entry_at(' ', vga_entry_color(VGA_COLOR_BLACK, VGA_COLOR_BLACK), window->x + x, window->y + y);
+            }
+        }
+    }
+
+    // Draw the title at the top
+    if (window->title) {
+        size_t i = 0;
+        while (window->title[i] != '\0' && i < window->width - 2) {
+            vga_put_entry_at(window->title[i], vga_entry_color(VGA_COLOR_WHITE, VGA_COLOR_BLACK), window->x + i + 1, window->y);
+            i++;
+        }
+    }
+}
+
+// Draw a button (a simple rectangle with text in the middle)
+void gui_draw_button(gui_button_t* button) {
+    for (uint32_t y = 0; y < button->height; ++y) {
+        for (uint32_t x = 0; x < button->width; ++x) {
+            // Check if we are at the border
+            if (x == 0 || y == 0 || x == button->width - 1 || y == button->height - 1) {
+                vga_put_entry_at('#', vga_entry_color(VGA_COLOR_LIGHT_GREY, VGA_COLOR_BLACK), button->x + x, button->y + y);
+            } else {
+                // Fill the inside of the button
+                vga_put_entry_at(' ', vga_entry_color(VGA_COLOR_BLACK, VGA_COLOR_BLACK), button->x + x, button->y + y);
+            }
+        }
+    }
+
+    // Draw the label in the center of the button
+    size_t label_len = 0;
+    while (button->label[label_len] != '\0') {
+        label_len++;
+    }
+
+    size_t start_x = button->x + (button->width - label_len) / 2;
+    size_t start_y = button->y + (button->height - 1) / 2;
+    for (size_t i = 0; i < label_len; ++i) {
+        vga_put_entry_at(button->label[i], vga_entry_color(VGA_COLOR_WHITE, VGA_COLOR_BLACK), start_x + i, start_y);
+    }
+}
+
+// Clear the screen with a color
+void gui_clear(uint32_t color) {
+    vga_clear(color);  // Just clear the VGA screen with a solid color
+}

kernel/gui.h

@@ -0,0 +1,34 @@
+#ifndef GUI_H
+#define GUI_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#define GUI_WINDOW_WIDTH   80
+#define GUI_WINDOW_HEIGHT  25
+#define GUI_BUTTON_WIDTH   10
+#define GUI_BUTTON_HEIGHT  3
+
+// Window structure
+typedef struct {
+    uint32_t x, y;
+    uint32_t width, height;
+    uint32_t color;  // Background color
+    const char* title;
+} gui_window_t;
+
+// Button structure
+typedef struct {
+    uint32_t x, y;
+    uint32_t width, height;
+    uint32_t color;  // Background color
+    const char* label;
+} gui_button_t;
+
+// Function prototypes for GUI elements
+void gui_init(void);
+void gui_draw_window(gui_window_t* window);
+void gui_draw_button(gui_button_t* button);
+void gui_clear(uint32_t color);
+
+#endif // GUI_H

kernel/hid.c

@@ -0,0 +1,65 @@
+#include "hid.h"
+#include "usb.h"
+#include "mouse.h"
+#include "keyboard.h"
+#include "print.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+// Global variables
+static bool hid_initialized = false;
+
+void hid_init(void) {
+    if (hid_initialized) return;
+    hid_initialized = true;
+
+    // Initialize keyboard and mouse HID handling
+    keyboard_init();
+    // Assume USB mouse has been initialized and is connected.
+    usb_hid_init(); // Initializes USB HID for both keyboard and mouse
+}
+
+void hid_process_report(uint8_t* report, uint8_t length) {
+    // Process the HID report based on its type
+    if (length == 8) {  // Assuming a standard 8-byte report for HID keyboard
+        keyboard_hid_report_t* k_report = (keyboard_hid_report_t*) report;
+        hid_process_keyboard_report(k_report);
+    } else if (length == 3) {  // Assuming a standard 3-byte report for HID mouse
+        mouse_hid_report_t* m_report = (mouse_hid_report_t*) report;
+        hid_process_mouse_report(m_report);
+    }
+}
+
+// Handle HID keyboard report
+void hid_process_keyboard_report(const keyboard_hid_report_t* report) {
+    // Iterate over the keycodes and process key presses
+    for (int i = 0; i < 6; i++) {
+        uint8_t keycode = report->keycodes[i];
+        if (keycode != 0) {
+            char key = scancode_map[keycode];
+            if (key) {
+                keyboard_buffer_add(key);
+            }
+        }
+    }
+}
+
+// Handle HID mouse report
+void hid_process_mouse_report(const mouse_hid_report_t* report) {
+    // Process mouse movement and button clicks
+    mouse_data.x += report->x;
+    mouse_data.y += report->y;
+    mouse_data.left_button = (report->buttons & 0x01) != 0;
+    mouse_data.right_button = (report->buttons & 0x02) != 0;
+
+    print_hex((uint32_t)mouse_data.x, 1, 1);
+    print_hex((uint32_t)mouse_data.y, 1, 1);
+    print_hex((uint32_t)report->buttons, 1, 1);
+}
+
+// Parse the HID descriptor (for parsing USB HID device descriptors)
+bool hid_parse_descriptor(uint8_t* descriptor, uint32_t length) {
+    // HID descriptors are defined in the USB HID specification, we'll need to parse them here.
+    // For now, just return true assuming we have a valid descriptor.
+    return true;
+}

kernel/hid.h

@@ -0,0 +1,46 @@
+#ifndef HID_H
+#define HID_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+// HID Report types
+#define HID_REPORT_INPUT  0x01
+#define HID_REPORT_OUTPUT 0x02
+#define HID_REPORT_FEATURE 0x03
+
+// HID usage page constants (USB HID)
+#define HID_USAGE_PAGE_GENERIC 0x01
+#define HID_USAGE_KEYBOARD 0x06
+#define HID_USAGE_MOUSE 0x02
+
+// HID keyboard and mouse data
+typedef struct {
+    uint8_t modifier;    // Modifier keys (shift, ctrl, alt, etc.)
+    uint8_t reserved;    // Reserved byte
+    uint8_t keycodes[6]; // Keycodes for keys pressed
+} keyboard_hid_report_t;
+
+typedef struct {
+    uint8_t buttons;     // Mouse buttons (bitwise: 0x01 = left, 0x02 = right, 0x04 = middle)
+    int8_t x;            // X axis movement
+    int8_t y;            // Y axis movement
+    int8_t wheel;        // Mouse wheel
+} mouse_hid_report_t;
+
+// Initialize the HID subsystem
+void hid_init(void);
+
+// Process an incoming HID report
+void hid_process_report(uint8_t* report, uint8_t length);
+
+// Process HID keyboard report
+void hid_process_keyboard_report(const keyboard_hid_report_t* report);
+
+// Process HID mouse report
+void hid_process_mouse_report(const mouse_hid_report_t* report);
+
+// USB HID report descriptor parsing
+bool hid_parse_descriptor(uint8_t* descriptor, uint32_t length);
+
+#endif // HID_H

kernel/irq.h

@@ -1,7 +1,7 @@
 #ifndef IRQ_H
 #define IRQ_H
 
-#include "types.h"
+#include <stdint.h>
 
 void irq_remap(void);
 void irq_install(void);

kernel/isr.c

@@ -1,3 +1,4 @@
+#include <stdbool.h>
 #include "terminal.h"
 #include "serial.h"
 #include "isr.h"

kernel/keyboard.c

@@ -2,64 +2,91 @@
 #include "io.h"
 #include "isr.h"
 #include "terminal.h"
+#include <stddef.h>
 
 #define KEYBOARD_DATA_PORT 0x60
 #define KEY_BUFFER_SIZE 256
 
-static char key_buffer[KEY_BUFFER_SIZE];
-static uint8_t buffer_head = 0;  // Write position (interrupt)
-static uint8_t buffer_tail = 0;  // Read position (get_char)
-static uint8_t buffer_count = 0;
-static uint8_t buffer_index = 0;
+// Use volatile so the compiler knows these change inside interrupts
+static volatile char key_buffer[KEY_BUFFER_SIZE];
+static volatile uint8_t buffer_head = 0;
+static volatile uint8_t buffer_tail = 0;
+static volatile uint8_t buffer_count = 0;
 
-// Basic US QWERTY keymap (scancode to ASCII)
-static const char scancode_map[128] = {
-    0,  27, '1', '2', '3', '4', '5', '6', '7', '8', // 0x00 - 0x09
-   '9', '0', '-', '=', '\b', '\t', 'q', 'w', 'e', 'r', // 0x0A - 0x13
-   't', 'y', 'z', 'u', 'i', 'o', 'p', '[', ']', '\n', // 0x14 - 0x1D
-    0, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', // 0x1E - 0x27
-   ';', '\'', '`', 0, '\\', 'x', 'c', 'v', 'b', // 0x28 - 0x31
-   'n', 'm', ',', '.', '/', 0, '*', 0, ' ', 0,      // 0x32 - 0x3B
-    // rest can be filled as needed
+// Exported map: Removed 'static' so hid.c can reference it if needed
+const char scancode_map[128] = {
+    0,  27, '1', '2', '3', '4', '5', '6', '7', '8',
+    '9', '0', '-', '=', '\b', '\t', 'q', 'w', 'e', 'r',
+    't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', 0,
+    'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',
+    '\'', '`', 0, '\\', 'z', 'x', 'c', 'v', 'b', 'n',
+    'm', ',', '.', '/', 0, '*', 0, ' ', 0
 };
 
-// Interrupt handler for IRQ1
-void keyboard_callback(void) {
-    uint8_t scancode = inb(KEYBOARD_DATA_PORT);
-
-    if (scancode & 0x80) return;  // Ignore key release
-
-    char c = scancode_map[scancode];
+/**
+ * Shared function used by both PS/2 (callback) and USB (hid.c)
+ * This fixes the "undefined reference to keyboard_buffer_add" error.
+ */
+void keyboard_buffer_add(char c) {
     if (!c) return;
 
     uint8_t next_head = (buffer_head + 1) % KEY_BUFFER_SIZE;
 
-    // Drop key if buffer full
-    if (next_head == buffer_tail) return;
+    // If buffer is full, we must drop the key
+    if (next_head == buffer_tail) {
+        return; 
+    }
 
     key_buffer[buffer_head] = c;
     buffer_head = next_head;
     buffer_count++;
 
+    // Echo to terminal
     terminal_putchar(c);
 }
 
-void keyboard_init() {
-    register_interrupt_handler(33, keyboard_callback); // IRQ1 = int 33 (0x21)
+/**
+ * Hardware Interrupt Handler for PS/2
+ */
+void keyboard_callback(void) {
+    uint8_t scancode = inb(KEYBOARD_DATA_PORT);
+
+    // Ignore break codes (key release)
+    if (scancode & 0x80) return; 
+
+    char c = scancode_map[scancode];
+    keyboard_buffer_add(c);
 }
 
-// Blocking read (returns one char)
+void keyboard_init(void) {
+    buffer_head = 0;
+    buffer_tail = 0;
+    buffer_count = 0;
+    // IRQ1 is usually mapped to IDT entry 33
+    register_interrupt_handler(33, keyboard_callback); 
+}
+
+/**
+ * Blocking read with a safe HLT to prevent CPU 100% usage
+ */
 char keyboard_get_char(void) {
-    while (buffer_count == 0) {
-        __asm__ __volatile__("hlt");  // Better than busy loop
-    }
-
     char c;
-    __asm__ __volatile__("cli");
-    c = key_buffer[buffer_tail];
-    buffer_tail = (buffer_tail + 1) % KEY_BUFFER_SIZE;
-    buffer_count--;
-    __asm__ __volatile__("sti");
 
-    return c;
+    while (1) {
+        __asm__ __volatile__("cli"); // Disable interrupts to check buffer_count safely
+        
+        if (buffer_count > 0) {
+            c = key_buffer[buffer_tail];
+            buffer_tail = (buffer_tail + 1) % KEY_BUFFER_SIZE;
+            buffer_count--;
+            __asm__ __volatile__("sti"); // Re-enable interrupts after reading
+            return c;
+        }
+
+        /* * IMPORTANT: 'sti' followed by 'hlt' is guaranteed by x86 
+         * to execute 'hlt' BEFORE the next interrupt can trigger.
+         * This prevents the race condition hang.
+         */
+        __asm__ __volatile__("sti; hlt"); 
+    }
 }

kernel/keyboard.h

@@ -1,7 +1,12 @@
 #ifndef KEYBOARD_H
 #define KEYBOARD_H
 
+#include <stdint.h>
+
 void keyboard_init(void);
-char keyboard_get_char(void);  // Blocking read from buffer
+void keyboard_buffer_add(char c);
+char keyboard_get_char(void);  
+
+extern const char scancode_map[128]; 
 
 #endif

kernel/linker.ld

@@ -1,18 +1,30 @@
 ENTRY(kmain)
 
+PHDRS {
+    text PT_LOAD FLAGS(5);    /* Read + Execute */
+    rodata PT_LOAD FLAGS(4);  /* Read only */
+    data PT_LOAD FLAGS(6);    /* Read + Write */
+}
+
 SECTIONS {
     . = 1M;
 
     .text : {
         *(.text*)
-    }
+    } :text
+
+    .rodata : {
+        *(.rodata*)
+    } :rodata
+
+    .data : {
+        *(.data*)
+    } :data
 
-    .rodata : { *(.rodata*) }
-    .data : { *(.data*) }
     .bss : {
         *(.bss*)
         *(COMMON)
-    }
+    } :data
 
     .stack (NOLOAD) : {
         . = ALIGN(4);

kernel/memory.c

@@ -1,6 +1,6 @@
 #include "memory.h"
 
-/* note: this is a stub, please use care as theres duplicate functions in utils implementation 
+/* note: this is a stub, please use care as theres duplicate functions in utils implementation
 /* --------------------------------------------------------------------- *
  *  Helper: copy a single byte (used by both memcpy and memmove)
  * --------------------------------------------------------------------- */
@@ -15,124 +15,3 @@ static inline void byte_copy_backward(uint8_t *dst, const uint8_t *src, size_t n
     while (n--) *--dst = *--src;
 }
 
-/* --------------------------------------------------------------------- *
- *  memcpy  –  no overlap allowed (behaviour undefined if overlap)
- * --------------------------------------------------------------------- */
-void *memcpy(void *restrict dst, const void *restrict src, size_t n)
-{
-    uint8_t *d = (uint8_t *)dst;
-    const uint8_t *s = (const uint8_t *)src;
-
-#if defined(MEMORY_OPTIMIZED)
-    /* Align destination to 4-byte boundary */
-    size_t align = (uintptr_t)d & 3U;
-    if (align) {
-        size_t head = 4 - align;
-        if (head > n) head = n;
-        byte_copy_forward(d, s, head);
-        d += head; s += head; n -= head;
-    }
-
-    /* 32-bit word copy – safe because we already aligned dst */
-    {
-        uint32_t *d32 = (uint32_t *)d;
-        const uint32_t *s32 = (const uint32_t *)s;
-        size_t words = n / 4;
-        while (words--) *d32++ = *s32++;
-        d = (uint8_t *)d32;
-        s = (const uint8_t *)s32;
-        n &= 3;
-    }
-#endif
-
-    byte_copy_forward(d, s, n);
-    return dst;
-}
-
-/* --------------------------------------------------------------------- *
- *  memmove – handles overlapping regions correctly
- * --------------------------------------------------------------------- */
-void *memmove(void *dst, const void *src, size_t n)
-{
-    uint8_t *d = (uint8_t *)dst;
-    const uint8_t *s = (const uint8_t *)src;
-
-    if (n == 0 || dst == src)
-        return dst;
-
-    if (d < s) {                     /* copy forward */
-#if defined(MEMORY_OPTIMIZED)
-        /* Same fast path as memcpy when no overlap */
-        size_t align = (uintptr_t)d & 3U;
-        if (align) {
-            size_t head = 4 - align;
-            if (head > n) head = n;
-            byte_copy_forward(d, s, head);
-            d += head; s += head; n -= head;
-        }
-        {
-            uint32_t *d32 = (uint32_t *)d;
-            const uint32_t *s32 = (const uint32_t *)s;
-            size_t words = n / 4;
-            while (words--) *d32++ = *s32++;
-            d = (uint8_t *)d32;
-            s = (const uint8_t *)s32;
-            n &= 3;
-        }
-#endif
-        byte_copy_forward(d, s, n);
-    } else {                         /* copy backward */
-        byte_copy_backward(d, s, n);
-    }
-    return dst;
-}
-
-/* --------------------------------------------------------------------- *
- *  memcmp  – lexicographical compare
- * --------------------------------------------------------------------- */
-int memcmp(const void *s1, const void *s2, size_t n)
-{
-    const uint8_t *a = (const uint8_t *)s1;
-    const uint8_t *b = (const uint8_t *)s2;
-
-#if defined(MEMORY_OPTIMIZED)
-    /* Align to 4-byte boundary */
-    size_t align = (uintptr_t)a & 3U;
-    if (align && align == ((uintptr_t)b & 3U)) {
-        size_t head = 4 - align;
-        if (head > n) head = n;
-        while (head--) {
-            int diff = *a++ - *b++;
-            if (diff) return diff;
-        }
-        n -= head;
-    }
-
-    {
-        const uint32_t *a32 = (const uint32_t *)a;
-        const uint32_t *b32 = (const uint32_t *)b;
-        size_t words = n / 4;
-        while (words--) {
-            uint32_t va = *a32++, vb = *b32++;
-            if (va != vb) {
-                /* byte-wise fallback for the differing word */
-                const uint8_t *pa = (const uint8_t *)(a32 - 1);
-                const uint8_t *pb = (const uint8_t *)(b32 - 1);
-                for (int i = 0; i < 4; ++i) {
-                    int diff = pa[i] - pb[i];
-                    if (diff) return diff;
-                }
-            }
-        }
-        a = (const uint8_t *)a32;
-        b = (const uint8_t *)b32;
-        n &= 3;
-    }
-#endif
-
-    while (n--) {
-        int diff = *a++ - *b++;
-        if (diff) return diff;
-    }
-    return 0;
-}

kernel/mouse.c

@@ -5,7 +5,7 @@
 #include <stdbool.h>
 
 // Mouse buffer
-static mouse_data_t mouse_data;
+mouse_data_t mouse_data;
 
 // Read USB mouse data
 mouse_data_t usb_read_mouse(void) {

kernel/mouse.h

@@ -12,6 +12,8 @@ typedef struct {
     bool right_button;
 } mouse_data_t;
 
+extern mouse_data_t mouse_data;
+
 // Function declarations for USB 1.x HID mouse support
 bool usb_mouse_init(void);
 bool usb_mouse_detected(void);

kernel/paging.c

@@ -1,21 +1,17 @@
-#include "paging.h"
-#include "io.h"
 #include <stdint.h>
-#include <stddef.h>
+#include <string.h>
+#include "io.h"
+#include "paging.h"
 
 page_directory_entry_t *page_directory = (page_directory_entry_t *)0x200000;
 page_table_entry_t     *page_table     = (page_table_entry_t *)0x201000;
-page_table_entry_t     *heap_page_table = (page_table_entry_t *)0x202000;
 
 // Helper function to set up the page directory entry
 void set_page_directory(page_directory_entry_t *dir) {
-    for (int i = 0; i < PAGE_DIRECTORY_SIZE; i++) {
-        dir[i].present = 0;
-    }
+    // Set first PDE
     dir[0].present = 1;
     dir[0].rw = 1;
-    dir[0].user = 0;
-    dir[0].frame = (uint32_t)page_table >> 12;
+    dir[0].addr = (uint32_t)page_table >> 12;
 }
 
 // Helper function to set up the page table entry
@@ -23,12 +19,8 @@ void set_page_table(page_table_entry_t *table) {
     for (int i = 0; i < PAGE_TABLE_SIZE; i++) {
         // Set up page table entries with identity mapping
         table[i].present = 1;
-        table[i].rw = 1;          // Read/Write
-        table[i].user = 0;        // Kernel mode
-        table[i].write_through = 0;
-        table[i].cache_disabled = 0;
-        table[i].accessed = 0;
-        table[i].frame = i;       // Identity mapping
+        table[i].rw = 1;        // Read/Write
+        table[i].addr = i;      // Identity mapping
     }
 }
 
@@ -47,26 +39,13 @@ void enable_paging() {
 
 // Initialize paging: set up the page directory and enable paging
 void paging_init() {
+    // Zero out the tables
+    memset(page_directory, 0x00, PAGE_DIRECTORY_SIZE * sizeof *page_directory);
+    memset(page_table, 0x00, PAGE_TABLE_SIZE * sizeof *page_table);
+
     // Set up identity-mapped page directory + table
     set_page_directory(page_directory);
     set_page_table(page_table);
 
-    // === Set up heap mapping at 0xC0100000 ===
-    for (int i = 0; i < PAGE_TABLE_SIZE; i++) {
-        heap_page_table[i].present = 1;
-        heap_page_table[i].rw = 1;
-        heap_page_table[i].user = 0;
-        heap_page_table[i].write_through = 0;
-        heap_page_table[i].cache_disabled = 0;
-        heap_page_table[i].accessed = 0;
-        heap_page_table[i].frame = (256 + i); // Start physical heap at 1MB (256*4KB = 1MB)
-    }
-
-    // Index 772 = 0xC0100000 / 4MB
-    page_directory[772].present = 1;
-    page_directory[772].rw = 1;
-    page_directory[772].user = 0;
-    page_directory[772].frame = (uint32_t)heap_page_table >> 12;
-
     enable_paging();
 }

kernel/paging.h

@@ -10,31 +10,31 @@
 
 // Page Directory and Page Table structure
 typedef struct {
-    uint32_t present : 1;  // Present bit (1: page is present in memory)
-    uint32_t rw : 1;       // Read-Write bit (1: page is read-write)
-    uint32_t user : 1;     // User-supervisor bit (1: user mode access)
-    uint32_t write_through : 1;  // Write-through cache
-    uint32_t cache_disabled : 1; // Cache disabled
-    uint32_t accessed : 1;        // Accessed bit
-    uint32_t reserved : 1;        // Reserved bit
-    uint32_t page_size : 1;       // Page size (0: 4KB, 1: 4MB)
-    uint32_t global : 1;           // Global page (can be used across different processes)
-    uint32_t available : 3;        // Available bits for the system
-    uint32_t frame : 20;           // Frame address (physical address)
+    uint32_t present : 1;           // Present bit (1: page is present in memory)
+    uint32_t rw : 1;                // Read-Write bit (1: page is read-write)
+    uint32_t user : 1;              // User-supervisor bit (1: user mode access)
+    uint32_t write_through : 1;     // Write-through cache
+    uint32_t cache_disabled : 1;    // Cache disabled
+    uint32_t accessed : 1;          // Accessed bit
+    uint32_t dirty : 1;             // Dirty bit
+    uint32_t attribute : 1;         // Page size (0: 4KB, 1: 4MB)
+    uint32_t global : 1;            // Global page (can be used across different processes)
+    uint32_t reserved : 3;          // Unused
+    uint32_t addr : 20;             // Page frame address (physical address)
 } __attribute__((packed)) page_table_entry_t;
 
 // Define page directory entry
 typedef struct {
-    uint32_t present : 1;
-    uint32_t rw : 1;
-    uint32_t user : 1;
-    uint32_t write_through : 1;
-    uint32_t cache_disabled : 1;
-    uint32_t accessed : 1;
-    uint32_t reserved : 1;
-    uint32_t zero : 5;           // Must be zero for page directory
-    uint32_t reserved_2 : 7;     // Reserved bits
-    uint32_t frame : 20;         // Frame address of the page table
+    uint32_t present : 1;           // Present bit (1: PTE is present in memory)
+    uint32_t rw : 1;                // Read-Write bit (1: pages are read-write)
+    uint32_t user : 1;              // User-supervisor bit (1: user mode access)
+    uint32_t write_through : 1;     // Write-through cache
+    uint32_t cache_disabled : 1;    // Cache disabled
+    uint32_t accessed : 1;          // Accessed bit
+    uint32_t available : 1;         // Unused
+    uint32_t page_size : 1;         // Page size (0: 4KB, 1: 4MB)
+    uint32_t available_2 : 4;       // Unused
+    uint32_t addr : 20;             // Page table address
 } __attribute__((packed)) page_directory_entry_t;
 
 extern page_directory_entry_t *page_directory;

kernel/pic.h

@@ -0,0 +1,25 @@
+#ifndef PIC_H
+#define PIC_H
+
+#include <stdint.h>
+
+/* I/O Ports for the PICs */
+#define PIC1_COMMAND 0x20
+#define PIC1_DATA    0x21
+#define PIC2_COMMAND 0xA0
+#define PIC2_DATA    0xA1
+
+/* PIC Commands */
+#define PIC_EOI      0x20  /* End of Interrupt */
+
+/* Offset vectors for remapping */
+#define PIC1_OFFSET  0x20
+#define PIC2_OFFSET  0x28
+
+void pic_init(void);
+void pic_send_eoi(uint8_t irq);
+void pic_mask(uint8_t irq);
+void pic_unmask(uint8_t irq);
+void pic_disable(void);
+
+#endif

kernel/print.h

@@ -1,7 +1,7 @@
 #ifndef PRINT_H
 #define PRINT_H
 
-#include "types.h"
+#include <stdint.h>
 
 void print_string(const char *str);
 void my_printf(const char *format, ...);

kernel/threading.c

@@ -1,9 +1,8 @@
+#include <stdbool.h>
+#include <string.h>
 #include "malloc.h"
 #include "print.h"
 #include "threading.h"
-#include "types.h"
-#include "utils.h"
-#include <stdint.h>
 
 #define MAX_THREADS 16           // Maximum number of threads
 #define THREAD_STACK_SIZE 8192   // Stack size for each thread

kernel/types.c

@@ -1 +0,0 @@
-#include "types.h"

kernel/types.h

@@ -1,62 +0,0 @@
-#ifndef TYPES_H
-#define TYPES_H
-
-// ----------------------------
-// Fixed-width integer types
-// ----------------------------
-typedef unsigned char      uint8_t;
-typedef signed char        int8_t;
-typedef unsigned short     uint16_t;
-typedef signed short       int16_t;
-typedef unsigned int       uint32_t;
-typedef signed int         int32_t;
-typedef unsigned long long uint64_t;
-typedef signed long long   int64_t;
-
-// ----------------------------
-// Boolean & NULL definitions
-// ----------------------------
-#ifndef __cplusplus
-typedef enum { false = 0, true = 1 } bool;
-#endif
-
-#ifndef NULL
-#define NULL ((void*)0)
-#endif
-
-// ----------------------------
-// OS subsystem types
-// ----------------------------
-typedef uint32_t size_t;
-typedef int32_t  ssize_t;
-
-typedef uint32_t phys_addr_t; // Physical address
-typedef uint32_t virt_addr_t; // Virtual address
-
-typedef uint32_t pid_t;       // Process ID
-typedef uint32_t tid_t;       // Thread ID
-
-// ----------------------------
-// Bitfield & utility macros
-// ----------------------------
-#define BIT(n) (1U << (n))
-#define BITS(m, n) (((1U << ((n) - (m) + 1)) - 1) << (m))
-
-// Align value to next multiple of alignment
-#define ALIGN_UP(val, align) (((val) + ((align)-1)) & ~((align)-1))
-#define ALIGN_DOWN(val, align) ((val) & ~((align)-1))
-
-// ----------------------------
-// Attributes for structures
-// ----------------------------
-#define PACKED      __attribute__((packed))
-#define ALIGN(x)    __attribute__((aligned(x)))
-
-// ----------------------------
-// Likely/unlikely branch hints
-// (for future optimization use)
-// ----------------------------
-#define likely(x)   __builtin_expect(!!(x), 1)
-#define unlikely(x) __builtin_expect(!!(x), 0)
-
-#endif // TYPES_H

kernel/utils.c

@@ -76,10 +76,3 @@ char* utoa(unsigned int value, char* str, int base) {
     reverse(str, i);
     return str;
 }
-
-void *memset(void *dest, int value, size_t len) {
-    unsigned char *ptr = (unsigned char *)dest;
-    while (len-- > 0)
-        *ptr++ = (unsigned char)value;
-    return dest;
-}

kernel/utils.h

@@ -1,7 +1,7 @@
 #ifndef UTILS_H
 #define UTILS_H
 
-#include "types.h"
+#include <stddef.h>
 
 // Convert integer to string (base is typically 10, 16, etc.)
 char* itoa(int value, char* str, int base);
@@ -9,6 +9,4 @@ char* itoa(int value, char* str, int base);
 // Convert unsigned integer to string (base is typically 10, 16, etc.)
 char* utoa(unsigned int value, char* str, int base);
 
-void *memset(void *dest, int value, size_t len);
-
 #endif // UTILS_H

kernel/vga.c

@@ -1,9 +1,9 @@
-#include "vga.h"
 #include <stddef.h>
 #include <stdbool.h>
 #include <string.h>
 #include <stdarg.h>
 #include "string_utils.h"
+#include "vga.h"
 
 void outb(uint16_t port, uint8_t value) {
     __asm__ volatile("outb %0, %1" : : "a"(value), "Nd"(port));
@@ -134,7 +134,7 @@ void vga_printf(const char* format, ...) {
     va_end(args);
     
     // Now you can use the buffer with vga_write_string
-    vga_write_string(buffer, my_strlen(buffer)); // Use my_strlen instead of strlen
+    vga_write_string(buffer, strlen(buffer)); // Use my_strlen instead of strlen
 }
 
 void vga_init(void) {

kernel/vga.h

@@ -35,6 +35,7 @@ typedef enum {
 // Function prototypes
 uint8_t vga_entry_color(vga_color fg, vga_color bg);
 uint16_t vga_entry(unsigned char uc, uint8_t color);
+void vga_init(void);
 
 void vga_put_entry_at(char c, uint8_t color, size_t x, size_t y);
 void vga_clear(uint8_t color);
@@ -50,4 +51,4 @@ void vga_set_cursor_blink_rate(uint8_t rate);
 
 void vga_printf(const char* format, ...);
 
-#endif
+#endif

klibc/include/stdarg.h

@@ -0,0 +1,14 @@
+#ifndef CLASSICOS_KLIBC_STDARG_H
+#define CLASSICOS_KLIBC_STDARG_H
+
+typedef __builtin_va_list va_list;
+
+#ifndef va_start
+#define va_start(ap, param) __builtin_va_start(ap, param)
+#endif
+
+#define va_end(ap) __builtin_va_end(ap)
+#define va_arg(ap, type) __builtin_va_arg(ap, type)
+#define va_copy(dest, src) __builtin_va_copy(dest, src)
+
+#endif  // CLASSICOS_KLIBC_STDARG_H

klibc/include/stdbool.h

@@ -0,0 +1,12 @@
+#ifndef CLASSICOS_KLIBC_STDBOOL_H
+#define CLASSICOS_KLIBC_STDBOOL_H
+
+#ifndef __cplusplus
+#define bool _Bool
+#define true 1
+#define false 0
+#endif
+
+#define __bool_true_false_are_defined 1
+
+#endif  // CLASSICOS_KLIBC_STDBOOL_H

klibc/include/stddef.h

@@ -0,0 +1,10 @@
+#ifndef CLASSICOS_KLIBC_STDDEF_H
+#define CLASSICOS_KLIBC_STDDEF_H
+
+typedef __SIZE_TYPE__ size_t;
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+
+#undef NULL
+#define NULL ((void*)0)
+
+#endif  // CLASSICOS_KLIBC_STDDEF_H

klibc/include/stdint.h

@@ -0,0 +1,16 @@
+#ifndef CLASSICOS_KLIBC_STDINT_H
+#define CLASSICOS_KLIBC_STDINT_H
+
+typedef signed char int8_t;
+typedef short int int16_t;
+typedef int int32_t;
+typedef long long int int64_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short int uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long int uint64_t;
+
+typedef unsigned int uintptr_t;
+
+#endif  // CLASSICOS_KLIBC_STDINT_H

klibc/include/stdio.h

@@ -0,0 +1,4 @@
+#ifndef CLASSICOS_KLIBC_STDIO_H
+#define CLASSICOS_KLIBC_STDIO_H
+
+#endif  // CLASSICOS_KLIBC_STDIO_H

klibc/include/stdlib.h

@@ -0,0 +1,4 @@
+#ifndef CLASSICOS_KLIBC_STDLIB_H
+#define CLASSICOS_KLIBC_STDLIB_H
+
+#endif  // CLASSICOS_KLIBC_STDLIB_H

klibc/include/string.h

@@ -0,0 +1,14 @@
+#ifndef CLASSICOS_KLIBC_STRING_H
+#define CLASSICOS_KLIBC_STRING_H
+
+#include <stddef.h>
+
+extern int memcmp(const void* s1, const void* s2, size_t n);
+extern void* memmove(void* dst, const void* src, size_t n);
+extern void* memcpy(void* dst, const void* src, size_t n);
+extern void* memset(void* dst, int c, size_t n);
+
+extern size_t strlen(const char* s);
+extern int strcmp(const char* s1, const char* s2);
+
+#endif  // CLASSICOS_KLIBC_STRING_H

klibc/src/string.c

@@ -0,0 +1,107 @@
+#include <string.h>
+
+int memcmp(const void* s1, const void* s2, size_t n) {
+    const unsigned char* c1 = s1;
+    const unsigned char* c2 = s2;
+    int d = 0;
+
+    while (n--) {
+        d = (int)*c1++ - (int)*c2++;
+        if (d) break;
+    }
+
+    return d;
+}
+
+void* memmove(void* dst, const void* src, size_t n) {
+    const char* p = src;
+    char* q = dst;
+#if defined(__i386__) || defined(__x86_64__)
+    if (q < p) {
+        __asm__ volatile("cld; rep; movsb" : "+c"(n), "+S"(p), "+D"(q));
+    } else {
+        p += (n - 1);
+        q += (n - 1);
+        __asm__ volatile("std; rep; movsb; cld" : "+c"(n), "+S"(p), "+D"(q));
+    }
+#else
+    if (q < p) {
+        while (n--) {
+            *q++ = *p++;
+        }
+    } else {
+        p += n;
+        q += n;
+        while (n--) {
+            *--q = *--p;
+        }
+    }
+#endif
+
+    return dst;
+}
+
+void* memcpy(void* dst, const void* src, size_t n) {
+    const char* p = src;
+    char* q = dst;
+#if defined(__i386__)
+    size_t nl = n >> 2;
+    __asm__ volatile("cld ; rep ; movsl ; movl %3,%0 ; rep ; movsb"
+                    : "+c"(nl), "+S"(p), "+D"(q)
+                    : "r"(n & 3));
+#elif defined(__x86_64__)
+    size_t nq = n >> 3;
+    __asm__ volatile("cld ; rep ; movsq ; movl %3,%%ecx ; rep ; movsb"
+                    : "+c"(nq), "+S"(p), "+D"(q)
+                    : "r"((uint32_t)(n & 7)));
+#else
+    while (n--) {
+        *q++ = *p++;
+    }
+#endif
+
+    return dst;
+}
+
+void* memset(void* dst, int c, size_t n) {
+    char* q = dst;
+
+#if defined(__i386__)
+    size_t nl = n >> 2;
+    __asm__ volatile("cld ; rep ; stosl ; movl %3,%0 ; rep ; stosb"
+                    : "+c"(nl), "+D"(q)
+                    : "a"((unsigned char)c * 0x01010101U), "r"(n & 3));
+#elif defined(__x86_64__)
+    size_t nq = n >> 3;
+    __asm__ volatile("cld ; rep ; stosq ; movl %3,%%ecx ; rep ; stosb"
+                    : "+c"(nq), "+D"(q)
+                    : "a"((unsigned char)c * 0x0101010101010101U),
+                      "r"((uint32_t)n & 7));
+#else
+    while (n--) {
+        *q++ = c;
+    }
+#endif
+
+    return dst;
+}
+
+size_t strlen(const char* s) {
+    const char* ss = s;
+    while (*ss) ss++;
+    return ss - s;
+}
+
+int strcmp(const char* s1, const char* s2) {
+    const unsigned char* c1 = (const unsigned char*)s1;
+    const unsigned char* c2 = (const unsigned char*)s2;
+    unsigned char ch;
+    int d = 0;
+
+    while (1) {
+        d = (int)(ch = *c1++) - (int)*c2++;
+        if (d || !ch) break;
+    }
+
+    return d;
+}

pic.c

@@ -0,0 +1,76 @@
+#include "pic.h"
+#include "io.h"
+
+/* Small delay for older hardware bus timing */
+static inline void io_wait(void) {
+    outb(0x80, 0); 
+}
+
+void pic_init(void) {
+    uint8_t a1, a2;
+
+    // Save current masks
+    a1 = inb(PIC1_DATA);
+    a2 = inb(PIC2_DATA);
+
+    // ICW1: Start initialization in cascade mode
+    outb(PIC1_COMMAND, 0x11);
+    io_wait();
+    outb(PIC2_COMMAND, 0x11);
+    io_wait();
+
+    // ICW2: Master PIC vector offset
+    outb(PIC1_DATA, PIC1_OFFSET);
+    io_wait();
+    // ICW2: Slave PIC vector offset
+    outb(PIC2_DATA, PIC2_OFFSET);
+    io_wait();
+
+    // ICW3: Tell Master there is a slave at IRQ2 (0000 0100)
+    outb(PIC1_DATA, 4);
+    io_wait();
+    // ICW3: Tell Slave its cascade identity (0000 0010)
+    outb(PIC2_DATA, 2);
+    io_wait();
+
+    // ICW4: Set 8086/88 mode
+    outb(PIC1_DATA, 0x01);
+    io_wait();
+    outb(PIC2_DATA, 0x01);
+    io_wait();
+
+    // Restore masks (or disable all to start clean)
+    outb(PIC1_DATA, 0xFB); // Keep IRQ2 (cascade) open
+    outb(PIC2_DATA, 0xFF);
+}
+
+void pic_send_eoi(uint8_t irq) {
+    if (irq >= 8) {
+        outb(PIC2_COMMAND, PIC_EOI);
+    }
+    outb(PIC1_COMMAND, PIC_EOI);
+}
+
+void pic_unmask(uint8_t irq) {
+    uint16_t port;
+    if (irq < 8) {
+        port = PIC1_DATA;
+    } else {
+        port = PIC2_DATA;
+        irq -= 8;
+    }
+    uint8_t value = inb(port) & ~(1 << irq);
+    outb(port, value);
+}
+
+void pic_mask(uint8_t irq) {
+    uint16_t port;
+    if (irq < 8) {
+        port = PIC1_DATA;
+    } else {
+        port = PIC2_DATA;
+        irq -= 8;
+    }
+    uint8_t value = inb(port) | (1 << irq);
+    outb(port, value);
+}