Update fat12.c

This fixes a offset issue where 510-512 might not be read correctly and might error.

kernel/fat12.c

@@ -1,184 +1,147 @@
 #include "fat12.h"
-#include <stddef.h> // for NULL
+#include "floppy.h"
+#include <stddef.h>
 
-// --- Globals for Filesystem State ---
 static fat12_bpb_t bpb;
 static uint32_t fat_start_lba;
 static uint32_t root_dir_lba;
 static uint32_t data_start_lba;
 static uint32_t root_dir_sectors;
 
-// Scratch buffer to read sectors (avoids large stack usage)
+// Local scratch buffer
-static uint8_t g_sector_buffer[FAT12_SECTOR_SIZE];
+static uint8_t sector_buffer[FAT12_SECTOR_SIZE];
+
+/* --- Internal Helpers --- */
 
-// --- Utils (Since we don't have string.h) ---
 static int k_memcmp(const void *s1, const void *s2, uint32_t n) {
-    const uint8_t *p1 = (const uint8_t *)s1;
+    const uint8_t *p1 = s1, *p2 = s2;
-    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] = ' ';
-    for(int i=0; i<11; i++) dest[i] = ' ';
-
     int i = 0, j = 0;
-    // Copy Name
+    while (src[i] && src[i] != '.' && j < 8) {
-    while (src[i] != '\0' && src[i] != '.' && j < 8) {
+        char c = src[i++];
-        // Convert to uppercase (simple version)
+        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
-        char c = src[i];
-        if (c >= 'a' && c <= 'z') c -= 32; 
-        dest[j++] = c;
-        i++;
     }
-    
-    // Skip extension dot
     if (src[i] == '.') i++;
-
-    // Copy Extension
     j = 8;
-    while (src[i] != '\0' && j < 11) {
+    while (src[i] && j < 11) {
-        char c = src[i];
+        char c = src[i++];
-        if (c >= 'a' && c <= 'z') c -= 32;
+        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
-        dest[j++] = c;
-        i++;
     }
 }
 
-// --- Core Logic ---
+/* --- FAT Chain Logic --- */
 
-void fat12_init() {
-    // 1. Read Boot Sector (LBA 0)
-    disk_read_sector(0, g_sector_buffer);
 
-    // 2. Copy BPB data safely
-    // We cast the buffer to our struct
-    fat12_bpb_t *boot_sector = (fat12_bpb_t*)g_sector_buffer;
-    bpb = *boot_sector;
-
-    // 3. Calculate System Offsets
-    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;
 
-    // Read the sector containing the FAT entry
+    uint8_t bytes[2];
-    disk_read_sector(fat_sector, g_sector_buffer);
+    floppy_read_sector(fat_sector, sector_buffer);
+    bytes[0] = sector_buffer[ent_offset];
 
-    // Read 16 bits (2 bytes)
+    // Boundary Fix: If entry spans two sectors
-    // Note: If ent_offset == 511, the entry spans two sectors. 
+    if (ent_offset == 511) {
-    // For simplicity in this snippet, we ignore that edge case (rare).
+        floppy_read_sector(fat_sector + 1, sector_buffer);
-    // A robust kernel would check if(ent_offset == 511) and read next sector.
+        bytes[1] = sector_buffer[0];
-    
-    uint16_t val = *(uint16_t*)&g_sector_buffer[ent_offset];
-
-    if (current_cluster & 1) {
-        return val >> 4;      // Odd: High 12 bits
     } else {
-        return val & 0x0FFF;  // Even: Low 12 bits
+        bytes[1] = sector_buffer[ent_offset + 1];
     }
+
+    uint16_t val = (uint16_t)bytes[0] | ((uint16_t)bytes[1] << 8);
+    return (cluster & 1) ? (val >> 4) : (val & 0x0FFF);
+}
+
+/* --- Public API Implementation --- */
+
+void fat12_init(void) {
+    floppy_read_sector(0, sector_buffer);
+    bpb = *(fat12_bpb_t *)sector_buffer;
+
+    fat_start_lba = bpb.reserved_sectors;
+    root_dir_lba  = fat_start_lba + (bpb.fat_count * bpb.sectors_per_fat);
+    root_dir_sectors = (bpb.dir_entries_count * 32 + 511) / 512;
+    data_start_lba = root_dir_lba + root_dir_sectors;
 }
 
 file_t fat12_open(const char *filename) {
     file_t file = {0};
-    char target_name[11];
+    char fat_name[11];
-    to_fat_name(filename, target_name);
+    to_fat_name(filename, fat_name);
 
-    // Search Root Directory
     for (uint32_t i = 0; i < root_dir_sectors; i++) {
-        disk_read_sector(root_dir_lba + i, g_sector_buffer);
+        floppy_read_sector(root_dir_lba + i, sector_buffer);
+        fat12_entry_t *entries = (fat12_entry_t *)sector_buffer;
 
-        fat12_entry_t *entry = (fat12_entry_t*)g_sector_buffer;
-
-        // Check all 16 entries in this sector (512 / 32 = 16)
         for (int j = 0; j < 16; j++) {
-            if (entry[j].filename[0] == 0x00) return file; // End of Dir
+            if (entries[j].filename[0] == 0x00) return file; // End of list
+            if ((uint8_t)entries[j].filename[0] == 0xE5) continue; // Deleted
 
-            // Check if filename matches
+            if (k_memcmp(entries[j].filename, fat_name, 11) == 0) {
-            if (k_memcmp(entry[j].filename, target_name, 11) == 0) {
+                file.size = entries[j].file_size;
-                // Found it!
+                file.start_cluster = entries[j].low_cluster_num;
-                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 bytes_to_read) {
+uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t count) {
-    if (file->start_cluster == 0) return 0; // File not open
+    if (!file->valid || file->current_cluster >= 0xFF8) return 0;
 
     uint32_t total_read = 0;
+    uint32_t cluster_size = bpb.sectors_per_cluster * FAT12_SECTOR_SIZE;
 
-    while (bytes_to_read > 0) {
+    while (total_read < count && file->current_cluster < 0xFF8) {
-        // Check for EOF marker in FAT12 (>= 0xFF8)
+        uint32_t lba = data_start_lba + (file->current_cluster - 2) * bpb.sectors_per_cluster;
-        if (file->current_cluster >= 0xFF8) break;
         
-        // Calculate Physical LBA of current cluster
+        // Read each sector in the cluster
-        // LBA = DataStart + ((Cluster - 2) * SectorsPerCluster)
+        for (uint8_t s = 0; s < bpb.sectors_per_cluster; s++) {
-        uint32_t lba = data_start_lba + ((file->current_cluster - 2) * bpb.sectors_per_cluster);
+            floppy_read_sector(lba + s, sector_buffer);
 
-        // Read the cluster
+            // Calculate how much of this sector we actually need
-        // NOTE: Assumes SectorsPerCluster = 1 (Standard Floppy)
+            uint32_t offset_in_sector = file->bytes_read % FAT12_SECTOR_SIZE;
-        disk_read_sector(lba, g_sector_buffer);
+            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;
 
-        // Determine how much to copy from this sector
+            uint32_t chunk = left_in_sector;
-        uint32_t chunk_size = FAT12_SECTOR_SIZE;
+            if (chunk > left_in_file)    chunk = left_in_file;
+            if (chunk > left_to_request) chunk = left_to_request;
 
-        // If the file is smaller than a sector, or we are at the end
+            // Simple memcpy replacement
-        if (chunk_size > bytes_to_read) chunk_size = bytes_to_read;
+            for (uint32_t i = 0; i < chunk; i++) {
-        
+                buffer[total_read + i] = sector_buffer[offset_in_sector + i];
-        // 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
+            total_read += chunk;
-        for (uint32_t i = 0; i < chunk_size; i++) {
+            file->bytes_read += chunk;
-            buffer[total_read + i] = g_sector_buffer[i];
+
+            if (chunk == 0 || file->bytes_read >= file->size || total_read >= count) break;
         }
 
-        total_read += chunk_size;
+        // If we've finished the cluster, move to next
-        file->bytes_read += chunk_size;
+        if (file->bytes_read % cluster_size == 0 || file->bytes_read >= file->size) {
-        bytes_to_read -= chunk_size;
+             if (file->bytes_read < file->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;
 }