Merge pull request #90 from gbowne1/gbowne1-patch-2

Fix extern declaration for disk_read_sector function

bootloader/stage2.asm

@@ -24,84 +24,3 @@ _start:
     call load_kernel
 
     jmp eax
-
-; ----------------------------------------------------------------------------
-; ATA read sectors (LBA mode) 
-;
-; sysv32 abi signature:
-; void ata_lba_read(uint32_t lba, uint8_t nsect, void *addr);
-; ----------------------------------------------------------------------------
-ata_lba_read:
-    push ebp
-    mov ebp, esp
-
-    push ebx
-    push ecx
-    push edx
-    push edi
-
-    ; 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
-    and eax, 0x0FFFFFFF
-
-    mov ebx, eax         ; Save LBA in RBX
-
-    mov edx, 0x01F6      ; Port to send drive and bit 24 - 27 of LBA
-    shr eax, 24          ; Get bit 24 - 27 in al
-    or al, 11100000b     ; Set bit 6 in al for LBA mode
-    out dx, al
-
-    mov edx, 0x01F2      ; Port to send number of sectors
-    mov al, cl           ; Get number of sectors from CL
-    out dx, al
-
-    mov edx, 0x1F3       ; Port to send bit 0 - 7 of LBA
-    mov eax, ebx         ; Get LBA from EBX
-    out dx, al
-
-    mov edx, 0x1F4       ; Port to send bit 8 - 15 of LBA
-    mov eax, ebx         ; Get LBA from EBX
-    shr eax, 8           ; Get bit 8 - 15 in AL
-    out dx, al
-
-    mov edx, 0x1F5       ; Port to send bit 16 - 23 of LBA
-    mov eax, ebx         ; Get LBA from EBX
-    shr eax, 16          ; Get bit 16 - 23 in AL
-    out dx, al
-
-    mov edx, 0x1F7       ; Command port
-    mov al, 0x20         ; Read with retry.
-    out dx, al
-
-    mov bl, cl           ; Save # of sectors in BL
-
-.wait_rdy2:
-    mov edx, 0x1F7
-.do_wait_rdy2:
-    in al, dx
-    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_rdy2       ; ...done?
-
-    pop edi
-    pop edx
-    pop ecx
-    pop ebx
-    pop ebp
-    ret

bootloader/stage2.ld

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

bootloader/stage2_load.c

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

kernel/cpu.c

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

kernel/cpu.h

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

kernel/fat12.c

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

kernel/fat12.h

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