.asm-lsp.toml

@@ -1,21 +0,0 @@
-[default_config]
-version = "0.10.0"
-assembler = "nasm"
-instruction_set = "x86/x86-64"
-
-[default_config.opts]
-compiler = "zig"
-compile_flags_txt = [
-  "cc",
-  "-x",
-  "assembler-with-cpp",
-  "-g",
-  "-Wall",
-  "-Wextra",
-  "-pedantic",
-  "-pedantic-errors",
-  "-std=c2y",
-  "-mllvm --x86-asm-syntax=intel",
-]
-diagnostics = true
-default_diagnostics = false

.gitignore

@@ -1,3 +1,2 @@
 zig-out
 .zig-cache
-.kate-swp

README.md

@@ -1,33 +0,0 @@
-an operating system made in nasm assembly and (in the future) zig, using the zig build system.
-this project is based on [this video series](https://www.youtube.com/playlist?list=PLFjM7v6KGMpiH2G-kT781ByCNC_0pKpPN) by [nanobyte](https://www.youtube.com/@nanobyte-dev)
-
-# HOWTO
-
-## dependencies
-
-this project requires the nasm assembler, mtools for floppy disk generation and zig to build.
-this project uses qemu as the default emulator, but this is optional
-
-## building
-
-```bash
-git clone https://dario48.site/git/Dario48/zos.git
-cd zos
-zig build
-```
-
-## running
-
-- with the default emulator
-
-```bash
-cd zos
-zig build run
-```
-
-- with a different emulator
-
-```bash
-cd zos
-emulator_cmd zig-out/bin/main_floppy.img
-```

build.zig

@@ -18,40 +18,16 @@ pub fn build(b: *std.Build) void {
     var floppy = createFloppy(b, "main_floppy.img");
     floppy.run = formatFloppyFat12(b, floppy);
 
-    var installToFloppy = installImgToFloppy(b, floppy, initramfs, &.{
-        NamedFile{ .file = .{ .runFile = kernel }, .name = "::kernel.bin" },
-        NamedFile{ .file = .{ .simpleFile = b.path("src/reference_implementations/test.txt") }, .name = "::test.txt" },
-    });
-
     const img_install = b.addInstallBinFile(floppy.obj, "main_floppy.img");
-    img_install.step.dependOn(&installToFloppy);
+    img_install.step.dependOn(&installImgToFloppy(b, floppy, initramfs, kernel).step);
 
     b.getInstallStep().dependOn(&img_install.step);
 
-    const target = b.standardTargetOptions(.{});
-    const fat_reference_mod = b.createModule(.{
-        .root_source_file = b.path("src/reference_implementations/fat.zig"),
-        .target = target,
-        .link_libc = true,
-    });
-
     const run = b.addSystemCommand(&.{ "qemu-system-i386", "-fda" });
-    run.addFileArg(floppy.obj);
+    run.addFileArg(b.path("zig-out/bin/initramfs.img"));
 
     const run_step = b.step("run", "run the os in qemu");
     run_step.dependOn(&run.step);
-
-    const fat_reference = b.addExecutable(.{
-        .root_module = fat_reference_mod,
-        .name = "fat_reference_implementation",
-        .use_lld = false,
-        .use_llvm = false,
-    });
-
-    const fat_install = b.addInstallArtifact(fat_reference, .{});
-
-    const build_references = b.step("references", "build the reference implementations");
-    build_references.dependOn(&fat_install.step);
 }
 
 const AddNasmFilesOptions = struct {
@@ -67,11 +43,6 @@ const NasmFile = struct {
 
 const Floppydisk = NasmFile;
 
-const NamedFile = struct {
-    file: union(enum) { runFile: NasmFile, simpleFile: std.Build.LazyPath },
-    name: []const u8,
-};
-
 fn createFloppy(b: *std.Build, name: []const u8) Floppydisk {
     const dd = b.addSystemCommand(&.{ "dd", "if=/dev/zero" });
     const Floppy = dd.addPrefixedOutputFileArg("of=", name);
@@ -92,7 +63,7 @@ fn formatFloppyFat12(b: *std.Build, floppy: Floppydisk) *std.Build.Step.Run {
     return mkfs;
 }
 
-fn installImgToFloppy(b: *std.Build, floppy: Floppydisk, bootloader: NasmFile, additional_files: []const NamedFile) std.Build.Step {
+fn installImgToFloppy(b: *std.Build, floppy: Floppydisk, bootloader: NasmFile, kernel: NasmFile) *std.Build.Step.Run {
     const dd = b.addSystemCommand(&.{"dd"});
     dd.addPrefixedFileArg("if=", bootloader.obj);
     dd.addPrefixedFileArg("of=", floppy.obj);
@@ -100,22 +71,14 @@ fn installImgToFloppy(b: *std.Build, floppy: Floppydisk, bootloader: NasmFile, a
     dd.step.dependOn(&floppy.run.step);
     dd.step.dependOn(&bootloader.run.step);
 
-    var mcopy_step = std.Build.Step.init(.{ .name = "mcopy", .owner = b, .id = .custom });
-    mcopy_step.dependOn(&dd.step);
-    for (additional_files) |f| {
     const mcopy = b.addSystemCommand(&.{"mcopy"});
     mcopy.addPrefixedFileArg("-i", floppy.obj);
-        switch (f.file) {
+    mcopy.addFileArg(kernel.obj);
-            .runFile => |file| {
+    mcopy.addArg("::kernel.bin");
-                mcopy.addFileArg(file.obj);
+    mcopy.step.dependOn(&dd.step);
-                mcopy_step.dependOn(&file.run.step);
+    mcopy.step.dependOn(&kernel.run.step);
-            },
+
-            .simpleFile => |file| mcopy.addFileArg(file),
+    return mcopy;
-        }
-        mcopy.addArg(f.name);
-        mcopy_step.dependOn(&mcopy.step);
-    }
-    return mcopy_step;
 }
 
 // adapted from https://codeberg.org/raddari/zig-nasm-lib.git

build.zig.zon

@@ -28,7 +28,7 @@
 
     // Tracks the earliest Zig version that the package considers to be a
     // supported use case.
-    .minimum_zig_version = "0.15.0",
+    .minimum_zig_version = "0.14.1",
 
     // This field is optional.
     // Each dependency must either provide a `url` and `hash`, or a `path`.

src/initramfs.asm

@@ -2,40 +2,8 @@
 org 0x7C00
 bits 16
 
-
 %define ENDL 0x0D, 0x0A
 
-;
-; FAT12 Header
-;
-jmp short start
-nop
-
-bdb_oem:					db "mkfs.fat"
-bdb_bytes_per_sector:		dw 512
-bdb_sectors_per_cluster:	db 1
-bdb_reserved_sectors:		dw 1
-bdb_fat_count:				db 2
-bdb_dir_entries_count:		dw 0E0h
-bdb_total_sectors:			dw 2880
-bdb_media_descriptor_type:	db 0F0h
-bdb_sectors_per_fat:		dw 9
-bdb_sectors_per_track:		dw 18
-bdb_heads:					dw 2
-bdb_hidden_sectors:			dd 0
-bdb_large_sector_count:		dd 0
-
-; Extended boot record
-ebr_drive_number:			db 0
-							db 0
-ebr_signature:				db 29h
-ebr_volume_id:				db 68h, 6Fh, 6Dh, 6Fh
-ebr_volume_laber:			db 'zos disk   '
-ebr_system_id:				db 'FAT12   '
-
-
-
-
 start:
 	jmp main
 
@@ -79,139 +47,16 @@ main:
 	mov ss, ax
 	mov sp, 0x7C00	; stack grows downward from where we are loaded in memory
 
-	mov si, msg_startup
+	; print the hello world
+	mov si, msg_hello
 	call echo
 
-	mov si, msg_reading_from_disk
-	call echo
-	mov [ebr_drive_number], dl
-
-	mov ax, 1								; second sector from disk
-	mov cl, 1								; 1 sector to read
-	mov bx, 0x7E00							; data should be after the bootloader
-	call disk_read
-
-	cli
-	hlt
-
-; errors
-
-floppy_error:
-	mov si, msg_read_failed
-	call echo
-	jmp .wait_and_reboot
-
-.wait_and_reboot:
-	mov ah, 0
-	int 16h
-	
-	jmp 0FFFFh:0							; jump to start of bios, should reboot
-
 	hlt
 
 .halt:
-	cli										; disable interrupts, this way we shouldn't be able to get out of halt
-	hlt
 	jmp .halt
 
-
+msg_hello: db 'Hello, world!', ENDL, 0
-;
-; args: 
-;	ax = lba adress
-; return:
-; 	cx[0..5] = sector number
-; 	cx[6-15] = cilinder number
-; 	dh: head
-;
-lba_to_chs:
-	push ax
-	push dx
-
-	xor dx, dx								; clear dw
-	div word [bdb_sectors_per_track]		; ax = LBA / SectorsPerTrack
-											; dx = LBA % SectorsPerTrack
-
-	inc dx
-	mov cx, dx								; cx = sector
-
-	xor dx, dx								; clear dx
-	div word [bdb_heads]					; ax = (LBA / SectorsPerTrack) / Heads = cylinder
-	                                        ; dx = (LBA / SectorsPerTrack) % Heads = head
-	mov dh, dl
-	mov ch, al
-	shl ah, 6
-	or cl, ah								; put upper 2 bits of cylinder in CL
-
-	pop ax
-	mov dl, al
-	pop ax
-
-	ret
-
-
-;
-; args:
-;	ax = LBA adress
-;	cl = number of sectors to read
-;	dl = drive number
-;	es:bx = pointer to where to store the data
-;
-
-disk_read:
-	push ax
-	push bx
-	push cx
-	push dx
-	push di
-
-	push cx									; cx will be overridden
-	call lba_to_chs
-	pop ax									; al = number of sectors to read
-	mov ah, 02h
-	mov di, 3								; hoe many times to try
-
-.retry:
-	pusha
-	stc										; set carry flag
-	int 13h									; if no carry flag => it work
-
-	jnc .done
-
-	; read fail
-	popa
-	call disk_reset
-	dec di
-
-	test di, di
-	jnz .retry
-
-.fail:
-	jmp floppy_error
-
-.done:
-	popa
-	
-	pop di
-	pop dx
-	pop cx
-	pop bx
-	pop ax
-	ret
-
-; arg: dl = drive number
-
-disk_reset:
-	pusha
-	mov ah, 0
-	stc										; set carry
-	int 13h	
-	jc floppy_error
-	popa
-	ret
-
-msg_startup: 								db 'starting zos, please hold while we check for any problems', ENDL, 0
-msg_reading_from_disk:						db 'testing reading from disk', ENDL, 0
-msg_read_failed:							db 'error when trying to read from floppy', ENDL, 0
 
 times 510-($-$$) db 0
 dw 0AA55h

src/reference_implementations/fat.zig

@@ -1,117 +0,0 @@
-const std = @import("std");
-
-const Errors = error{ InvalidSyntax, ReadSectors, FileNotFound };
-
-var buffer: [1024]u8 = undefined;
-
-var g_Fat: []u8 = undefined;
-
-const BootSector = extern struct {
-    BootJumpInstruction: [3]u8 align(1),
-    OemIdentifier: [8]u8 align(1),
-    BytesPerSector: u16 align(1),
-    SectorsPerCluster: u8 align(1),
-    ReservedSectors: u16 align(1),
-    FatCount: u8 align(1),
-    DirEntryCount: u16 align(1),
-    TotalSectors: u16 align(1),
-    MediaDescriptorType: u8 align(1),
-    SectorsPerFat: u16 align(1),
-    SectorsPerTrack: u16 align(1),
-    Heads: u16 align(1),
-    HiddenSectors: u32 align(1),
-    LargeSectorCount: u32 align(1),
-
-    // ebr
-    DriveNumber: u8 align(1),
-    _Reserved: u8 align(1),
-    Signature: u8 align(1),
-    VolumeId: u32 align(1),
-    VolumeLaber: [11]u8 align(1),
-    SystemId: [8]u8 align(1),
-};
-
-var g_BootSector: BootSector = undefined;
-
-const DirectoryEntry = extern struct {
-    Name: [11]u8 align(1),
-    Attributes: u8 align(1),
-    _Reserved: u8 align(1),
-    CreatedTimeTenths: u8 align(1),
-    CreatedTime: u16 align(1),
-    CreatedDate: u16 align(1),
-    AccessedDate: u16 align(1),
-    FirstClusterHigh: u16 align(1),
-    ModifiedTime: u16 align(1),
-    ModifiedDate: u16 align(1),
-    FirstClusterLow: u16 align(1),
-    Size: u32 align(1),
-};
-
-var g_RootDirectory: []DirectoryEntry = undefined;
-
-fn readStruct(reader: *std.fs.File.Reader, T: type) !T {
-    var ret: [@sizeOf(T)]u8 = undefined;
-    _ = try reader.*.read(&ret);
-    return @bitCast(ret);
-}
-
-fn readBootSector(disk: *std.fs.File) !void {
-    var reader = disk.*.reader(&buffer);
-    g_BootSector = try readStruct(&reader, BootSector);
-}
-
-fn readSectors(disk: *std.fs.File, lba: u32, count: u32, bufferOut: *[]anyopaque) !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);
-}
-
-fn readFat(disk: *std.fs.File) !void {
-    g_Fat = try std.heap.smp_allocator.alloc(u8, g_BootSector.SectorsPerFat * g_BootSector.BytesPerSector);
-    errdefer std.heap.smp_allocator.free(g_Fat);
-    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;
-    const size: u32 = @sizeOf(DirectoryEntry) * g_BootSector.DirEntryCount;
-    const 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);
-}
-
-fn findFile(name: []const u8) !*DirectoryEntry {
-    for (g_RootDirectory, 0..) |Entry, i|
-        if (std.mem.eql(u8, Entry.Name, name))
-            return &g_RootDirectory[i];
-    return Errors.FileNotFound;
-}
-
-pub fn main() !void {
-    if (std.os.argv.len < 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 });
-
-    _ = &disk;
-    try readBootSector(&disk);
-
-    try readFat(&disk);
-    defer std.heap.smp_allocator.free(g_Fat);
-
-    try readRootDirectory(disk);
-    defer std.heap.smp_allocator.free(g_RootDirectory);
-
-    const fileEntry = try findFile(std.os.argv[2]);
-    _ = fileEntry;
-}

src/reference_implementations/test.txt

@@ -1,3 +0,0 @@
-testing file
-aabaacaadaaeaafaagaahaaiaajaakaalaamaanaaoaapaaqaaraasaataauaavaawaaxaayaaz
-tstngfl