mirror of
https://github.com/gbowne1/ClassicOS.git
synced 2026-01-02 05:25:19 -08:00
Update fat12.c
This fixes a offset issue where 510-512 might not be read correctly and might error.
This commit is contained in:
GitHub
213
kernel/fat12.c
213
kernel/fat12.c
@@ -1,183 +1,146 @@
|
||||
#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)
|
||||
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;
|
||||
|
||||
Reference in New Issue
Block a user