feat: add 'vol' command

kernel/src/Api/BuildNo.hpp

@@ -12,4 +12,4 @@
 
 #pragma once
 
-#define MONTAUK_BUILD_NUMBER 221
+#define MONTAUK_BUILD_NUMBER 223

kernel/src/Api/Storage.hpp

@@ -57,6 +57,48 @@ namespace montauk::abi {
         return count;
     }
 
+    // Fill a user buffer with one entry per mounted volume. Returns the number
+    // of entries written, or -1 for a bad buffer.
+    static int Sys_VolInfo(VolInfo* buf, int maxCount) {
+        if (buf == nullptr || maxCount <= 0) return 0;
+        if (!UserMemory::Range((uint64_t)buf, (uint64_t)maxCount * sizeof(VolInfo), true)) return -1;
+
+        int drives[Fs::Vfs::MaxDrives];
+        int n = Fs::Vfs::VfsDriveList(drives, Fs::Vfs::MaxDrives);
+        if (n > maxCount) n = maxCount;
+
+        for (int i = 0; i < n; i++) {
+            VolInfo& v = buf[i];
+            v = VolInfo{};
+            v.drive = drives[i];
+            v.blockDev = -1;
+            v.partIndex = -1;
+
+            Fs::Vfs::VfsDriveLabel(v.drive, v.label, sizeof(v.label));
+            Fs::Vfs::VfsDriveFsType(v.drive, v.fsType, sizeof(v.fsType));
+
+            v.partIndex = Fs::FsProbe::GetPartitionForDrive(v.drive);
+            if (v.partIndex < 0) continue;   // ramdisk: no backing partition
+
+            auto* part = Drivers::Storage::Gpt::GetPartition(v.partIndex);
+            if (part == nullptr) continue;
+
+            v.blockDev = part->BlockDevIndex;
+            v.startLba = part->StartLba;
+            v.sectorCount = part->SectorCount;
+            dl_strcpy_s(v.partName, part->Name, sizeof(v.partName));
+
+            auto* dev = Drivers::Storage::GetBlockDevice(v.blockDev);
+            if (dev == nullptr) continue;
+
+            v.kind = dev->Kind;
+            v.sectorSize = dev->SectorSize;
+            dl_strcpy_s(v.model, dev->Model, sizeof(v.model));
+        }
+
+        return n;
+    }
+
     // Read sectors from a block device. Returns bytes read, or -1 on error.
     static int64_t Sys_DiskRead(int blockDev, uint64_t lba, uint32_t count, void* buffer) {
         if (buffer == nullptr || count == 0) return -1;

kernel/src/Api/Syscall.cpp

@@ -29,7 +29,7 @@
 #include "MemInfo.hpp"    // SYS_MEMSTATS
 #include "Device.hpp"     // SYS_DEVLIST, SYS_DISKINFO
 #include "Input.hpp"      // SYS_INPUT_WAIT
-#include "Storage.hpp"    // SYS_PARTLIST, SYS_DISKREAD, SYS_DISKWRITE
+#include "Storage.hpp"    // SYS_PARTLIST, SYS_VOLINFO, SYS_DISKREAD, SYS_DISKWRITE
 #include "Window.hpp"     // SYS_WINCREATE, SYS_WINDESTROY, SYS_WINPRESENT, SYS_WINPOLL, SYS_WINENUM, SYS_WINMAP, SYS_WINSENDEVENT, SYS_WINRESIZE, SYS_WINSETCURSOR, SYS_WINSETFLAGS, SYS_WINSETSCALE, SYS_WINGETSCALE
 #include "Audio.hpp"      // SYS_AUDIOOPEN, SYS_AUDIOCLOSE, SYS_AUDIOWRITE, SYS_AUDIOCTL
 #include "BluetoothSyscall.hpp" // SYS_BTSCAN, SYS_BTCONNECT, SYS_BTDISCONNECT, SYS_BTLIST, SYS_BTINFO
@@ -425,6 +425,10 @@ namespace montauk::abi {
                 if ((int64_t)frame->arg2 < 0) return -1;
                 if (!UserMemory::Range(frame->arg1, (uint64_t)frame->arg2 * sizeof(PartInfo), true)) return -1;
                 return (int64_t)Sys_PartList((PartInfo*)frame->arg1, (int)frame->arg2);
+            case SYS_VOLINFO:
+                if ((int64_t)frame->arg2 < 0) return -1;
+                if (!UserMemory::Range(frame->arg1, (uint64_t)frame->arg2 * sizeof(VolInfo), true)) return -1;
+                return (int64_t)Sys_VolInfo((VolInfo*)frame->arg1, (int)frame->arg2);
             case SYS_DISKREAD:
                 if (!Sched::HasCapability(CAP_RAW_STORAGE)) return SYS_ERR_PERMISSION;
                 return (int64_t)Sys_DiskRead((int)frame->arg1, frame->arg2,

kernel/src/Api/Syscall.hpp

@@ -349,6 +349,9 @@ namespace montauk::abi {
     /* Process.hpp -- the caller's own capability masks. */
     static constexpr uint64_t SYS_GETCAPS              = 189;  // (SpawnCapabilities*) -> 0, -1 bad pointer
 
+    /* Storage.hpp */
+    static constexpr uint64_t SYS_VOLINFO              = 190;  // (VolInfo*, maxCount) -> count, -1 bad pointer
+
     /* Kernel-owned process capabilities. User identities may namespace
        per-user resources, but never participate in authorization decisions. */
     static constexpr uint64_t CAP_PROCESS_ADMIN = 1ULL << 0;
@@ -679,6 +682,28 @@ namespace montauk::abi {
         char     typeName[24];    // human-readable type name
     };
 
+    // One mounted volume (returned by SYS_VOLINFO). A volume is a single
+    // mounted filesystem, which is what a drive number names: one physical
+    // disk with three partitions occupies three drive numbers.
+    //
+    // A volume with no backing partition -- the boot ramdisk -- reports
+    // blockDev and partIndex as -1 and leaves the geometry fields zero.
+    struct VolInfo {
+        int32_t  drive;           // VFS drive number ("N:/")
+        int32_t  blockDev;        // backing block device index, -1 if none
+        int32_t  partIndex;       // global GPT partition index, -1 if none
+        uint32_t kind;            // BlockDeviceKind: 0=none/ramdisk, 1=SATA, 2=SATAPI, 3=NVMe, 4=USB MSC
+        uint64_t startLba;        // partition start LBA, 0 if none
+        uint64_t sectorCount;     // partition length in sectors, 0 if none
+        uint32_t sectorSize;      // logical sector size in bytes, 0 if none
+        uint32_t _pad0;
+        char     label[36];       // filesystem volume label, "" if unset
+        char     fsType[12];      // "ext2", "FAT32", "ramdisk", "" if unknown
+        char     partName[72];    // GPT partition name, "" if none
+        char     model[41];       // backing disk model, "" if none
+        char     _pad1[3];
+    };
+
     struct GptAddParams {
         int32_t  blockDev;
         uint32_t _pad0;