Fix/manhunt2 persistent diagnostics

.github/workflows/build.yml

@@ -1,6 +1,6 @@
 name: build
 
-on: [push, pull_request]
+on: [push, pull_request, workflow_dispatch]
 
 jobs:
   linux-gcc-clang:
@@ -30,13 +30,15 @@ jobs:
             export CC=clang
             export CXX=clang++
           fi
-          cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS=-msse4.1 -DCMAKE_CXX_FLAGS=-msse4.1
+          cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS=-msse4.1 -DCMAKE_CXX_FLAGS=-msse4.1 -DPS2X_IOP_BUILD_TESTS=ON
 
       - name: Build
         run: cmake --build build --config Release
 
       - name: Tests
-        run: ./build/ps2xTest/ps2x_tests
+        run: |
+          ./build/ps2xTest/ps2x_tests
+          ./build/ps2xIOP/ps2_iop_import_tests
 
   windows-msvc:
     strategy:
@@ -63,13 +65,14 @@ jobs:
       - name: Build
         shell: cmd
         run: |
-          cmake -B build
+          cmake -B build -DPS2X_IOP_BUILD_TESTS=ON
           cmake --build build --config Release
 
       - name: Tests
         shell: cmd
         run: |
           .\build\ps2xTest\Release\ps2x_tests.exe
+          .\build\ps2xIOP\Release\ps2_iop_import_tests.exe
       - name: Upload artifact
         uses: actions/upload-artifact@v6
         with:

ps2xIOP/CMakeLists.txt

