Merge pull request #84 from shoshta73/RWXPerms

[fix] LOAD segment with RWX permissions

.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,6 +15,9 @@ 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
@@ -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,7 @@ $(DISK_IMG): stage1 stage2 kernel
 
 $(BUILD_DIR):
 	mkdir -p $@
+	mkdir -p $(BUILD_DIR)/klibc
 
 run:
 	qemu-system-i386 -s -S $(DISK_IMG)
@@ -57,4 +65,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

@@ -40,6 +40,13 @@ 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
@@ -76,19 +83,21 @@ ata_lba_read:
 
     mov bl, cl           ; Save # of sectors in BL
 
-.wait_drq:
+.wait_rdy2:
     mov edx, 0x1F7
-.do_wait_drq:
+.do_wait_rdy2:
     in al, dx
-    test al, 8           ; the sector buffer requires servicing.
-    jz .do_wait_drq      ; keep polling until the sector buffer is ready.
+    test al, 0x80        ; BSY?
+    jnz .do_wait_rdy2
+    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_drq        ; ...done?
+    jnz .wait_rdy2       ; ...done?
 
     pop edi
     pop edx

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

@@ -1,178 +1,184 @@
 #include "fat12.h"
-#include "floppy.h"
-#include <stddef.h>
+#include <stddef.h> // for NULL
 
+// --- 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;
 
-// Local scratch buffer
-static uint8_t sector_buffer[FAT12_SECTOR_SIZE];
-
-/* --- Internal Helpers --- */
+// Scratch buffer to read sectors (avoids large stack usage)
+static uint8_t g_sector_buffer[FAT12_SECTOR_SIZE];
 
+// --- 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]) {
-            // 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];
+        if (p1[i] != p2[i]) return p1[i] - 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] = ' ';
+
     int i = 0, j = 0;
-    while (src[i] && src[i] != '.' && j < 8) {
-        char c = src[i++];
-        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
+    // Copy Name
+    while (src[i] != '\0' && src[i] != '.' && j < 8) {
+        // Convert to uppercase (simple version)
+        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] && j < 11) {
-        char c = src[i++];
-        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
+    while (src[i] != '\0' && j < 11) {
+        char c = src[i];
+        if (c >= 'a' && c <= 'z') c -= 32;
+        dest[j++] = c;
+        i++;
     }
 }
 
-/* --- FAT Chain Logic --- */
+// --- Core 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
+    fat_start_lba  = bpb.reserved_sectors;
+    
+    // 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);
     
