fix: correct COMMAND.COM PSP[0x02] size, and DOS media ID tables segment and informations returned by DOS INT21H (#2138)

* fix: correct COMMAND.COM PSP CurrentSize to prevent TSR memory exhaustion

The DosProgramSegmentPrefix constructor was writing CurrentSize = LastFreeSegment
(0x9FFF = 40959 paragraphs) to memory on every instantiation, acting as a
destructive write rather than a pure memory view.

The fake COMMAND.COM PSP at segment 0x60 had PSP[0x02] = 0x9FFF because:
1. CreateRootCommandComPsp set it to 0x9FFF (old code)
2. Every call to `new DosProgramSegmentPrefix(memory, 0x60_address)` re-wrote
   it to 0x9FFF (even pure read wrappers)

Games like Maupiti Island read the parent (COMMAND.COM) PSP[0x02] to compute
DX for INT 21h/31h (Terminate and Stay Resident). With the buggy 0x9FFF value,
TryModifyBlock would fail (0x9E8D block < 0x9FFF requested), leaving the entire
program block allocated and no conventional memory free for subsequent allocations.

Fix:
- Remove the destructive write from DosProgramSegmentPrefix constructor: it is
  a memory view/wrapper and must not initialise fields on construction.
- Set CreateRootCommandComPsp to use a realistic value:
  CommandComSegment + PspSizeInParagraphs = 0x60 + 0x10 = 0x70
  (reflecting only the 16-paragraph PSP area, as real COMMAND.COM would have
  after releasing its extra memory before loading the game).

TDD evidence (MCP-server style ASM test):
- Before fix: parent PSP[0x02] = 0x9FFF; largest free block = 12 paragraphs
- After fix:  parent PSP[0x02] = 0x0070; largest free block = 0x9E2D paragraphs

Agent-Logs-Url: https://github.com/OpenRakis/Spice86/sessions/788b07bb-2457-4112-9e30-cbc5fa5319e4

Co-authored-by: maximilien-noal <1087524+maximilien-noal@users.noreply.github.com>

* fix: remove null-forgiving operator and clarify comment per review feedback

Agent-Logs-Url: https://github.com/OpenRakis/Spice86/sessions/788b07bb-2457-4112-9e30-cbc5fa5319e4

Co-authored-by: maximilien-noal <1087524+maximilien-noal@users.noreply.github.com>

* refactor: use Arrange/Act/Assert and share init code in TsrIntegrationTests

Agent-Logs-Url: https://github.com/OpenRakis/Spice86/sessions/3d9d957b-4161-4500-b596-c0a7316cd3d9

Co-authored-by: maximilien-noal <1087524+maximilien-noal@users.noreply.github.com>

* refactor: extract shared ResourceDir field in TsrIntegrationTests

Agent-Logs-Url: https://github.com/OpenRakis/Spice86/sessions/61eac897-87f7-4491-8a9a-5322f190d3dd

Co-authored-by: maximilien-noal <1087524+maximilien-noal@users.noreply.github.com>

* feat: implement INT 21h, AH=1Ch and related tests for drive allocation info

Co-authored-by: Copilot <copilot@github.com>

* refactor: DosTables constructor

* refactor: removed 'default!'

* refactor: streamline DOS media ID handling and improve drive manager initialization

Co-authored-by: Copilot <copilot@github.com>

* refactor: DosDriveManager initializes itself

* refactor: Removed unused field

* chore: Format DOSInt21Handler to respect java style code blocks

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: maximilien-noal <1087524+maximilien-noal@users.noreply.github.com>
Co-authored-by: Maximilien Noal <noal.maximilien@gmail.com>
Co-authored-by: Copilot <copilot@github.com>

Author: 3 people

src/Spice86.Core/Emulator/InterruptHandlers/Dos/DosInt21Handler.cs

@@ -46,6 +46,9 @@ public class DosInt21Handler : InterruptHandler {
 
     private const ushort OffsetMask = 0x0F;
     private const byte ExpectedValueOfALInCreateChildPsp = 0xF0;
+    private const ushort DefaultBytesPerSector = 0x200;
+    private const byte DefaultSectorsPerCluster = 0x20;
+    private const ushort DefaultTotalClusters = 0x7FFD;
 
     /// <summary>
     /// Initializes a new instance.
@@ -621,35 +624,74 @@ public void RemoveDirectory(bool calledFromVm) {
     }
 
     /// <summary>
-    /// Returns the bytes per sector (in CX), sectors per cluster (in AX), total clusters (in DX), media id (in DS), <br/>
-    /// and drive parameter block address for the default drive (in BX). <br/>
-    /// Sets the AH register to 0.
+    /// INT 21h, AH=1Ch - Get allocation info for a specific drive.
+    /// Returns AL=0xFF if the drive is invalid or not mounted as a block drive.
     /// </summary>
-    /// <remarks>
-    /// TODO: Implement it for real. This is just a stub that returns the same information<br/>
-    /// as <see cref="GetAllocationInfoForDefaultDrive"/> as we can only mount C: !
-    /// </remarks>
     public void GetAllocationInfoForAnyDrive() {
-        GetAllocationInfoForDefaultDrive();
+        if (!TryGetAllocationInfoDrive(State.DL, out byte driveIndex, out _)) {
+            if (LoggerService.IsEnabled(LogEventLevel.Verbose)) {
+                LoggerService.Verbose("INT 21h AH=1Ch invalid/unmounted drive request DL={DriveRequest:X2}", State.DL);
+            }
+            State.AL = 0xFF;
+            return;
+        }
+        SetAllocationInfoRegisters(driveIndex);
     }
 
     /// <summary>
-    /// Returns the bytes per sector (in CX), sectors per cluster (in AX), total clusters (in DX), media id (in DS),<br/>
-    /// and drive parameter block address for the default drive (in BX). <br/>
-    /// Sets the AH register to 0. <br/>
-    /// Notes: always returns the same values.
+    /// INT 21h, AH=1Bh - Get allocation info for the default drive.
+    /// Returns AL=0xFF if the current default drive is invalid for FAT allocation queries.
     /// </summary>
     public void GetAllocationInfoForDefaultDrive() {
-        // Bytes per sector
-        State.CX = 0x200;
-        // Sectors per cluster
-        State.AX = 1;
-        // Total clusters
-        State.DX = 0xEA0;
-        // Media Id
-        State.DS = 0x8010;
-        State.BX = (ushort)(0x8010 + _dosDriveManager.CurrentDriveIndex * 9);
+        if (!TryGetAllocationInfoDrive(0, out byte driveIndex, out _)) {
+            if (LoggerService.IsEnabled(LogEventLevel.Verbose)) {
+                LoggerService.Verbose("INT 21h AH=1Bh default drive invalid/unmounted (CurrentDriveIndex={DriveIndex})",
+                    _dosDriveManager.CurrentDriveIndex);
+            }
+            State.AL = 0xFF;
+            return;
+        }
+        SetAllocationInfoRegisters(driveIndex);
+    }
+
+    private bool TryGetAllocationInfoDrive(byte driveRequest, out byte driveIndex, out string mountedHostDirectory) {
+        mountedHostDirectory = string.Empty;
+        if (driveRequest == 0) {
+            driveIndex = _dosDriveManager.CurrentDriveIndex;
+        } else {
+            driveIndex = (byte)(driveRequest - 1);
+        }
+
+        if (driveIndex >= DosDriveManager.MaxDriveCount) {
+            return false;
+        }
+
+        char driveLetter = (char)('A' + driveIndex);
+        if (!_dosDriveManager.TryGetValue(driveLetter, out VirtualDrive? resolvedDrive) || resolvedDrive == null) {
+            return false;
+        }
+
+        if (string.IsNullOrWhiteSpace(resolvedDrive.MountedHostDirectory)) {
+            return false;
+        }
+
+        mountedHostDirectory = resolvedDrive.MountedHostDirectory;
+        return true;
+    }
+
+    private void SetAllocationInfoRegisters(byte driveIndex) {
+        State.CX = DefaultBytesPerSector;
+        State.AL = DefaultSectorsPerCluster;
         State.AH = 0;
+        State.DX = DefaultTotalClusters;
+        State.DS = _dosDriveManager.MediaIdTableSegment;
+        State.BX = _dosDriveManager.MediaIdEntryOffset(driveIndex);
+
+        if (LoggerService.IsEnabled(LogEventLevel.Verbose)) {
+            LoggerService.Verbose(
+                "INT 21h AH=1Bh/1Ch allocation info drive={DriveLetter}: AL(spc)={SectorsPerCluster:X2} CX(bps)={BytesPerSector:X4} DX(totalClusters)={TotalClusters:X4} DS:BX={Segment:X4}:{Offset:X4}",
+                (char)('A' + driveIndex), State.AL, State.CX, State.DX, State.DS, State.BX);
+        }
     }
 
     /// <summary>

src/Spice86.Core/Emulator/OperatingSystem/Dos.cs

@@ -182,17 +182,16 @@ public Dos(Configuration configuration, IMemory memory,
         _biosDataArea = biosDataArea;
         _vgaFunctionality = vgaFunctionality;
 
-        DosDriveManager = new(_loggerService, configuration.CDrive, configuration.Exe);
+        DosTables = new DosTables(memory);
+        ushort mediaIdSegment = DosTables.ReserveDosPrivateSegment((ushort)DosMediaIdTable.TableSizeInParagraphs);
+        DosMediaIdTable mediaIdTable = new(memory, MemoryUtils.ToPhysicalAddress(mediaIdSegment, 0), mediaIdSegment);
+        DosDriveManager = new(_loggerService, configuration.CDrive, configuration.Exe, mediaIdTable);
 
         VirtualFileBase[] dosDevices = AddDefaultDevices(state, keyboardInt16Handler);
         DosSysVars = new DosSysVars(configuration, (NullDevice)dosDevices[0], memory,
             MemoryUtils.ToPhysicalAddress(DosSysVars.Segment, 0x0));
 
         DosSysVars.ConsoleDeviceHeaderPointer = ((IVirtualDevice)dosDevices[1]).Header.BaseAddress;
-
-        DosTables = new DosTables();
-        DosTables.Initialize(memory);
-
         DosSysVars.CurrentDirectoryStructureListPointer = DosTables.CurrentDirectoryStructure.BaseAddress;
         DosSysVars.CurrentDirectoryStructureCount = 26;
 

src/Spice86.Core/Emulator/OperatingSystem/DosDriveManager.cs

@@ -15,25 +15,27 @@
 public class DosDriveManager : IDictionary<char, VirtualDrive> {
     private readonly SortedDictionary<char, VirtualDrive> _driveMap = new();
     private readonly Dictionary<char, MemoryDrive> _memoryDriveMap = new();
-    private readonly ILoggerService _loggerService;
+    private readonly DosMediaIdTable _mediaIdTable;
 
     /// <summary>
     /// Initializes a new instance.
     /// </summary>
     /// <param name="loggerService">The service used to log messages.</param>
     /// <param name="cDriveFolderPath">The host path to be mounted as C:.</param>
     /// <param name="executablePath">The host path to the DOS executable to be launched.</param>
-    public DosDriveManager(ILoggerService loggerService, string? cDriveFolderPath, string? executablePath) {
+    /// <param name="mediaIdTable">The DOS private-segment media ID table owned by this manager.</param>
+    public DosDriveManager(ILoggerService loggerService, string? cDriveFolderPath, string? executablePath, DosMediaIdTable mediaIdTable) {
+        _mediaIdTable = mediaIdTable;
         if (string.IsNullOrWhiteSpace(cDriveFolderPath)) {
             cDriveFolderPath = DosPathResolver.GetExeParentFolder(executablePath);
         }
-        _loggerService = loggerService;
         cDriveFolderPath = ConvertUtils.ToSlashFolderPath(cDriveFolderPath);
         _driveMap.Add('A', new() { DriveLetter = 'A', CurrentDosDirectory = "", MountedHostDirectory = "" });
         _driveMap.Add('B', new() { DriveLetter = 'B', CurrentDosDirectory = "", MountedHostDirectory = "" });
         var cDrive = new VirtualDrive { DriveLetter = 'C', MountedHostDirectory = cDriveFolderPath, CurrentDosDirectory = "" };
         _driveMap.Add('C', cDrive);
         CurrentDrive = cDrive;
+        InitializeMediaDescriptors();
         if (loggerService.IsEnabled(Serilog.Events.LogEventLevel.Verbose)) {
             loggerService.Verbose("DOS Drives initialized: {@Drives}", _driveMap.Values);
         }
@@ -86,6 +88,9 @@ internal bool HasDriveAtIndex(ushort zeroBasedIndex) {
         return true;
     }
 
+    /// <suummary>
+    /// Gets the number of DOS drive letters assigned.
+    /// </summary>
     public byte NumberOfPotentiallyValidDriveLetters {
         get {
             // At least A: and B:
@@ -106,6 +111,29 @@ public byte NumberOfPotentiallyValidDriveLetters {
 
     public const int MaxDriveCount = 26;
 
+    private const byte FloppyMediaDescriptor = 0xF0;
+    private const byte FixedDiskMediaDescriptor = 0xF8;
+
+    /// <summary>Writes the FAT media descriptor byte for every drive into the media ID table.</summary>
+    private void InitializeMediaDescriptors() {
+        for (byte driveIndex = 0; driveIndex < MaxDriveCount; driveIndex++) {
+            _mediaIdTable[driveIndex] = MediaDescriptor(driveIndex);
+        }
+    }
+
+    /// <summary>The segment of the media ID table, used as DS in AH=1Bh/1Ch returns.</summary>
+    public ushort MediaIdTableSegment => _mediaIdTable.Segment;
+
+    /// <summary>In-segment offset of the given drive's entry, used as BX in AH=1Bh/1Ch returns.</summary>
+    public ushort MediaIdEntryOffset(byte driveIndex) => _mediaIdTable.EntryOffset(driveIndex);
+
+    private byte MediaDescriptor(byte driveIndex) {
+        if (driveIndex <= 1) {
+            return FloppyMediaDescriptor;
+        }
+        return FixedDiskMediaDescriptor;
+    }
+
     public void Add(char key, VirtualDrive value) {
         ((IDictionary<char, VirtualDrive>)_driveMap).Add(key, value);
     }

src/Spice86.Core/Emulator/OperatingSystem/DosProcessManager.cs

@@ -258,7 +258,13 @@ public DosProgramSegmentPrefix CreateRootCommandComPsp() {
 
         rootPsp.Exit[0] = IntOpcode;
         rootPsp.Exit[1] = Int20TerminateNumber;
-        rootPsp.CurrentSize = DosMemoryManager.LastFreeSegment;
+        // CurrentSize reflects only the PSP itself (16 paragraphs), not all of conventional memory.
+        // Programs that read the parent (COMMAND.COM) PSP[0x02] to compute their TSR resident
+        // size (DX for INT 21h/31h) must receive a realistic small value, not LastFreeSegment
+        // (0x9FFF = 40959 decimal). Using 0x9FFF caused games like Maupiti Island to pass 0x9FFF
+        // as DX, which made TryModifyBlock fail after expanding the block to maximum, leaving
+        // all conventional memory consumed and subsequent allocations impossible.
+        rootPsp.CurrentSize = (ushort)(CommandComSegment + DosProgramSegmentPrefix.PspSizeInParagraphs);
 
         // Root PSP: parent points to itself
         rootPsp.ParentProgramSegmentPrefix = CommandComSegment;

src/Spice86.Core/Emulator/OperatingSystem/Structures/DosMediaIdTable.cs

@@ -0,0 +1,49 @@
+namespace Spice86.Core.Emulator.OperatingSystem.Structures;
+
+using Spice86.Core.Emulator.Memory.ReaderWriter;
+using Spice86.Core.Emulator.ReverseEngineer.DataStructure;
+
+/// <summary>
+/// Represents the DOS media ID table stored in the DOS private segment area.
+/// Each of the 26 possible drives has a 9-byte entry; the first byte is the FAT
+/// media descriptor returned by INT 21h AH=1Bh/1Ch via DS:BX.
+/// </summary>
+/// <remarks>
+/// The 9-byte stride matches DOSBox's DPB layout (<c>mediaid = RealMake(dpb, 0x17)</c>)
+/// where media IDs are spaced at <c>i*9</c> offsets.
+/// </remarks>
+public class DosMediaIdTable : MemoryBasedDataStructure {
+    /// <summary>Bytes per drive entry.</summary>
+    public const int EntrySize = 9;
+
+    /// <summary>Total bytes required for all 26 drive entries.</summary>
+    public const int TableSizeInBytes = 26 * EntrySize;
+
+    /// <summary>Paragraphs (16-byte blocks) required to hold the full table.</summary>
+    public const int TableSizeInParagraphs = (TableSizeInBytes + 15) / 16;
+
+    /// <summary>The segment of this table in the DOS private area.</summary>
+    public ushort Segment { get; }
+
+    /// <summary>
+    /// Initializes a new instance.
+    /// </summary>
+    /// <param name="byteReaderWriter">The memory bus.</param>
+    /// <param name="baseAddress">The physical base address of the table.</param>
+    /// <param name="segment">The segment value used to build DS:BX pointers for callers.</param>
+    public DosMediaIdTable(IByteReaderWriter byteReaderWriter, uint baseAddress, ushort segment)
+        : base(byteReaderWriter, baseAddress) {
+        Segment = segment;
+    }
+
+    /// <summary>Gets or sets the FAT media descriptor byte for the given zero-based drive index.</summary>
+    public byte this[byte driveIndex] {
+        get => UInt8[driveIndex * EntrySize];
+        set => UInt8[driveIndex * EntrySize] = value;
+    }
+
+    /// <summary>
+    /// Returns the in-segment offset of the given drive's entry, for use as BX in the DS:BX pointer.
+    /// </summary>
+    public ushort EntryOffset(byte driveIndex) => (ushort)(driveIndex * EntrySize);
+}

src/Spice86.Core/Emulator/OperatingSystem/Structures/DosProgramSegmentPrefix.cs

@@ -26,7 +26,6 @@ public sealed class DosProgramSegmentPrefix : MemoryBasedDataStructure {
     public const ushort PspSizeInParagraphs = 0x10;
 
     public DosProgramSegmentPrefix(IByteReaderWriter byteReaderWriter, uint baseAddress) : base(byteReaderWriter, baseAddress) {
-        CurrentSize = DosMemoryManager.LastFreeSegment;
     }
 
     /// <summary>

src/Spice86.Core/Emulator/OperatingSystem/Structures/DosTables.cs

@@ -24,18 +24,18 @@ public class DosTables {
     /// <summary>
     /// Gets the Current Directory Structure (CDS) for DOS drives.
     /// </summary>
-    public CurrentDirectoryStructure CurrentDirectoryStructure { get; private set; } = default!;
+    public CurrentDirectoryStructure CurrentDirectoryStructure { get; private set; }
 
     /// <summary>
     /// Gets the Double Byte Character Set (DBCS) lead-byte table.
     /// </summary>
-    public DosDoubleByteCharacterSet DoubleByteCharacterSet { get; private set; } = default!;
+    public DosDoubleByteCharacterSet DoubleByteCharacterSet { get; private set; }
 
     /// <summary>
     /// Initializes the DOS table structures in memory.
     /// </summary>
     /// <param name="memory">The memory interface to write structures to.</param>
-    public void Initialize(IByteReaderWriter memory) {
+    public DosTables(IByteReaderWriter memory) {
         uint cdsAddress = MemoryUtils.ToPhysicalAddress(MemoryMap.DosCdsSegment, 0);
         CurrentDirectoryStructure = new CurrentDirectoryStructure(memory, cdsAddress);
 

src/Spice86/Spice86DependencyInjection.cs

@@ -356,7 +356,7 @@ internal Spice86DependencyInjection(Configuration configuration, MainWindow? mai
 
         ExtendedMemoryManager? xms = null;
 
-        DosTables dosTables = new();
+        DosTables dosTables = new(memory);
 
         SharedMouseData sharedMouseData = new();