Merge pull request #84 from shoshta73/RWXPerms

[fix] LOAD segment with RWX permissions

.gitignore

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

Makefile

@@ -1,10 +1,12 @@
 AS = nasm
 ASFLAGS = -f elf32 -g -F dwarf
-CC = gcc
-LD = ld
+CC = i386-elf-gcc
+LD = i386-elf-ld
 QEMU= qemu-system-i386
+OBJCOPY = i386-elf-objcopy
 
 BUILD_DIR = build
+CROSS_DIR = cross
 DISK_IMG = $(BUILD_DIR)/disk.img
 STAGE2_SIZE = 2048
 
@@ -13,31 +15,37 @@ 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
 stage1: $(BUILD_DIR)
 	$(AS) $(ASFLAGS) -o $(BUILD_DIR)/$@.o bootloader/$@.asm
 	$(LD) -Ttext=0x7c00 -melf_i386 -o $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.o
-	objcopy -O binary $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.bin
+	$(OBJCOPY) -O binary $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.bin
 
 # NOTE: Stage2 final size should be checked against `$(STAGE2_SIZE)` by the build system to avoid an overflow.
 # 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
+	$(OBJCOPY) -O binary $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.bin
 	truncate -s $(STAGE2_SIZE) $(BUILD_DIR)/$@.bin
 
 $(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=$@
@@ -47,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)
@@ -56,3 +65,9 @@ gdb:
 
 clean:
 	rm -rf $(BUILD_DIR)
+
+clean-cross:
+	rm -rf $(CROSS_DIR)
+	rm -rf .build.env
+
+clean-all: clean clean-cross

README.md

@@ -35,6 +35,7 @@ You’ll need the following tools installed:
 - `qemu-system-i386`
 
 Optional:
+
 - `gdb`
 - `vncviewer` (TigerVNC or similar)
 
@@ -42,13 +43,27 @@ Optional:
 
 ## 🛠️ Building ClassicOS
 
-Clone and build:
+Clone repository:
 
-```bash
+```sh
 git clone https://github.com/gbowne1/ClassicOS.git
 cd ClassicOS
