Dario48/zos
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

initramfs -> bootloader, kernel can now be loaded, FAT can now be looked

Browse source 
at throug reference implementation
This commit is contained in:
Dario48 2025-07-23 17:24:23 +02:00
parent c7ec508dba
commit e1926aec8a
5 changed files with 495 additions and 316 deletions
Download patch file Download diff file Expand all files Collapse all files

96
src/reference_implementations/fat.zig
View file

@ -6,6 +6,10 @@ var buffer: [1024]u8 = undefined;
var g_Fat: []u8 = undefined;
pub const std_options: std.Options = .{
.log_level = .info,
};
const BootSector = extern struct {
BootJumpInstruction: [3]u8 align(1),
OemIdentifier: [8]u8 align(1),
@ -49,10 +53,11 @@ const DirectoryEntry = extern struct {
};
var g_RootDirectory: []DirectoryEntry = undefined;
var g_RootDirectoryEnd: u32 = undefined;
fn readStruct(reader: *std.fs.File.Reader, T: type) !T {
var ret: [@sizeOf(T)]u8 = undefined;
_ = try reader.*.read(&ret);
_ = try reader.*.readStreaming(&ret);
return @bitCast(ret);
}
@ -61,13 +66,13 @@ fn readBootSector(disk: *std.fs.File) !void {
g_BootSector = try readStruct(&reader, BootSector);
}
fn readSectors(disk: *std.fs.File, lba: u32, count: u32, bufferOut: *[]anyopaque) !void {
fn readSectors(disk: *std.fs.File, lba: u32, count: u32, bufferOut: *[]u8) !void {
const dest: []u8 = try std.heap.smp_allocator.alloc(u8, g_BootSector.BytesPerSector * count);
defer std.heap.smp_allocator.free(dest);
var stream = disk.readerStreaming(&buffer);
try stream.seekTo(lba * g_BootSector.BytesPerSector);
if (try stream.readStreaming(dest) != g_BootSector.BytesPerSector * count) return Errors.ReadSectors;
@memcpy(@as(*[]u8, @ptrCast(bufferOut)).*, dest);
try disk.seekTo(lba * g_BootSector.BytesPerSector);
var reader = disk.readerStreaming(&buffer);
if (try reader.readStreaming(dest) != g_BootSector.BytesPerSector * count) return Errors.ReadSectors;
@memcpy(bufferOut.*, dest);
}
fn readFat(disk: *std.fs.File) !void {
@ -76,42 +81,93 @@ fn readFat(disk: *std.fs.File) !void {
try readSectors(disk, g_BootSector.ReservedSectors, g_BootSector.SectorsPerFat, &g_Fat);
}
fn readRootDirectory(disk: std.fs.File) !void {
const lba: u32 = g_BootSector.ReservedSectors + g_BootSector.SectorsPerFat + g_BootSector.FatCount;
fn readRootDirectory(disk: *std.fs.File) !void {
const lba: u32 = g_BootSector.ReservedSectors + g_BootSector.SectorsPerFat * g_BootSector.FatCount;
const size: u32 = @sizeOf(DirectoryEntry) * g_BootSector.DirEntryCount;
const sectors: u32 = (size / g_BootSector.BytesPerSector);
if (@rem(size, g_BootSector.BytesPerSector > 0))
var sectors: u32 = (size / g_BootSector.BytesPerSector);
if (@rem(size, g_BootSector.BytesPerSector) > 0)
sectors += 1;
g_RootDirectory = try std.heap.smp_allocator.alloc(DirectoryEntry, sectors * g_BootSector.BytesPerSector);
errdefer std.heap.smp_allocator.free(g_RootDirectory);
try readSectors(disk, lba, sectors, &g_RootDirectory);
g_RootDirectoryEnd = lba + sectors;
try readSectors(disk, lba, sectors, @ptrCast(&g_RootDirectory));
for (g_RootDirectory) |Entry| {
std.log.debug("Entry: {any}, Entry.Name: {s}", .{
Entry, Entry.Name,
});
}
}
fn findFile(name: []const u8) !*DirectoryEntry {
for (g_RootDirectory, 0..) |Entry, i|
if (std.mem.eql(u8, Entry.Name, name))
for (g_RootDirectory, 0..) |Entry, i| {
std.log.debug("looking at {s}", .{Entry.Name});
if (std.mem.eql(u8, &Entry.Name, name))
return &g_RootDirectory[i];
}
return Errors.FileNotFound;
}
fn readFile(file: *DirectoryEntry, disk: *std.fs.File, outputBuffer: *[]u8) !void {
var currentCluster: u16 = file.FirstClusterLow;
const offset = g_BootSector.SectorsPerCluster * g_BootSector.BytesPerSector;
var i: usize = 0;
while (currentCluster < 0x0FF8) {
std.log.debug("currentCluster: {}", .{currentCluster});
const lba: u32 = g_RootDirectoryEnd + (currentCluster -% 2) * g_BootSector.SectorsPerCluster;
var sizedOutput = outputBuffer.*[i .. i + offset];
try readSectors(disk, lba, g_BootSector.SectorsPerCluster, &sizedOutput);
std.log.debug("sizedOutput: {s}", .{sizedOutput});
i += offset;
const fatindex = currentCluster * 3 / 2;
std.log.debug("@as(u16, g_Fat[fatindex]): {}, g_Fat[fatindex]: {}", .{ @as(*align(1) u16, @ptrCast(&g_Fat[fatindex])).*, g_Fat[fatindex] });
if (@rem(currentCluster, 2) == 0) {
currentCluster = @as(*align(1) u16, @ptrCast(&g_Fat[fatindex])).* & 0x0FFF;
} else {
currentCluster = @as(*align(1) u16, @ptrCast(&g_Fat[fatindex])).* >> 4;
}
}
}
pub fn main() !void {
if (std.os.argv.len < 3) {
var args = try std.process.argsWithAllocator(std.heap.smp_allocator);
defer args.deinit();
if (args.inner.count < 3) {
std.log.err("syntax: {s} <disk image> <file name>", .{std.os.argv[0]});
return Errors.InvalidSyntax;
}
var disk = try std.fs.cwd().openFileZ(std.os.argv[1], .{ .mode = .read_only });
_ = args.skip();
var disk = try std.fs.cwd().openFileZ(args.next().?, .{ .mode = .read_only });
std.log.debug("opened disk {any}", .{disk});
_ = &disk;
try readBootSector(&disk);
std.log.debug("read BootSector from disk, {any}", .{g_BootSector});
try readFat(&disk);
defer std.heap.smp_allocator.free(g_Fat);
std.log.debug("read file allocation table from disk, {any}", .{g_Fat});
try readRootDirectory(disk);
try readRootDirectory(&disk);
defer std.heap.smp_allocator.free(g_RootDirectory);
std.log.debug("read root directory from disk, {any}", .{g_RootDirectory});
const fileEntry = try findFile(std.os.argv[2]);
_ = fileEntry;
const fileEntry = try findFile(try std.fmt.allocPrint(std.heap.smp_allocator, "{s}", .{args.next().?}));
var fileBuffer = try std.heap.smp_allocator.alloc(u8, fileEntry.Size + g_BootSector.BytesPerSector);
@memset(fileBuffer, 0);
defer std.heap.smp_allocator.free(fileBuffer);
try readFile(fileEntry, &disk, &fileBuffer);
const stdout = std.fs.File.stdout();
defer stdout.close();
var writer = stdout.writer(&buffer);
try writer.interface.print("{s}\n", .{@as(*[:0]u8, @ptrCast(&fileBuffer)).*});
const newline = "\n";
_ = try std.posix.write(0, fileBuffer);
_ = try std.posix.write(0, newline);
}