diff --git a/kernel/fat12.c b/kernel/fat12.c index 7f0a1da..0b4b1df 100644 --- a/kernel/fat12.c +++ b/kernel/fat12.c @@ -1,183 +1,146 @@ #include "fat12.h" -#include // for NULL +#include "floppy.h" +#include -// --- 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]; +// Local scratch buffer +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 *p2 = (const uint8_t *)s2; + const uint8_t *p1 = s1, *p2 = 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] != '\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++; + while (src[i] && src[i] != '.' && j < 8) { + char c = src[i++]; + dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c; } - - // 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++; + while (src[i] && j < 11) { + char c = src[i++]; + dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c; } } -// --- 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 - disk_read_sector(fat_sector, g_sector_buffer); + uint8_t bytes[2]; + floppy_read_sector(fat_sector, sector_buffer); + bytes[0] = sector_buffer[ent_offset]; - // 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 + // Boundary Fix: If entry spans two sectors + if (ent_offset == 511) { + floppy_read_sector(fat_sector + 1, sector_buffer); + bytes[1] = sector_buffer[0]; } 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]; - to_fat_name(filename, target_name); + char fat_name[11]; + 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 - - // 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 + if (entries[j].filename[0] == 0x00) return file; // End of list + if ((uint8_t)entries[j].filename[0] == 0xE5) continue; // Deleted + + if (k_memcmp(entries[j].filename, fat_name, 11) == 0) { + file.size = entries[j].file_size; + file.start_cluster = entries[j].low_cluster_num; 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) { - if (file->start_cluster == 0) return 0; // File not open +uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t count) { + 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) { - // 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; + while (total_read < count && file->current_cluster < 0xFF8) { + uint32_t lba = data_start_lba + (file->current_cluster - 2) * bpb.sectors_per_cluster; - // 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; + // 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 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; + + uint32_t chunk = left_in_sector; + if (chunk > left_in_file) chunk = left_in_file; + if (chunk > left_to_request) chunk = left_to_request; + + // Simple memcpy replacement + for (uint32_t i = 0; i < chunk; i++) { + buffer[total_read + i] = sector_buffer[offset_in_sector + i]; + } + + total_read += chunk; + file->bytes_read += chunk; + + if (chunk == 0 || file->bytes_read >= file->size || total_read >= count) break; + } + + // 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) { + file->current_cluster = fat12_get_next_cluster(file->current_cluster); + } + } - // 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; - } + if (file->bytes_read >= file->size) break; } return total_read;