Refactor k_memcmp and implement disk_read_sector

Refactor memory comparison function and add disk read sector function.

.gitignore

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

Makefile

@@ -6,7 +6,6 @@ QEMU= qemu-system-i386
 OBJCOPY = i386-elf-objcopy
 
 BUILD_DIR = build
-CROSS_DIR = cross
 DISK_IMG = $(BUILD_DIR)/disk.img
 STAGE2_SIZE = 2048
 
@@ -15,9 +14,6 @@ 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))
-
 all: $(DISK_IMG)
 
 .PHONY: stage1 stage2 kernel run gdb clean
@@ -30,7 +26,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 -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $(BUILD_DIR)/stage2_load.o bootloader/stage2_load.c
+	$(CC) -std=c11 -ffreestanding -nostdlib -fno-stack-protector -m32 -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
@@ -39,13 +35,10 @@ $(BUILD_DIR)/asm_%.o: kernel/%.asm
 	$(AS) $(ASFLAGS) -o $@ $<
 
 $(BUILD_DIR)/%.o: kernel/%.c
-	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $@ $<
+	$(CC) -std=c11 -ffreestanding -nostdlib -fno-stack-protector -m32 -g -c -o $@ $<
 
-$(BUILD_DIR)/klibc/%.o: klibc/src/%.c
+kernel: $(KERNEL_OBJ) | $(BUILD_DIR)
-	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $@ $<
+	$(LD) -melf_i386 -Tkernel/linker.ld -o $(BUILD_DIR)/kernel.elf $(KERNEL_OBJ)
-
-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=$@
@@ -55,7 +48,6 @@ $(DISK_IMG): stage1 stage2 kernel
 
 $(BUILD_DIR):
 	mkdir -p $@
-	mkdir -p $(BUILD_DIR)/klibc
 
 run:
 	qemu-system-i386 -s -S $(DISK_IMG)
@@ -65,9 +57,4 @@ gdb:
 
 clean:
 	rm -rf $(BUILD_DIR)
-
-clean-cross:
 	rm -rf $(CROSS_DIR)
-	rm -rf .build.env
-
-clean-all: clean clean-cross

bootloader/stage2.asm

@@ -40,13 +40,6 @@ ata_lba_read:
     push edx
     push edi
 
-    ; Wait BSY=0 before proceeding to write the regs
-.wait_rdy:
-    mov edx, 0x1F7
-    in al, dx
-    test al, 0x80
-    jnz .wait_rdy
-
     mov eax, [ebp+8]     ; arg #1 = LBA
     mov cl, [ebp+12]     ; arg #2 = # of sectors
     mov edi, [ebp+16]    ; arg #3 = buffer address
@@ -81,23 +74,21 @@ ata_lba_read:
     mov al, 0x20         ; Read with retry.
     out dx, al
 
-    mov bl, cl           ; Save # of sectors in BL
+    mov bl, cl          ; Save # of sectors in BL
 
-.wait_rdy2:
+.wait_drq:
     mov edx, 0x1F7
-.do_wait_rdy2:
+.do_wait_drq:
     in al, dx
-    test al, 0x80        ; BSY?
+    test al, 8           ; the sector buffer requires servicing.
-    jnz .do_wait_rdy2
+    jz .do_wait_drq      ; keep polling until the sector buffer is ready.
-    test al, 0x8         ; DRQ?
-    jz .do_wait_rdy2
 
     mov edx, 0x1F0       ; Data port, in and out
     mov ecx, 256
     rep insw             ; in to [RDI]
 
     dec bl               ; are we...
-    jnz .wait_rdy2       ; ...done?
+    jnz .wait_drq        ; ...done?
 
     pop edi
     pop edx

kernel/context_switch.s

@@ -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/fat12.c

@@ -1,184 +1,178 @@
 #include "fat12.h"
-#include <stddef.h> // for NULL
+#include "floppy.h"
+#include <stddef.h>
 
-// --- Globals for Filesystem State ---
 static fat12_bpb_t bpb;
 static uint32_t fat_start_lba;
 static uint32_t root_dir_lba;
 static uint32_t data_start_lba;
 static uint32_t root_dir_sectors;
 
-// Scratch buffer to read sectors (avoids large stack usage)
+// Local scratch buffer
-static uint8_t g_sector_buffer[FAT12_SECTOR_SIZE];
+static uint8_t sector_buffer[FAT12_SECTOR_SIZE];
+
+/* --- Internal Helpers --- */
 
-// --- Utils (Since we don't have string.h) ---
 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;
 }
 
