Merge pull request #117 from gbowne1/klibc-strncpy

[klibc] implment strncpy function

Makefile

@@ -8,8 +8,13 @@ OBJCOPY = i386-elf-objcopy
 BUILD_DIR = build
 CROSS_DIR = cross
 DISK_IMG = $(BUILD_DIR)/disk.img
+
+STAGE2_ADDR = 0x7e00
 STAGE2_SIZE = 2048
 
+# Place the memory map (e820) past stage2 bl in memory
+MEMMAP_BASE = $(shell echo $$(($(STAGE2_ADDR) + $(STAGE2_SIZE))))
+
 KERNEL_C_SRC = $(wildcard kernel/*.c)
 KERNEL_ASM_SRC = $(wildcard kernel/*.asm)
 KERNEL_OBJ = $(patsubst kernel/%.c, $(BUILD_DIR)/%.o, $(KERNEL_C_SRC))
@@ -29,7 +34,7 @@ stage1: $(BUILD_DIR)
 # 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
+	$(AS) $(ASFLAGS) -DMEMMAP_BASE=$(MEMMAP_BASE) -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
 	$(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
@@ -39,7 +44,7 @@ $(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) -DMEMMAP_BASE=$(MEMMAP_BASE) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $@ $<
 
 $(BUILD_DIR)/klibc/%.o: klibc/src/%.c
 	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $@ $<

bootloader/README.md

@@ -11,16 +11,16 @@ Bootloader documentation for ClassicOS
 
 ## Stage 1 (`stage1.asm`)
 
-Responsible for loading the second stage using BIOS routines, and switching to protected mode.
-
 - Queries CHS parameters from BIOS
 - Loads the second stage bootloader (2048 B) to `0x7c00`
-- Sets up a GDT with descriptor entries for code and data both covering the whole 32-bit address space
 - Enables A20
-- Set CR0.PE (enable protected mode) and jump to stage 2
+- Jumps to stage2
 
 ## Stage 2 (`stage2.asm, stage2_load.c`)
 
+- Read and store E820 memory map from BIOS
+- Sets up a GDT with descriptor entries for code and data both covering the whole 32-bit address space
+- Set CR0.PE (enable protected mode)
 - Set up segment registers
 - Load the kernel ELF header
 - Parse the program headers, and load all `PT_LOAD` segments from disk

bootloader/stage1.asm

@@ -40,11 +40,8 @@ _start:
     call enable_a20
     jc a20_error                ; Jump if A20 enable fails
 
-    ; Setup Global Descriptor Table
-    call setup_gdt
-
-    ; Switch to protected mode and jump to second stage at 0x08:0x7E00
-    call switch_to_pm
+    ; Jump to s2
+    jmp 0x7e00
 
 disk_error:
     mov si, disk_error_msg
@@ -241,30 +238,6 @@ check_a20:
     clc                      ; Clear carry flag to indicate success
     ret
 
-; ----------------------------------------------------------------
-gdt_start:
-    dq 0x0000000000000000         ; Null descriptor
-    dq 0x00CF9A000000FFFF         ; 32-bit code segment (selector 0x08)
-    dq 0x00CF92000000FFFF         ; 32-bit data segment (selector 0x10)
-    dq 0x00009A000000FFFF         ; 16-bit code segment for real mode (selector 0x18)
-
-gdt_descriptor:
-    dw gdt_end - gdt_start - 1
-    dd gdt_start
-gdt_end:
-
-setup_gdt:
-    lgdt [gdt_descriptor]
-    ret
-
-; ----------------------------------------------------------------
-switch_to_pm:
-    cli
-    mov eax, cr0
-    or eax, 1
-    mov cr0, eax
-    jmp 0x08:0x7E00             ; jump to S2
-
 ; ----------------------------------------------------------------
 print_string_16:
 .loop:

bootloader/stage2.asm

@@ -1,10 +1,80 @@
-[BITS 32]
 global _start
-global ata_lba_read
-
 extern load_kernel
 
+%define e820_magic 0x534d4150 ; "SMAP"
+%define e820_entry_size 24
+%define e820_max_entries 128
+
+; ----------------------------------------------------------------
+; Real mode
+; ----------------------------------------------------------------
+[BITS 16]
 _start:
+    call read_e820
+    call setup_gdt
+    call switch_to_pm
+
+read_e820:
+    xor ebx, ebx
+    mov es, bx
+    mov di, MEMMAP_BASE+4       ; ES=0 DI=MEMMAP_BASE+4
+    xor bp, bp                  ; Keeping count in bp
+
+.e820_loop:
+    mov eax, 0xe820
+    mov ecx, e820_entry_size
+    mov edx, e820_magic
+    int 0x15
+    jc .done                    ; Error?
+
+    cmp eax, e820_magic         ; Verify "SMAP"
+    jne .done
+
+    test ecx, ecx               ; Skip 0-sized entries
+    jz .skip
+
+    add di, e820_entry_size     ; Advance write addr
+    inc bp                      ; Increment count
+
+    cmp bp, e820_max_entries    ; Stop if we're at capacity
+    jae .done
+.skip:
+    test ebx, ebx
+    jne .e820_loop
+.done:
+    mov [MEMMAP_BASE], bp       ; Store count
+    ret
+
+setup_gdt:
+    lgdt [gdt_descriptor]
+    ret
+
+switch_to_pm:
+    cli
+    mov eax, cr0
+    or eax, 1
+    mov cr0, eax
+    jmp 0x08:pm_entry
+
+e820_count:
+    dw 0
+
+gdt_start:
+    dq 0x0000000000000000         ; Null descriptor
+    dq 0x00CF9A000000FFFF         ; 32-bit code segment (selector 0x08)
+    dq 0x00CF92000000FFFF         ; 32-bit data segment (selector 0x10)
+    dq 0x00009A000000FFFF         ; 16-bit code segment for real mode (selector 0x18)
+gdt_descriptor:
+    dw gdt_end - gdt_start - 1
+    dd gdt_start
+gdt_end:
+
+; ----------------------------------------------------------------
+; Protected mode
+; ----------------------------------------------------------------
+[BITS 32]
+
+pm_entry:
     ; Set up segments
     ; Data segments
     mov ax, 0x10
@@ -18,9 +88,8 @@ _start:
     mov ax, 0x08
     mov cs, ax
 
-    ; Stack (must be identity-mapped)
+    ; Stack
     mov esp, 0x90000
 
     call load_kernel
-
     jmp eax

kernel/cmos.c

@@ -1,86 +0,0 @@
-#include "cmos.h"
-#include "io.h"
-#include "print.h"
-
-#define CMOS_ADDR 0x70
-#define CMOS_DATA 0x71
-
-enum {
-    CMOS_SEC  = 0x00,
-    CMOS_MIN  = 0x02,
-    CMOS_HOUR = 0x04,
-    CMOS_DAY  = 0x07,
-    CMOS_MONTH= 0x08,
-    CMOS_YEAR = 0x09,
-    CMOS_STAT_A = 0x0A,
-    CMOS_STAT_B = 0x0B
-};
-
-// Check if CMOS is currently updating its values
-static int is_updating() {
-    outb(CMOS_ADDR, CMOS_STAT_A);
-    return (inb(CMOS_DATA) & 0x80);
-}
-
-static uint8_t get_register(int reg) {
-    outb(CMOS_ADDR, reg);
-    return inb(CMOS_DATA);
-}
-
-void cmos_read_time(cmos_time_t* time) {
-    // Wait for any current update to finish
-    while (is_updating());
-
-    uint8_t sec   = get_register(CMOS_SEC);
-    uint8_t min   = get_register(CMOS_MIN);
-    uint8_t hour  = get_register(CMOS_HOUR);
-    uint8_t day   = get_register(CMOS_DAY);
-    uint8_t month = get_register(CMOS_MONTH);
-    uint8_t year  = get_register(CMOS_YEAR);
-    uint8_t statb = get_register(CMOS_STAT_B);
-
-    // If Bit 2 of Status Register B is 0, then values are BCD
-    if (!(statb & 0x04)) {
-        time->second = (sec & 0x0F) + ((sec / 16) * 10);
-        time->minute = (min & 0x0F) + ((min / 16) * 10);
-        time->hour   = ((hour & 0x0F) + (((hour & 0x70) / 16) * 10)) | (hour & 0x80);
-        time->day    = (day & 0x0F) + ((day / 16) * 10);
-        time->month  = (month & 0x0F) + ((month / 16) * 10);
-        time->year   = (year & 0x0F) + ((year / 16) * 10);
-    } else {
-        time->second = sec;
-        time->minute = min;
-        time->hour   = hour;
-        time->day    = day;
-        time->month  = month;
-        time->year   = year;
-    }
-
-    // Adjust for Century (assuming we are in the 2000s for ClassicOS)
-    time->year += 2000; 
-}
-
-void cmos_print_time(cmos_time_t* time) {
-    // Using your print_string/itoa style logic
-    char buf[16];
-    
-    print_string("System Time: ");
-    
-    // Simple padding check for minutes
-    print_hex(time->hour, 0, 1);
-    print_string(":");
-    if (time->minute < 10) print_string("0");
-    print_hex(time->minute, 0, 1);
-    print_string(":");
-    if (time->second < 10) print_string("0");
-    print_hex(time->second, 0, 1);
-    
-    print_string("  ");
-    
-    print_hex(time->month, 0, 1);
-    print_string("/");
-    print_hex(time->day, 0, 1);
-    print_string("/");
-    print_hex(time->year, 0, 1);
-    print_string("\n");
-}

kernel/cmos.h

@@ -1,18 +0,0 @@
-#ifndef CMOS_H
-#define CMOS_H
-
-#include <stdint.h>
-
-typedef struct {
-    uint8_t second;
-    uint8_t minute;
-    uint8_t hour;
-    uint8_t day;
-    uint8_t month;
-    uint32_t year;
-} cmos_time_t;
-
-void cmos_read_time(cmos_time_t* time);
-void cmos_print_time(cmos_time_t* time);
-
-#endif

kernel/memmap.c

@@ -1,21 +1,18 @@
 #include "memmap.h"
 
+#define BOOTLOADER_MEMMAP_COUNT_ADDR    MEMMAP_BASE
+#define BOOTLOADER_MEMMAP_ADDR          (MEMMAP_BASE + 4)
+
 uint32_t get_memory_map(memory_map_entry_t *map, uint32_t max_entries) {
+    // Read the number of entries found by the bootloader
+    uint32_t entries_found = *(uint32_t*)BOOTLOADER_MEMMAP_COUNT_ADDR;
+    memory_map_entry_t *bios_data = (memory_map_entry_t*)BOOTLOADER_MEMMAP_ADDR;
+
     uint32_t count = 0;
-
-    if (max_entries >= 1) {
-        map[count].base_addr = 0x00000000;
-        map[count].length = 0x0009FC00;
-        map[count].type = 1;
-        count++;
-    }
-
-    if (max_entries >= 2) {
-        map[count].base_addr = 0x00100000;
-        map[count].length = 0x1FF00000;
-        map[count].type = 1;
+    while (count < entries_found && count < max_entries) {
+        map[count] = bios_data[count];
         count++;
     }
 
     return count;
-}
+}

kernel/memmap.h

@@ -7,6 +7,7 @@ typedef struct {
     uint64_t base_addr;
     uint64_t length;
     uint32_t type;
+    uint32_t ext;
 } __attribute__((packed)) memory_map_entry_t;
 
 uint32_t get_memory_map(memory_map_entry_t *map, uint32_t max_entries);

klibc/include/string.h

@@ -3,12 +3,13 @@
 
 #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 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);
+extern size_t strlen(const char *s);
+extern int strcmp(const char *s1, const char *s2);
+extern char *strncpy(char *dst, const char *src, size_t n);
 
 #endif  // CLASSICOS_KLIBC_STRING_H

klibc/src/string.c

@@ -1,8 +1,8 @@
 #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 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--) {
@@ -13,9 +13,9 @@ int memcmp(const void* s1, const void* s2, size_t n) {
     return d;
 }
 
-void* memmove(void* dst, const void* src, size_t n) {
-    const char* p = src;
-    char* q = dst;
+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));
@@ -41,19 +41,19 @@ void* memmove(void* dst, const void* src, size_t n) {
     return dst;
 }
 
-void* memcpy(void* dst, const void* src, size_t n) {
-    const char* p = src;
-    char* q = 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));
+                     : "+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)));
+                     : "+c"(nq), "+S"(p), "+D"(q)
+                     : "r"((uint32_t)(n & 7)));
 #else
     while (n--) {
         *q++ = *p++;
@@ -63,20 +63,20 @@ void* memcpy(void* dst, const void* src, size_t n) {
     return dst;
 }
 
-void* memset(void* dst, int c, size_t n) {
-    char* q = 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));
+                     : "+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));
+                     : "+c"(nq), "+D"(q)
+                     : "a"((unsigned char)c * 0x0101010101010101U),
+                       "r"((uint32_t)n & 7));
 #else
     while (n--) {
         *q++ = c;
@@ -86,15 +86,15 @@ void* memset(void* dst, int c, size_t n) {
     return dst;
 }
 
-size_t strlen(const char* s) {
-    const char* ss = s;
+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;
+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;
 
@@ -105,3 +105,19 @@ int strcmp(const char* s1, const char* s2) {
 
     return d;
 }
+
+char *strncpy(char *dst, const char *src, size_t n) {
+    char *q = dst;
+    const char *p = src;
+    char ch;
+
+    while (n) {
+        n--;
+        *q++ = ch = *p++;
+        if (!ch) break;
+    }
+
+    memset(q, 0, n);
+
+    return dst;
+}