-make
 ```
 
-build kernel
-for %f in (*.c) do gcc -m32 -O0 -Wall -Wextra -Werror -pedantic -ffreestanding -nostdlib -fno-pic -fno-stack-protector -fno-pie -march=i386 -mtune=i386 -c "%f" -o "%f.o"
+Run `configure` script to build a cross-compiler toolchain for `i386-elf`:
+
+```sh
+./configure
+```
+
+Source the `.build.env` file to add the cross-compiler toolchain to your PATH:
+
+```sh
+source .build.env
+```
+
+Build the kernel:
+
+```sh
+make
+```

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

configure

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Configuration
+TARGET="i386-elf"
+BINUTILS_VERSION="2.45"
+GCC_VERSION="15.2.0"
+
+# Paths
+SCRIPT_PATH="$(realpath "${BASH_SOURCE[0]}")"
+SCRIPT_DIR="$(dirname "$SCRIPT_PATH")"
+PREFIX="$SCRIPT_DIR/cross"
+SRC_DIR="$PREFIX/src"
+
+BINUTILS_SRC="$SRC_DIR/binutils-$BINUTILS_VERSION"
+BINUTILS_BUILD="$PREFIX/build-binutils"
+GCC_SRC="$SRC_DIR/gcc-$GCC_VERSION"
+GCC_BUILD="$PREFIX/build-gcc"
+
+# Flags
+DEBUG=0
+HELP=0
+
+# Parse arguments
+for arg in "$@"; do
+  case "$arg" in
+    -h|--help)
+      HELP=1
+      ;;
+    -d|--debug)
+      DEBUG=1
+      ;;
+    *)
+      echo "Unknown option: $arg"
+      echo "Use -h or --help for usage information"
+      exit 1
+      ;;
+  esac
+done
+
+# Show help
+if [[ "$HELP" -eq 1 ]]; then
+  cat << EOF
+Usage: $0 [OPTIONS]
+
+Build a cross-compiler toolchain for $TARGET.
+
+OPTIONS:
+  -h, --help     Show this help message
+  -d, --debug    Enable debug mode (set -x)
+
+This script will:
+  1. Download binutils $BINUTILS_VERSION and GCC $GCC_VERSION
+  2. Build and install them to: $PREFIX
+
+EOF
+  exit 0
+fi
+
+# Enable debug mode
+if [[ "$DEBUG" -eq 1 ]]; then
+  set -x
+fi
+
+# Print configuration
+cat << EOF
+
+=== Build Configuration ===
+Target       : $TARGET
+Prefix       : $PREFIX
+Binutils     : $BINUTILS_VERSION
+GCC          : $GCC_VERSION
+===========================
+
+EOF
+
+# Create directory structure
+echo "Setting up directories..."
+mkdir -p "$SRC_DIR"
+
+# Download sources
+cd "$SRC_DIR"
+
+if [[ ! -d "$BINUTILS_SRC" ]]; then
+  echo "Downloading binutils $BINUTILS_VERSION..."
+  wget "https://ftp.gnu.org/gnu/binutils/binutils-$BINUTILS_VERSION.tar.gz"
+  echo "Extracting binutils..."
+  tar xf "binutils-$BINUTILS_VERSION.tar.gz"
+  rm "binutils-$BINUTILS_VERSION.tar.gz"
+else
+  echo "Binutils source already exists, skipping download"
+fi
+
+if [[ ! -d "$GCC_SRC" ]]; then
+  echo "Downloading GCC $GCC_VERSION..."
+  wget "https://ftp.gnu.org/gnu/gcc/gcc-$GCC_VERSION/gcc-$GCC_VERSION.tar.gz"
+  echo "Extracting GCC..."
+  tar xf "gcc-$GCC_VERSION.tar.gz"
+  rm "gcc-$GCC_VERSION.tar.gz"
+else
+  echo "GCC source already exists, skipping download"
+fi
+
+# Download GCC prerequisites
+if [[ ! -d "$GCC_SRC/gmp" ]]; then
+  echo "Downloading GCC prerequisites..."
+  cd "$GCC_SRC"
+  ./contrib/download_prerequisites
+  cd "$SRC_DIR"
+else
+  echo "GCC prerequisites already downloaded, skipping"
+fi
+
+# Build binutils
+if [[ ! -f "$PREFIX/bin/$TARGET-ld" ]]; then
+  echo "Building binutils..."
+  mkdir -p "$BINUTILS_BUILD"
+  cd "$BINUTILS_BUILD"
+
+  "$BINUTILS_SRC/configure" \
+    --target="$TARGET" \
+    --prefix="$PREFIX" \
+    --with-sysroot \
+    --disable-nls \
+    --disable-werror
+
+  make -j"$(nproc)"
+  make install
+else
+  echo "Binutils already installed, skipping build"
+fi
+
+# Build GCC
+if [[ ! -f "$PREFIX/bin/$TARGET-gcc" ]]; then
+  echo "Building GCC..."
+  mkdir -p "$GCC_BUILD"
+  cd "$GCC_BUILD"
+
+  "$GCC_SRC/configure" \
+    --target="$TARGET" \
+    --prefix="$PREFIX" \
+    --disable-nls \
+    --enable-languages=c \
+    --without-headers
+
+  make all-gcc -j"$(nproc)"
+  make all-target-libgcc -j"$(nproc)"
+  make install-gcc
+  make install-target-libgcc
+else
+  echo "GCC already installed, skipping build"
+fi
+
+cd "$SCRIPT_DIR"
+
+# Generate .build.env file
+cat > .build.env << EOF
+# Generated by configure on $(date)
+# Source this file to add the cross-compiler toolchain to your PATH
+export PATH="$PREFIX/bin:\$PATH"
+EOF
+
+echo ""
+echo "=== Build Complete ==="
+echo "Toolchain installed to: $PREFIX"
+echo ""
+echo "To use the toolchain, run:"
+echo "  source .build.env"
+echo "======================"

kernel/context_switch.asm

@@ -0,0 +1,25 @@
+global ctx_switch
+
+; void ctx_switch(uint32_t **old_sp_ptr, uint32_t *new_sp);
+; Arguments on stack (cdecl convention):
+; [ESP + 4] -> old_sp_ptr (pointer to the 'stack_ptr' field of current task)
+; [ESP + 8] -> new_sp     (value of 'stack_ptr' of the next task)
+
+ctx_switch:
+    ; 1. Save the context of the CURRENT task
+    pushf               ; Save EFLAGS (CPU status flags)
+    pusha               ; Save all General Purpose Regs (EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI)
+
+    ; 2. Save the current stack pointer (ESP) into the pointer passed as 1st arg
+    mov eax, [esp + 40] ; Get 1st argument (old_sp_ptr). Offset 40 = 36 (regs) + 4 (ret addr)
+    mov [eax], esp      ; *old_sp_ptr = ESP
+
+    ; 3. Load the stack pointer of the NEW task
+    mov esp, [esp + 44] ; Get 2nd argument (new_sp). Offset 44 = 40 + 4
+
+    ; 4. Restore the context of the NEW task
+    popa                ; Restore all General Purpose Regs
+    popf                ; Restore EFLAGS
+
+    ; 5. Jump to the new task (The 'ret' pops EIP from the new stack)
+    ret

kernel/fat12.c

@@ -1,5 +1,184 @@
 #include "fat12.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;
+
+// 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]) 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;
+    // 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] != '\0' && j < 11) {
+        char c = src[i];
+        if (c >= 'a' && c <= 'z') c -= 32;
+        dest[j++] = c;
+        i++;
+    }
+}
+
+// --- Core Logic ---
 
 void fat12_init() {
-    // Filesystem initialization code
+    // 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);
+    
+    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
+    disk_read_sector(fat_sector, g_sector_buffer);
+
+    // 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 {
+        return val & 0x0FFF;  // Even: Low 12 bits
+    }
+}
+
+file_t fat12_open(const char *filename) {
+    file_t file = {0};
+    char target_name[11];
+    to_fat_name(filename, target_name);
+
+    // Search Root Directory
+    for (uint32_t i = 0; i < root_dir_sectors; i++) {
+        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 (entry[j].filename[0] == 0x00) return file; // End of Dir
+            
+            // 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;
+                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) {
+    if (file->start_cluster == 0) return 0; // File not open
+
+    uint32_t total_read = 0;
+
+    while (bytes_to_read > 0) {
+        // Check for EOF marker in FAT12 (>= 0xFF8)
+        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
+        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;
+        }
+
+        // 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;
 }

kernel/fat12.h

@@ -1,47 +1,67 @@
 #ifndef FAT12_H
 #define FAT12_H
 
-#include <stdint.h> /* Include standard integer types */
-#include <stdio.h>  /* Include standard I/O library */
-#include <stdlib.h> /* Include standard library */
+#include <stdint.h>
 
-#define FAT12_SECTOR_SIZE 512 /* Sector size for FAT12 */
-#define FAT12_MAX_FILES 128 /* Maximum number of files in root directory */
-#define FAT12_ROOT_DIR_SECTORS 1 /* Number of sectors for root directory */
+// --- Configuration ---
+#define FAT12_SECTOR_SIZE 512
 
+// --- On-Disk Structures (Must be Packed) ---
+
+// BIOS Parameter Block (Start of Boot Sector)
 typedef struct {
-    uint8_t jump[3]; /* Jump instruction for boot */
-    char oem[8]; /* OEM name */
-    uint16_t bytes_per_sector; /* Bytes per sector */
-    uint8_t sectors_per_cluster; /* Sectors per cluster */
-    uint16_t reserved_sectors; /* Reserved sectors count */
-    uint8_t num_fats; /* Number of FATs */
-    uint16_t max_root_dir_entries; /* Max entries in root directory */
-    uint16_t total_sectors; /* Total sectors */
-    uint8_t media_descriptor; /* Media descriptor */
-    uint16_t fat_size; /* Size of each FAT */
-    uint16_t sectors_per_track; /* Sectors per track */
-    uint16_t num_heads; /* Number of heads */
-    uint32_t hidden_sectors; /* Hidden sectors count */
-    uint32_t total_sectors_large; /* Total sectors for large disks */
-} __attribute__((packed)) FAT12_BootSector; /* Packed structure for boot sector */
+    uint8_t  jump[3];
+    char     oem[8];
+    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 name[11]; /* File name (8.3 format) */
-    uint8_t attr; /* File attributes */
-    uint16_t reserved; /* Reserved */
-    uint16_t time; /* Time of last write */
-    uint16_t date; /* Date of last write */
-    uint16_t start_cluster; /* Starting cluster number */
-    uint32_t file_size; /* File size in bytes */
-} __attribute__((packed)) FAT12_DirEntry; /* Directory entry structure */
+    char     filename[8];
+    char     ext[3];
+    uint8_t  attributes;
+    uint8_t  reserved;
+    uint8_t  creation_ms;
+    uint16_t creation_time;
+    uint16_t creation_date;
+    uint16_t last_access_date;
+    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
+    uint32_t file_size;        // Size in bytes
+} __attribute__((packed)) fat12_entry_t;
 
-void initialize_fat12(const char *disk_image); /* Function to initialize FAT12 */
-void read_fat12(const char *disk_image); /* Function to read FAT12 */
-void write_fat12(const char *disk_image); /* Function to write FAT12 */
-void list_files(const char *disk_image); /* Function to list files in root directory */
-void read_file(const char *disk_image, const char *filename); /* Function to read a file */
-void write_file(const char *disk_image, const char *filename, const uint8_t *data, size_t size); /* Function to write a file */
+// --- 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;
+} file_t;
 
-#endif 
-/* FAT12_H */
+// --- Public API ---
+
+// 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 // FAT12_H

kernel/io.h

@@ -13,4 +13,24 @@ static inline uint8_t inb(uint16_t port) {
     return ret;
 }
 
+static inline void outw(uint16_t port, uint16_t val) {
+    __asm__("outw %0, %1" : : "a"(val), "Nd"(port));
+}
+
+static inline uint16_t inw(uint16_t port) {
+    uint16_t ret;
+    __asm__("inw %1, %0" : "=a"(ret) : "Nd"(port));
+    return ret;
+}
+
+static inline void outl(uint16_t port, uint32_t val) {
+    __asm__("outl %0, %1" : : "a"(val), "Nd"(port));
+}
+
+static inline uint32_t inl(uint16_t port) {
+    uint32_t ret;
+    __asm__("inl %1, %0" : "=a"(ret) : "Nd"(port));
+    return ret;
+}
+
 #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/scheduler.c

@@ -1,7 +1,12 @@
 #include "scheduler.h"
 #include <stddef.h>
 
+// Defined in context_switch.s
+extern void ctx_switch(uint32_t **old_sp_ptr, uint32_t *new_sp);
+
 static task_t tasks[MAX_TASKS];
+
+// Stack memory area. Note: x86 Stacks grow DOWN from high to low addresses.
 static uint32_t task_stacks[MAX_TASKS][STACK_SIZE / sizeof(uint32_t)];
 
 static int task_count = 0;
@@ -9,7 +14,6 @@ static task_t *task_list = NULL;
 static task_t *current_task = NULL;
 
 void scheduler_init() {
-    // Initialize task list, etc.
     task_list = NULL;
     current_task = NULL;
     task_count = 0;
@@ -20,16 +24,42 @@ void scheduler_add_task(void (*entry)(void)) {
 
     task_t *new_task = &tasks[task_count];
     new_task->id = task_count;
-    new_task->entry = entry;
 
-    // Simulate a stack pointer pointing to the "top" of the stack
-    new_task->stack_ptr = &task_stacks[task_count][STACK_SIZE / sizeof(uint32_t) - 1];
+    // 1. Calculate the top of the stack (High Address)
+    // We point to the very end of the array.
+    uint32_t *sp = &task_stacks[task_count][STACK_SIZE / sizeof(uint32_t)];
 
+    // 2. "Forge" the stack frame to look like ctx_switch saved it.
+    // We push values onto the stack by decrementing the pointer and writing.
+
+    // --- Return Address (EIP) ---
+    sp--; 
+    *sp = (uint32_t)entry; // When ctx_switch does 'ret', it pops this and jumps to 'entry'
+
+    // --- EFLAGS ---
+    sp--;
+    *sp = 0x00000202; // Reserved bit set, Interrupts Enabled (IF=1). Important!
+
+    // --- General Purpose Registers (PUSHA/POPA layout) ---
+    // Order: EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI
+    // We initialize them to 0 or meaningful values.
+    sp--; *sp = 0; // EAX
+    sp--; *sp = 0; // ECX
+    sp--; *sp = 0; // EDX
+    sp--; *sp = 0; // EBX
+    sp--; *sp = 0; // ESP (Ignored by POPA)
+    sp--; *sp = 0; // EBP
+    sp--; *sp = 0; // ESI
+    sp--; *sp = 0; // EDI
+
+    // Save this final stack location to the TCB
+    new_task->stack_ptr = sp;
     new_task->next = NULL;
 
-    // Add to task list
+    // 3. Add to linked list
     if (task_list == NULL) {
         task_list = new_task;
+        current_task = new_task; // Make sure we have a current task to start
     } else {
         task_t *tail = task_list;
         while (tail->next) {
@@ -42,21 +72,25 @@ void scheduler_add_task(void (*entry)(void)) {
 }
 
 void scheduler_schedule() {
-    // Very basic round-robin switch
-    if (current_task && current_task->next) {
+    if (!current_task) return;
+
+    task_t *prev = current_task;
+    
+    // Round-robin logic
+    if (current_task->next) {
         current_task = current_task->next;
     } else {
-        current_task = task_list; // Loop back
+        current_task = task_list;
     }
 
-    // Call context switch or simulate yielding to current_task
-    // In real system: context_switch_to(current_task)
-    if (current_task && current_task->entry) {
-        current_task->entry();  // Simulate switching by calling
+    // Perform the ACTUAL context switch
+    // We pass the address of the previous task's stack pointer storage
+    // and the value of the new task's stack pointer.
+    if (prev != current_task) {
+        ctx_switch(&prev->stack_ptr, current_task->stack_ptr);
     }
 }
 
 void scheduler_yield() {
-    // Stub: manually call schedule for cooperative multitasking
     scheduler_schedule();
 }

kernel/scheduler.h

@@ -4,18 +4,21 @@
 #include <stdint.h>
 
 #define MAX_TASKS 8
-#define STACK_SIZE 1024
+#define STACK_SIZE 1024 // in bytes
 
 typedef struct task {
     uint32_t id;
-    void (*entry)(void);
+    
+    // The most important field: 
+    // Where was the stack pointer when we last left this task?
     uint32_t *stack_ptr; 
+    
     struct task *next;
 } task_t;
 
 void scheduler_init();
 void scheduler_add_task(void (*entry)(void));
 void scheduler_schedule();
-void scheduler_yield();  // Optional for cooperative scheduling
+void scheduler_yield();
 
 #endif // SCHEDULER_H

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