@@ -25,6 +25,7 @@ add_library(ps2_iop STATIC
     src/emulator/imports/iop_sysmem.cpp
     src/emulator/imports/iop_timrman.cpp
     src/emulator/imports/iop_vblank.cpp
+    src/modules/cdvdman.cpp
     src/modules/dbcman.cpp
     src/modules/libsd.cpp
     src/modules/mcserv.cpp
@@ -61,7 +62,6 @@ if(PS2X_IOP_BUILD_TESTS)
     target_link_libraries(ps2_iop_import_version_tests PRIVATE ps2_iop)
     target_include_directories(ps2_iop_import_version_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
     add_test(NAME ps2_iop_import_version_tests COMMAND ps2_iop_import_version_tests)
-
 endif()
 
 install(TARGETS ps2_iop

ps2xIOP/README.md

@@ -55,3 +55,6 @@ ctest --test-dir out/build/iop-tests --output-on-failure
 
 The suites cover IRX execution, RPC, imports, version resolution and generic
 HLE compatibility. `ps2x_tests` also covers runtime SIF RPC/DMA integration.
+
+
+The IOMAN compatibility layer currently supports read-only `open`, `close`, `read`, and `lseek` operations through the host VFS adapter. Write and directory operations are not implemented by this layer yet.

ps2xIOP/include/ps2x/iop/iop_host.h

@@ -96,7 +96,23 @@ namespace ps2x::iop
 
         virtual void audioCommand(uint32_t sid, uint32_t function, GuestBuffer send, GuestBuffer receive) = 0;
 
+        struct CdFileInfo
+        {
+            uint32_t lsn = 0u;
+            uint32_t size = 0u;
+            bool directory = false;
+            std::string name;
+        };
+
         virtual std::string hostPath(HostPathKind kind) const = 0;
+        // Resolve a CD-ROM path against the mounted disc image and return its real
+        // ISO9660 extent. Hosts without a mounted image may keep the default.
+        virtual bool findCdFile(std::string_view path, CdFileInfo &result) const
+        {
+            (void)path;
+            (void)result;
+            return false;
+        }
         virtual std::string translateGuestPath(std::string_view path) const = 0;
         virtual uint64_t openHostFile(std::string_view path) = 0;
         virtual bool hostFileSize(uint64_t handle, uint64_t &size) const = 0;

ps2xIOP/src/emulator/imports/iop_cdvd.cpp

@@ -600,11 +600,32 @@ namespace ps2x::iop::detail
                 return false;
 
             const std::string guestPath = memory.readString(nameAddress, 1024u);
+
+            // When a real ISO is mounted, return the file's actual LSN and size
+            // from its ISO9660 directory record. The old virtual-directory index
+            // describes a host folder and its synthetic LSNs do not match sectors
+            // in the mounted disc image.
+            ps2x::iop::IopHost::CdFileInfo discEntry;
+            const bool hasMountedDisc = !host.hostPath(HostPathKind::CdImage).empty();
+            if (hasMountedDisc)
+            {
+                if (!host.findCdFile(guestPath, discEntry))
+                    return false;
+
+                std::array<uint8_t, 32u> result{};
+                writeLe32(result.data(), discEntry.lsn);
+                writeLe32(result.data() + 4u, discEntry.size);
+                const std::string leaf = normalizedIsoComponent(discEntry.name);
+                std::memcpy(result.data() + 8u, leaf.data(), std::min<size_t>(16u, leaf.size()));
+                result[24u] = discEntry.directory ? 2u : 0u;
+                return memory.writeRam(resultAddress, result.data(), result.size());
+            }
+
+            // Keep the synthetic host-directory disc for non-ISO runner setups.
             IsoNode *node = findVirtualIsoNode(guestPath);
             if (!node)
                 return false;
 
-            // sceCdlFILE: lsn, size, name[16], date/flags[8].
             std::array<uint8_t, 32u> result{};
             writeLe32(result.data(), node->lsn);
             writeLe32(result.data() + 4u, node->size);

ps2xIOP/src/emulator/imports/iop_ioman.cpp

@@ -8,13 +8,19 @@
 
 namespace ps2x::iop::detail
 {
-    IopIoman::IopIoman(IopMemory &memory) noexcept
-        : m_memory(memory)
+    IopIoman::IopIoman(IopHost &host, IopMemory &memory) noexcept
+        : m_host(host), m_memory(memory)
     {
     }
 
     void IopIoman::reset()
     {
+        for (const auto &[fd, file] : m_openFiles)
+        {
+            (void)fd;
+            m_host.closeHostFile(file.hostHandle);
+        }
+        m_openFiles.clear();
         m_devices.clear();
     }
 
@@ -29,6 +35,156 @@ namespace ps2x::iop::detail
 
         switch (ordinal)
         {
+        case 4: // open
+        {
+            constexpr uint32_t kAccessModeMask = 0x0003u;
+            constexpr uint32_t kReadOnly = 0x0001u;
+            constexpr uint32_t kCreate = 0x0200u;
+            constexpr uint32_t kTruncate = 0x0400u;
+            constexpr uint32_t kExclusive = 0x0800u;
+
+            const std::string guestPath = m_memory.readString(a0, 1024u);
+            const uint32_t mode = cpu.gpr[5];
+            if (guestPath.empty() ||
+                (mode & kAccessModeMask) != kReadOnly ||
+                (mode & (kCreate | kTruncate | kExclusive)) != 0u)
+            {
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            const std::string hostPath = m_host.translateGuestPath(guestPath);
+            if (hostPath.empty())
+            {
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            const uint64_t handle = m_host.openHostFile(hostPath);
+            if (handle == 0u)
+            {
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            uint64_t size = 0u;
+            if (!m_host.hostFileSize(handle, size))
+            {
+                m_host.closeHostFile(handle);
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            int32_t fd = -1;
+            for (int32_t candidate = 3; candidate < 256; ++candidate)
+            {
+                if (m_openFiles.find(candidate) == m_openFiles.end())
+                {
+                    fd = candidate;
+                    break;
+                }
+            }
+            if (fd < 0)
+            {
+                m_host.closeHostFile(handle);
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            m_openFiles.emplace(fd, OpenFile{handle, 0u, size});
+            setV0(static_cast<uint32_t>(fd));
+            return true;
+        }
+        case 5: // close
+        {
+            const int32_t fd = static_cast<int32_t>(a0);
+            const auto file = m_openFiles.find(fd);
+            if (file == m_openFiles.end())
+            {
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            m_host.closeHostFile(file->second.hostHandle);
+            m_openFiles.erase(file);
+            setV0(0u);
+            return true;
+        }
+        case 6: // read
+        {
+            const int32_t fd = static_cast<int32_t>(a0);
+            const auto file = m_openFiles.find(fd);
+            const uint32_t destination = cpu.gpr[5];
+            const uint32_t requested = cpu.gpr[6];
+            if (file == m_openFiles.end() || requested > IopMemory::RamSize)
+            {
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+            if (requested == 0u)
+            {
+                setV0(0u);
+                return true;
+            }
+
+            std::vector<uint8_t> buffer(requested);
+            size_t bytesRead = 0u;
+            if (!m_host.readHostFile(file->second.hostHandle,
+                                     file->second.offset,
+                                     buffer.data(),
+                                     buffer.size(),
+                                     bytesRead) ||
+                bytesRead > buffer.size() ||
+                !m_memory.writeRam(destination, buffer.data(), bytesRead))
+            {
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            file->second.offset += bytesRead;
+            setV0(static_cast<uint32_t>(bytesRead));
+            return true;
+        }
+        case 8: // lseek
+        {
+            const int32_t fd = static_cast<int32_t>(a0);
+            const auto file = m_openFiles.find(fd);
+            if (file == m_openFiles.end())
+            {
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            const int32_t offset = static_cast<int32_t>(cpu.gpr[5]);
+            const uint32_t whence = cpu.gpr[6];
+            int64_t base = 0;
+            switch (whence)
+            {
+            case 0u: // SEEK_SET
+                base = 0;
+                break;
+            case 1u: // SEEK_CUR
+                base = static_cast<int64_t>(file->second.offset);
+                break;
+            case 2u: // SEEK_END
+                base = static_cast<int64_t>(file->second.size);
+                break;
+            default:
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            const int64_t newOffset = base + static_cast<int64_t>(offset);
+            if (newOffset < 0 || newOffset > 0x7FFFFFFFLL)
+            {
+                setV0(0xFFFFFFFFu);
+                return true;
+            }
+
+            file->second.offset = static_cast<uint64_t>(newOffset);
+            setV0(static_cast<uint32_t>(newOffset));
+            return true;
+        }
         case 20: // AddDrv
         {
             if (a0 == 0u || m_devices.size() >= kMaxDevices)

ps2xIOP/src/emulator/imports/iop_ioman.h

@@ -1,6 +1,9 @@
 #pragma once
 
+#include "ps2x/iop/iop_host.h"
+
 #include <cstdint>
+#include <map>
 #include <string>
 #include <vector>
 
@@ -13,7 +16,7 @@ namespace ps2x::iop::detail
     class IopIoman
     {
     public:
-        explicit IopIoman(IopMemory &memory) noexcept;
+        IopIoman(IopHost &host, IopMemory &memory) noexcept;
 
         void reset();
         [[nodiscard]] bool dispatchImport(uint16_t ordinal, IopCpuState &cpu, IopGuestExecutor &executor);
@@ -26,7 +29,16 @@ namespace ps2x::iop::detail
             std::string name;
         };
 
+        struct OpenFile
+        {
+            uint64_t hostHandle = 0u;
+            uint64_t offset = 0u;
+            uint64_t size = 0u;
+        };
+
+        IopHost &m_host;
         IopMemory &m_memory;
         std::vector<Device> m_devices;
+        std::map<int32_t, OpenFile> m_openFiles;
     };
 }

ps2xIOP/src/emulator/iop_emulator.cpp

@@ -105,7 +105,7 @@ namespace ps2x::iop::detail
               heaplib(memory),
               intrman(memory),
               timrman(),
-              ioman(memory),
+              ioman(host, memory),
               cpuCore(memory),
               imports(memory),
               loadcore(memory, imports)