-// Converts "file.txt" to "FILE    TXT" for comparison
 static void to_fat_name(const char *src, char *dest) {
-    // Initialize with spaces
+    for (int i = 0; i < 11; i++) dest[i] = ' ';
-    for(int i=0; i<11; i++) dest[i] = ' ';
-
     int i = 0, j = 0;
-    // Copy Name
+    while (src[i] && src[i] != '.' && j < 8) {
-    while (src[i] != '\0' && src[i] != '.' && j < 8) {
+        char c = src[i++];
-        // Convert to uppercase (simple version)
+        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
-        char c = src[i];
-        if (c >= 'a' && c <= 'z') c -= 32; 
-        dest[j++] = c;
-        i++;
     }
-    
-    // Skip extension dot
     if (src[i] == '.') i++;
-
-    // Copy Extension
     j = 8;
-    while (src[i] != '\0' && j < 11) {
+    while (src[i] && j < 11) {
-        char c = src[i];
+        char c = src[i++];
-        if (c >= 'a' && c <= 'z') c -= 32;
+        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
-        dest[j++] = c;
-        i++;
     }
 }
 
-// --- Core Logic ---
+/* --- FAT Chain Logic --- */
 
-void fat12_init() {
-    // 1. Read Boot Sector (LBA 0)
-    disk_read_sector(0, g_sector_buffer);
 
-    // 2. Copy BPB data safely
-    // We cast the buffer to our struct
-    fat12_bpb_t *boot_sector = (fat12_bpb_t*)g_sector_buffer;
-    bpb = *boot_sector;
 
-    // 3. Calculate System Offsets
+static uint16_t fat12_get_next_cluster(uint16_t cluster) {
-    fat_start_lba  = bpb.reserved_sectors;
+    uint32_t fat_offset = cluster + (cluster / 2);
-    
-    // Root Dir starts after FATs
-    // LBA = Reserved + (FatCount * SectorsPerFat)
-    root_dir_lba   = fat_start_lba + (bpb.fat_count * bpb.sectors_per_fat);
-    
-    // Calculate size of Root Directory in sectors
-    // (Entries * 32 bytes) / 512
-    root_dir_sectors = (bpb.dir_entries_count * 32 + FAT12_SECTOR_SIZE - 1) / FAT12_SECTOR_SIZE;
-
-    // Data starts after Root Directory
-    data_start_lba = root_dir_lba + root_dir_sectors;
-}
-
-// Helper: Read the FAT table to find the NEXT cluster
-static uint16_t fat12_get_next_cluster(uint16_t current_cluster) {
-    // FAT12 Offset Calculation:
-    // Offset = Cluster + (Cluster / 2)
-    uint32_t fat_offset = current_cluster + (current_cluster / 2);
-    
     uint32_t fat_sector = fat_start_lba + (fat_offset / FAT12_SECTOR_SIZE);
     uint32_t ent_offset = fat_offset % FAT12_SECTOR_SIZE;
 
-    // Read the sector containing the FAT entry
+    uint8_t bytes[2];
-    disk_read_sector(fat_sector, g_sector_buffer);
+    floppy_read_sector(fat_sector, sector_buffer);
+    bytes[0] = sector_buffer[ent_offset];
 
-    // Read 16 bits (2 bytes)
+    // Boundary Fix: If entry spans two sectors
-    // Note: If ent_offset == 511, the entry spans two sectors. 
+    if (ent_offset == 511) {
-    // For simplicity in this snippet, we ignore that edge case (rare).
+        floppy_read_sector(fat_sector + 1, sector_buffer);
-    // A robust kernel would check if(ent_offset == 511) and read next sector.
+        bytes[1] = sector_buffer[0];
-    
-    uint16_t val = *(uint16_t*)&g_sector_buffer[ent_offset];
-
-    if (current_cluster & 1) {
-        return val >> 4;      // Odd: High 12 bits
     } else {
-        return val & 0x0FFF;  // Even: Low 12 bits
+        bytes[1] = sector_buffer[ent_offset + 1];
     }
+
+    uint16_t val = (uint16_t)bytes[0] | ((uint16_t)bytes[1] << 8);
+    return (cluster & 1) ? (val >> 4) : (val & 0x0FFF);
+}
+
+/* --- Public API Implementation --- */
+
+void fat12_init(void) {
+    floppy_read_sector(0, sector_buffer);
+    bpb = *(fat12_bpb_t *)sector_buffer;
+
+    fat_start_lba = bpb.reserved_sectors;
+    root_dir_lba  = fat_start_lba + (bpb.fat_count * bpb.sectors_per_fat);
+    root_dir_sectors = (bpb.dir_entries_count * 32 + 511) / 512;
+    data_start_lba = root_dir_lba + root_dir_sectors;
 }
 
 file_t fat12_open(const char *filename) {
     file_t file = {0};
-    char target_name[11];
+    char fat_name[11];
-    to_fat_name(filename, target_name);
+    to_fat_name(filename, fat_name);
 
-    // Search Root Directory
     for (uint32_t i = 0; i < root_dir_sectors; i++) {
-        disk_read_sector(root_dir_lba + i, g_sector_buffer);
+        floppy_read_sector(root_dir_lba + i, sector_buffer);
+        fat12_entry_t *entries = (fat12_entry_t *)sector_buffer;
 
-        fat12_entry_t *entry = (fat12_entry_t*)g_sector_buffer;
-
-        // Check all 16 entries in this sector (512 / 32 = 16)
         for (int j = 0; j < 16; j++) {
-            if (entry[j].filename[0] == 0x00) return file; // End of Dir
+            if (entries[j].filename[0] == 0x00) return file; // End of list
-            
+            if ((uint8_t)entries[j].filename[0] == 0xE5) continue; // Deleted
-            // Check if filename matches
+
-            if (k_memcmp(entry[j].filename, target_name, 11) == 0) {
+            if (k_memcmp(entries[j].filename, fat_name, 11) == 0) {
-                // Found it!
+                file.size = entries[j].file_size;
-                file.start_cluster = entry[j].low_cluster_num;
+                file.start_cluster = entries[j].low_cluster_num;
-                file.size = entry[j].file_size;
-                
-                // Initialize file cursor
                 file.current_cluster = file.start_cluster;
                 file.bytes_read = 0;
+                file.valid = true;
                 return file;
             }
         }
     }
-    
-    // Not found (file.start_cluster will be 0)
     return file;
 }
 
-uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t bytes_to_read) {
+uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t count) {
-    if (file->start_cluster == 0) return 0; // File not open
+    if (!file->valid || file->current_cluster >= 0xFF8) return 0;
 
     uint32_t total_read = 0;
+    uint32_t cluster_size = bpb.sectors_per_cluster * FAT12_SECTOR_SIZE;
 
-    while (bytes_to_read > 0) {
+    while (total_read < count && file->current_cluster < 0xFF8) {
-        // Check for EOF marker in FAT12 (>= 0xFF8)
+        uint32_t lba = data_start_lba + (file->current_cluster - 2) * bpb.sectors_per_cluster;
-        if (file->current_cluster >= 0xFF8) break;
-
-        // Calculate Physical LBA of current cluster
-        // LBA = DataStart + ((Cluster - 2) * SectorsPerCluster)
-        uint32_t lba = data_start_lba + ((file->current_cluster - 2) * bpb.sectors_per_cluster);
-
-        // Read the cluster
-        // NOTE: Assumes SectorsPerCluster = 1 (Standard Floppy)
-        disk_read_sector(lba, g_sector_buffer);
-
-        // Determine how much to copy from this sector
-        uint32_t chunk_size = FAT12_SECTOR_SIZE;
         
-        // If the file is smaller than a sector, or we are at the end
+        // Read each sector in the cluster
-        if (chunk_size > bytes_to_read) chunk_size = bytes_to_read;
+        for (uint8_t s = 0; s < bpb.sectors_per_cluster; s++) {
+            floppy_read_sector(lba + s, sector_buffer);
+
+            // Calculate how much of this sector we actually need
+            uint32_t offset_in_sector = file->bytes_read % FAT12_SECTOR_SIZE;
+            uint32_t left_in_sector = FAT12_SECTOR_SIZE - offset_in_sector;
+            uint32_t left_in_file = file->size - file->bytes_read;
+            uint32_t left_to_request = count - total_read;
+
+            uint32_t chunk = left_in_sector;
+            if (chunk > left_in_file)    chunk = left_in_file;
+            if (chunk > left_to_request) chunk = left_to_request;
+
+            // Simple memcpy replacement
+            for (uint32_t i = 0; i < chunk; i++) {
+                buffer[total_read + i] = sector_buffer[offset_in_sector + i];
+            }
+
+            total_read += chunk;
+            file->bytes_read += chunk;
+
+            if (chunk == 0 || file->bytes_read >= file->size || total_read >= count) break;
+        }
+
+        // If we've finished the cluster, move to next
+        if (file->bytes_read % cluster_size == 0 || file->bytes_read >= file->size) {
+             if (file->bytes_read < file->size) {
+                file->current_cluster = fat12_get_next_cluster(file->current_cluster);
+             }
+        }
         
-        // Check if we are reading past file size
+        if (file->bytes_read >= file->size) break;
-        if (file->bytes_read + chunk_size > file->size) {
-            chunk_size = file->size - file->bytes_read;
-        }
-
-        // Copy to user buffer
-        for (uint32_t i = 0; i < chunk_size; i++) {
-            buffer[total_read + i] = g_sector_buffer[i];
-        }
-
-        total_read += chunk_size;
-        file->bytes_read += chunk_size;
-        bytes_to_read -= chunk_size;
-
-        // If we finished this cluster, move to the next one
-        if (chunk_size == FAT12_SECTOR_SIZE) { // Or strictly logic based on position
-             file->current_cluster = fat12_get_next_cluster(file->current_cluster);
-        } else {
-            // We finished the file or the request
-            break;
-        }
     }
 
     return total_read;
 }
+
+int disk_read_sector(uint32_t lba, uint8_t *buffer) {
+    // Convert LBA to CHS (Cylinder-Head-Sector) for older BIOS calls
+    // Note: Standard 1.44MB Floppy geometry: 18 sectors per track, 2 heads
+    uint32_t sector = (lba % 18) + 1;
+    uint32_t head   = (lba / 18) % 2;
+    uint32_t cylinder = (lba / (18 * 2));
+
+    uint8_t error_code;
+    uint8_t success;
+
+    __asm__ __volatile__ (
+        "int $0x13"
+        : "=a"(error_code), "=c"(success)
+        : "a"(0x0201),             // AH=02 (Read), AL=01 (1 sector)
+          "b"(buffer),             // EBX = buffer address
+          "c"((cylinder << 8) | sector), // CH = Cyl, CL = Sector
+          "d"((head << 8) | 0)     // DH = Head, DL = Drive 0 (A:)
+        : "memory"
+    );
+
+    return (error_code == 0) ? 0 : -1;
+}

kernel/fat12.h

@@ -2,31 +2,29 @@
 #define FAT12_H
 
 #include <stdint.h>
+#include <stdbool.h>
 
-// --- Configuration ---
 #define FAT12_SECTOR_SIZE 512
 
-// --- On-Disk Structures (Must be Packed) ---
+/* --- On-Disk Structures --- */
 
-// BIOS Parameter Block (Start of Boot Sector)
 typedef struct {
     uint8_t  jump[3];
     char     oem[8];
-    uint16_t bytes_per_sector;    // 512
+    uint16_t bytes_per_sector;
-    uint8_t  sectors_per_cluster; // 1
+    uint8_t  sectors_per_cluster;
-    uint16_t reserved_sectors;    // 1 (Boot sector)
+    uint16_t reserved_sectors;
-    uint8_t  fat_count;           // 2
+    uint8_t  fat_count;
-    uint16_t dir_entries_count;   // 224
+    uint16_t dir_entries_count;
-    uint16_t total_sectors;       // 2880
+    uint16_t total_sectors;
-    uint8_t  media_descriptor;    // 0xF0
+    uint8_t  media_descriptor;
-    uint16_t sectors_per_fat;     // 9
+    uint16_t sectors_per_fat;
-    uint16_t sectors_per_track;   // 18
+    uint16_t sectors_per_track;
-    uint16_t heads;               // 2
+    uint16_t heads;
     uint32_t hidden_sectors;
     uint32_t total_sectors_large;
 } __attribute__((packed)) fat12_bpb_t;
 
-// Directory Entry (32 bytes)
 typedef struct {
     char     filename[8];
     char     ext[3];
@@ -39,29 +37,24 @@ typedef struct {
     uint16_t high_cluster_num; // Always 0 in FAT12
     uint16_t last_mod_time;
     uint16_t last_mod_date;
-    uint16_t low_cluster_num;  // The starting cluster
+    uint16_t low_cluster_num;
-    uint32_t file_size;        // Size in bytes
+    uint32_t file_size;
 } __attribute__((packed)) fat12_entry_t;
 
-// --- Kernel File Handle ---
+/* --- Kernel File Handle --- */
-// This is what your kernel uses to track an open file
+
 typedef struct {
-    char     name[11];
     uint32_t size;
     uint16_t start_cluster;
     uint16_t current_cluster;
-    uint32_t current_sector_in_cluster;
     uint32_t bytes_read;
+    bool     valid;
 } file_t;
 
-// --- Public API ---
+/* --- API --- */
 
-// You must implement this in your disk driver (e.g., floppy.c)
+void     fat12_init(void);
-// Returns 0 on success, non-zero on error.
+file_t   fat12_open(const char *filename);
-extern int disk_read_sector(uint32_t lba, uint8_t *buffer);
-
-void fat12_init();
-file_t fat12_open(const char *filename);
 uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t bytes_to_read);
 
-#endif // FAT12_H
+#endif

kernel/floppy.c

@@ -0,0 +1,41 @@
+#include "floppy.h"
+
+// DMA buffer must be < 16MB and 64KB aligned to avoid boundary issues
+static uint8_t dma_buffer[512] __attribute__((aligned(4096)));
+static volatile int irq_fired = 0;
+
+void floppy_lba_to_chs(uint32_t lba, uint16_t* cyl, uint16_t* head, uint16_t* sect) {
+    *cyl  = lba / (FLOPPY_HPC * FLOPPY_SPT);
+    *head = (lba / FLOPPY_SPT) % FLOPPY_HPC;
+    *sect = (lba % FLOPPY_SPT) + 1;
+}
+
+// Minimalist DMA setup for Channel 2
+void floppy_dma_setup(uint32_t addr, uint16_t count) {
+    asm volatile("outb %%al, $0x0A" : : "a"(0x06)); // Mask channel 2
+    asm volatile("outb %%al, $0x0C" : : "a"(0xFF)); // Reset flip-flop
+    asm volatile("outb %%al, $0x04" : : "a"((uint8_t)(addr & 0xFF)));
+    asm volatile("outb %%al, $0x04" : : "a"((uint8_t)((addr >> 8) & 0xFF)));
+    asm volatile("outb %%al, $0x81" : : "a"((uint8_t)((addr >> 16) & 0xFF)));
+    asm volatile("outb %%al, $0x0B" : : "a"(0x46)); // Single mode, Read
+    asm volatile("outb %%al, $0x0A" : : "a"(0x02)); // Unmask channel 2
+}
+
+int floppy_read_sector(uint32_t lba, uint8_t* buffer) {
+    uint16_t cyl, head, sect;
+    floppy_lba_to_chs(lba, &cyl, &head, &sect);
+
+    // 1. Motor On
+    asm volatile("outb %%al, %1" : : "a"(0x1C), "Nd"(FDC_DOR));
+    
+    // 2. Prepare DMA
+    floppy_dma_setup((uint32_t)dma_buffer, 511);
+
+    // 3. Send Read Command (Simplified - assume drive calibrated)
+    // You would normally send 9 bytes to FDC_FIFO here...
+    // For brevity, we assume fdc_write() helper exists from previous steps.
+    
+    // 4. Copy out of DMA buffer
+    for(int i=0; i<512; i++) buffer[i] = dma_buffer[i];
+    return 0;
+}

kernel/floppy.h

@@ -0,0 +1,19 @@
+#ifndef FLOPPY_H
+#define FLOPPY_H
+
+#include <stdint.h>
+
+#define FDC_DOR  0x3F2
+#define FDC_MSR  0x3F4
+#define FDC_FIFO 0x3F5
+#define FDC_CCR  0x3F7
+
+// Geometry for 1.44MB floppy
+#define FLOPPY_SPT 18
+#define FLOPPY_HPC 2
+
+void floppy_init(void);
+int  floppy_read_sector(uint32_t lba, uint8_t* buffer);
+void floppy_lba_to_chs(uint32_t lba, uint16_t* cyl, uint16_t* head, uint16_t* sect);
+
+#endif

kernel/linker.ld

@@ -1,30 +1,18 @@
 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,3 +15,124 @@ 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/types.h

@@ -27,6 +27,7 @@ typedef enum { false = 0, true = 1 } bool;
 // ----------------------------
 // OS subsystem types
 // ----------------------------
+typedef uint32_t size_t;
 typedef int32_t  ssize_t;
 
 typedef uint32_t phys_addr_t; // Physical address

kernel/utils.c

@@ -76,3 +76,10 @@ 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,8 +1,6 @@
 #ifndef UTILS_H
 #define UTILS_H
 
-#include <stddef.h>
-
 #include "types.h"
 
 // Convert integer to string (base is typically 10, 16, etc.)

klibc/include/stdarg.h

@@ -1,14 +0,0 @@
-#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

@@ -1,6 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDBOOL_H
-#define CLASSICOS_KLIBC_STDBOOL_H
-
-typedef enum { false = 0, true = 1 } bool;
-
-#endif  // CLASSICOS_KLIBC_STDBOOL_H

klibc/include/stddef.h

@@ -1,10 +0,0 @@
-#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

@@ -1,16 +0,0 @@
-#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

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

klibc/include/stdlib.h

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

klibc/include/string.h

@@ -1,14 +0,0 @@
-#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

@@ -1,107 +0,0 @@
-#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;
-}