Making Virtualbox work

[Timzka]

i have tried a lot for the past week, my OS does boot on both VBox and Vmware, however, Vbox seems to be unable to use the filesystem.
i always seem to get one of 3 errors, either "readonly disk", "path not found (even though that exact path was created and does list under Directories), or it just decides to tell me in my settings, that the Filesystem.vdmk isnt accessable.

i havent found someone have that Problem, but i do wish to use audio in my system so i gotta use vbox...
and before someone tells me, i tried Qemu, couldnt figure it out

i believe what might help is someone showing me their settings for the OS in Vbox (specifically Filesystem) and/or their way of writing files

i am currently using PIIX3 and in code i use VFSManager functions for everything

[Timzka]

i also tried using the .vdmk provided in the documentation, same issues

[LoxyMono]

Which drive are you trying to access? Drive as in drive number. 1:/ (the ISO, usually) is read-only

[Timzka]

i am always using 0:
but i just noticed that vbox makes 0:\ my iso for some reason, not even listing my .vdmk at all

[Timzka]

well at least now it decides to show the vdmk, however, it seemingly contains no files even though it does.

might it be a wrong controller type? idk

[Timzka]

here are a few screenshots that might help, as seen i can still only access the iso, i also tried manually formatting the vdmk again, didnt do anything

[Timzka]

Well i figured out a lot the last few days.

no matter what i do, if i use a vmdk, if i use a vdi or just load a vmdk that already has all the data on it, the first time i launch it in vbox it can read and show everything on it.

as soon as i try to write anything, it tells me about an "aFirstCluster" error or throws a FileNotFound exception. after that nothing works anymore until i reboot.
However, once i reboot, the vmdk/vdi doesnt have a partition anymore so instead my 0:\ becomes my ISO.

i tried it with a new Project, that was purely made to do FS things, same issues, first boot makes it readable, once you write it is broken...