-static uint16_t fat12_get_next_cluster(uint16_t cluster) {
-    uint32_t fat_offset = cluster + (cluster / 2);
     uint32_t fat_sector = fat_start_lba + (fat_offset / FAT12_SECTOR_SIZE);
     uint32_t ent_offset = fat_offset % FAT12_SECTOR_SIZE;
 
-    uint8_t bytes[2];
-    floppy_read_sector(fat_sector, sector_buffer);
-    bytes[0] = sector_buffer[ent_offset];
+    // Read the sector containing the FAT entry
+    disk_read_sector(fat_sector, g_sector_buffer);
 
-    // Boundary Fix: If entry spans two sectors
-    if (ent_offset == 511) {
-        floppy_read_sector(fat_sector + 1, sector_buffer);
-        bytes[1] = sector_buffer[0];
+    // Read 16 bits (2 bytes)
+    // Note: If ent_offset == 511, the entry spans two sectors. 
+    // For simplicity in this snippet, we ignore that edge case (rare).
+    // A robust kernel would check if(ent_offset == 511) and read next sector.
+    
+    uint16_t val = *(uint16_t*)&g_sector_buffer[ent_offset];
+
+    if (current_cluster & 1) {
+        return val >> 4;      // Odd: High 12 bits
     } else {
-        bytes[1] = sector_buffer[ent_offset + 1];
+        return val & 0x0FFF;  // Even: Low 12 bits
     }
-
-    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 fat_name[11];
-    to_fat_name(filename, fat_name);
+    char target_name[11];
+    to_fat_name(filename, target_name);
 
+    // Search Root Directory
     for (uint32_t i = 0; i < root_dir_sectors; i++) {
-        floppy_read_sector(root_dir_lba + i, sector_buffer);
-        fat12_entry_t *entries = (fat12_entry_t *)sector_buffer;
+        disk_read_sector(root_dir_lba + i, g_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 (entries[j].filename[0] == 0x00) return file; // End of list
-            if ((uint8_t)entries[j].filename[0] == 0xE5) continue; // Deleted
+            if (entry[j].filename[0] == 0x00) return file; // End of Dir
             
-            if (k_memcmp(entries[j].filename, fat_name, 11) == 0) {
-                file.size = entries[j].file_size;
-                file.start_cluster = entries[j].low_cluster_num;
+            // Check if filename matches
+            if (k_memcmp(entry[j].filename, target_name, 11) == 0) {
+                // Found it!
+                file.start_cluster = entry[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 count) {
-    if (!file->valid || file->current_cluster >= 0xFF8) return 0;
+uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t bytes_to_read) {
+    if (file->start_cluster == 0) return 0; // File not open
 
     uint32_t total_read = 0;
-    uint32_t cluster_size = bpb.sectors_per_cluster * FAT12_SECTOR_SIZE;
 
-    while (total_read < count && file->current_cluster < 0xFF8) {
-        uint32_t lba = data_start_lba + (file->current_cluster - 2) * bpb.sectors_per_cluster;
+    while (bytes_to_read > 0) {
+        // Check for EOF marker in FAT12 (>= 0xFF8)
+        if (file->current_cluster >= 0xFF8) break;
 
-        // Read each sector in the cluster
-        for (uint8_t s = 0; s < bpb.sectors_per_cluster; s++) {
-            floppy_read_sector(lba + s, sector_buffer);
+        // 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);
 
-            // 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;
+        // Read the cluster
+        // NOTE: Assumes SectorsPerCluster = 1 (Standard Floppy)
+        disk_read_sector(lba, g_sector_buffer);
 
-            uint32_t chunk = left_in_sector;
-            if (chunk > left_in_file)    chunk = left_in_file;
-            if (chunk > left_to_request) chunk = left_to_request;
+        // Determine how much to copy from this sector
+        uint32_t chunk_size = FAT12_SECTOR_SIZE;
         
-            // Simple memcpy replacement
-            for (uint32_t i = 0; i < chunk; i++) {
-                buffer[total_read + i] = sector_buffer[offset_in_sector + i];
+        // If the file is smaller than a sector, or we are at the end
+        if (chunk_size > bytes_to_read) chunk_size = bytes_to_read;
+        
+        // Check if we are reading past file size
+        if (file->bytes_read + chunk_size > file->size) {
+            chunk_size = file->size - file->bytes_read;
         }
 
-            total_read += chunk;
-            file->bytes_read += chunk;
-
-            if (chunk == 0 || file->bytes_read >= file->size || total_read >= count) break;
+        // Copy to user buffer
+        for (uint32_t i = 0; i < chunk_size; i++) {
+            buffer[total_read + i] = g_sector_buffer[i];
         }
 
-        // 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) {
+        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;
         }
     }
 
-        if (file->bytes_read >= file->size) 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,29 +2,31 @@
 #define FAT12_H
 
 #include <stdint.h>
-#include <stdbool.h>
 
+// --- Configuration ---
 #define FAT12_SECTOR_SIZE 512
 
-/* --- On-Disk Structures --- */
+// --- On-Disk Structures (Must be Packed) ---
 
+// BIOS Parameter Block (Start of Boot Sector)
 typedef struct {
     uint8_t  jump[3];
     char     oem[8];
-    uint16_t bytes_per_sector;
-    uint8_t  sectors_per_cluster;
-    uint16_t reserved_sectors;
-    uint8_t  fat_count;
-    uint16_t dir_entries_count;
-    uint16_t total_sectors;
-    uint8_t  media_descriptor;
-    uint16_t sectors_per_fat;
-    uint16_t sectors_per_track;
-    uint16_t heads;
+    uint16_t bytes_per_sector;    // 512
+    uint8_t  sectors_per_cluster; // 1
+    uint16_t reserved_sectors;    // 1 (Boot sector)
+    uint8_t  fat_count;           // 2
+    uint16_t dir_entries_count;   // 224
+    uint16_t total_sectors;       // 2880
+    uint8_t  media_descriptor;    // 0xF0
+    uint16_t sectors_per_fat;     // 9
+    uint16_t sectors_per_track;   // 18
+    uint16_t heads;               // 2
     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];
@@ -37,24 +39,29 @@ 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;
-    uint32_t file_size;
+    uint16_t low_cluster_num;  // The starting cluster
+    uint32_t file_size;        // Size in bytes
 } __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;
 
-/* --- API --- */
+// --- Public API ---
 
-void     fat12_init(void);
+// 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);
+
+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
+#endif // FAT12_H

kernel/floppy.c

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

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

@@ -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/types.h

@@ -27,7 +27,6 @@ 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,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,6 +1,8 @@
 #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

@@ -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,6 @@
+#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

@@ -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;
+}