for that Test-Project i only made a kernel.cs which looks like this:
`using System;
using System.Collections.Generic;
using System.Text;
using Cosmos.System.FileSystem;
using Cosmos.System.FileSystem.VFS;
using Cosmos.System.FileSystem.Listing;
using Sys = Cosmos.System;

namespace FSTESTvbox
{
public class Kernel : Sys.Kernel
{
private CosmosVFS fs;

    protected override void BeforeRun()
    {
        Console.WriteLine("=== COSMOS Filesystem Test ===");
        Console.WriteLine();

        try
        {
            // Versuche VFS zu initialisieren
            Console.WriteLine("Initialisiere Virtual File System...");
            fs = new CosmosVFS();
            VFSManager.RegisterVFS(fs);
            Console.WriteLine("[OK] VFS erfolgreich initialisiert!");
            Console.WriteLine();

            // Zeige verfügbare Laufwerke
            Console.WriteLine("Verfügbare Laufwerke:");
            var disks = fs.GetDisks();
            Console.WriteLine($"  Anzahl Disks gefunden: {disks.Count}");
            for (int i = 0; i < disks.Count; i++)
            {
                var disk = disks[i];
                Console.WriteLine($"  - Disk {i} | Groesse: {disk.Size / 1024 / 1024} MB");

                var partitions = disk.Partitions;
                Console.WriteLine($"    Partitionen: {partitions.Count}");
                for (int j = 0; j < partitions.Count; j++)
                {
                    var partition = partitions[j];
                    Console.WriteLine($"    -> Partition {j} | RootPath: {partition.RootPath}");
                }
            }
            Console.WriteLine();

            // Zeige gemountete Volumes
            Console.WriteLine("Gemountete Volumes:");
            var volumes = fs.GetVolumes();
            Console.WriteLine($"  Anzahl Volumes: {volumes.Count}");
            for (int i = 0; i < volumes.Count; i++)
            {
                Console.WriteLine($"  - Volume {i}");
            }
            Console.WriteLine();

            // Liste Root-Verzeichnis mit VFS direkt
            Console.WriteLine("Versuche Root-Verzeichnis zu listen (0:\\)...");
            try
            {
                var entries = fs.GetDirectoryListing(@"0:\");
                Console.WriteLine($"[OK] {entries.Count} Eintraege gefunden:");
                foreach (var entry in entries)
                {
                    var type = entry.mEntryType == DirectoryEntryTypeEnum.Directory ? "DIR " : "FILE";
                    Console.WriteLine($"  [{type}] {entry.mName}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[FEHLER] Konnte Root nicht listen: {ex.Message}");
            }
            Console.WriteLine();

            Console.WriteLine("--- Filesystem bereit! ---");
            Console.WriteLine("Befehle: help, ls, mkdir, write, read, delete, info, exit");
            Console.WriteLine();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"[KRITISCHER FEHLER] VFS Init fehlgeschlagen: {ex.Message}");
        }
    }

    protected override void Run()
    {
        try
        {
            Console.Write("fs> ");
            var input = Console.ReadLine();

            if (string.IsNullOrWhiteSpace(input))
                return;

            var parts = input.Split(' ');
            var cmd = parts[0].ToLower();

            switch (cmd)
            {
                case "help":
                    ShowHelp();
                    break;

                case "ls":
                    ListDirectory(parts.Length > 1 ? parts[1] : @"0:\");
                    break;

                case "mkdir":
                    if (parts.Length > 1)
                        CreateDirectory(parts[1]);
                    else
                        Console.WriteLine("Verwendung: mkdir <pfad>");
                    break;

                case "write":
                    if (parts.Length > 2)
                        WriteFile(parts[1], string.Join(" ", parts, 2, parts.Length - 2));
                    else
                        Console.WriteLine("Verwendung: write <datei> <inhalt>");
                    break;

                case "read":
                    if (parts.Length > 1)
                        ReadFile(parts[1]);
                    else
                        Console.WriteLine("Verwendung: read <datei>");
                    break;

                case "delete":
                    if (parts.Length > 1)
                        DeleteFile(parts[1]);
                    else
                        Console.WriteLine("Verwendung: delete <datei>");
                    break;

                case "info":
                    if (parts.Length > 1)
                        ShowFileInfo(parts[1]);
                    else
                        Console.WriteLine("Verwendung: info <datei>");
                    break;

                case "exit":
                    Console.WriteLine("System wird heruntergefahren...");
                    Sys.Power.Shutdown();
                    break;

                default:
                    Console.WriteLine($"Unbekannter Befehl: {cmd}");
                    Console.WriteLine("Tippe 'help' fuer Hilfe.");
                    break;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"[FEHLER] {ex.Message}");
        }
    }

    private void ShowHelp()
    {
        Console.WriteLine("Verfuegbare Befehle:");
        Console.WriteLine("  help              - Zeigt diese Hilfe");
        Console.WriteLine("  ls [pfad]         - Listet Verzeichnisinhalt");
        Console.WriteLine("  mkdir <pfad>      - Erstellt Verzeichnis");
        Console.WriteLine("  write <datei> <t> - Schreibt Text in Datei");
        Console.WriteLine("  read <datei>      - Liest Datei");
        Console.WriteLine("  delete <datei>    - Loescht Datei");
        Console.WriteLine("  info <datei>      - Zeigt Dateiinfos");
        Console.WriteLine("  exit              - Beendet System");
    }

    private void ListDirectory(string path)
    {
        try
        {
            Console.WriteLine($"Inhalt von {path}:");

            var entries = fs.GetDirectoryListing(path);
            int dirCount = 0;
            int fileCount = 0;

            foreach (var entry in entries)
            {
                if (entry.mEntryType == DirectoryEntryTypeEnum.Directory)
                {
                    Console.WriteLine($"  [DIR]  {entry.mName}");
                    dirCount++;
                }
                else
                {
                    Console.WriteLine($"  [FILE] {entry.mName} ({entry.mSize} bytes)");
                    fileCount++;
                }
            }

            Console.WriteLine($"Gesamt: {dirCount} Ordner, {fileCount} Dateien");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Fehler: {ex.Message}");
        }
    }

    private void CreateDirectory(string path)
    {
        try
        {
            fs.CreateDirectory(path);
            Console.WriteLine($"[OK] Verzeichnis erstellt: {path}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Fehler: {ex.Message}");
        }
    }

    private void WriteFile(string path, string content)
    {
        try
        {
            var file = fs.CreateFile(path);
            var data = Encoding.ASCII.GetBytes(content);
            Console.WriteLine($"[OK] Datei geschrieben: {path} ({data.Length} bytes)");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Fehler: {ex.Message}");
        }
    }

    private void ReadFile(string path)
    {
        try
        {
            var file = fs.GetFile(path);
            var size = (int)file.mSize;
            var data = new byte[size];

            var stream = file.GetFileStream();
            stream.Read(data, 0, size);

            var content = Encoding.ASCII.GetString(data);
            Console.WriteLine($"Inhalt von {path}:");
            Console.WriteLine(content);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Fehler: {ex.Message}");
        }
    }

    private void DeleteFile(string path)
    {
        try
        {
            var entry = fs.GetFile(path);
            fs.DeleteFile(entry);
            Console.WriteLine($"[OK] Datei geloescht: {path}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Fehler: {ex.Message}");
        }
    }

    private void ShowFileInfo(string path)
    {
        try
        {
            var entry = fs.GetFile(path);
            Console.WriteLine($"Datei-Info: {path}");
            Console.WriteLine($"  Name: {entry.mName}");
            Console.WriteLine($"  Groesse: {entry.mSize} bytes");
            Console.WriteLine($"  Typ: {entry.mEntryType}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Fehler: {ex.Message}");
        }
    }
}

}`

my repo for BlyatOS is also public, so if you are curious (or somehow know the issue) you may also look there