feat(libkernel): support deferred cancellation in POSIX accept

core/libs/CMakeLists.txt

@@ -488,6 +488,21 @@ if(BUILD_TESTING)
         add_test(NAME nid_elf_layout COMMAND ${Python3_EXECUTABLE}
             ${CMAKE_CURRENT_SOURCE_DIR}/nid/tests/test_elf_layout.py $<TARGET_FILE:nid_patcher>)
     endif()
+    add_test_executable(guest_kernel_sys_pwrite_tests tests/GuestKernelSysPwrite.cpp
+        nid/src/NidCompute.cpp nid/src/Sha1.cpp)
+    target_include_directories(guest_kernel_sys_pwrite_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/nid/include)
+    target_link_libraries(guest_kernel_sys_pwrite_tests PRIVATE ${CMAKE_DL_LIBS})
+    add_custom_target(guest_kernel_sys_pwrite_libraries DEPENDS
+        ${PATCHED_DIR}/libkernel_sys.prx ${PATCHED_DIR}/libkernel.prx ${LIBC_PATCHED})
+    add_dependencies(guest_kernel_sys_pwrite_tests guest_kernel_sys_pwrite_libraries)
+    configure_windows_unwind(guest_kernel_sys_pwrite_tests)
+    if(MINGW)
+        target_compile_options(guest_kernel_sys_pwrite_tests PRIVATE -fasynchronous-unwind-tables)
+        target_link_options(guest_kernel_sys_pwrite_tests PRIVATE -static -static-libgcc -static-libstdc++)
+    endif()
+    add_test(NAME guest_kernel_sys_pwrite COMMAND guest_kernel_sys_pwrite_tests ${UNPATCHED_DIR} unpatched)
+    add_test(NAME guest_kernel_sys_pwrite_patched COMMAND guest_kernel_sys_pwrite_tests ${PATCHED_DIR} patched)
+    set_tests_properties(guest_kernel_sys_pwrite guest_kernel_sys_pwrite_patched PROPERTIES TIMEOUT 20)
     add_test_executable(guest_kernel_sys_tests tests/GuestKernelSys.cpp)
     target_include_directories(guest_kernel_sys_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
     target_link_libraries(guest_kernel_sys_tests PRIVATE libkernel_sys libSceNet libSceAmpr libkernel libc)

core/libs/prx/libSceLibcInternal/UserContext.cpp

@@ -1,13 +1,15 @@
 #include "prx/libkernel/include/Api.hpp"
 #include "prx/libSceLibcInternal/include/Api.hpp"
 #include "prx/libc/include/GuestStacks.hpp"
+#include "prx/libc/include/JumpBuffer.hpp"
 #include "prx/libc/include/Shutdown.hpp"
 #include "prx/libc/include/general/VabiMacros.hpp"
 #include "prx/libkernel/System/include/UserContext.hpp"
 #include <cstdarg>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
+#include <cstring>
 
 namespace {
 
@@ -98,6 +100,8 @@ void APS5_VABI makecontext_nid_postfix(UserUcontext* context, void (APS5_VABI* s
     machine.rbx = reinterpret_cast<std::uint64_t>(stack);
     machine.rsp = reinterpret_cast<std::uint64_t>(stack);
     machine.rip = reinterpret_cast<std::uint64_t>(&Aps5MakecontextStart_nid_no_patch);
+    const auto identity = JumpBuffer::GuestContextCreate_nid_no_patch(machine.rsp);
+    std::memcpy(machine.spare, &identity, sizeof(identity));
     GuestStacks::GuestStackRegister_nid_no_patch(context->stackPointer, context->stackSize);
 }
 

core/libs/prx/libSceNet/Export.cpp

@@ -1129,14 +1129,14 @@ int APS5_VABI sceNetSocketClose(int s) {
         if (!GuestSocketIsOpen_nid_no_patch(s)) return fail(NET_EBADF);
         return close_nid_postfix(s) == 0 ? 0 : fail(*__error_nid_postfix());
     }
-    KernelReleaseSocketNumber_nid_no_patch(s);
     if (native) {
 #ifdef _WIN32
         ::shutdown(native->value, SD_BOTH);
 #else
         ::shutdown(native->value, SHUT_RDWR);
 #endif
     }
+    KernelReleaseSocketNumber_nid_no_patch(s);
     g_cv.NotifyAll();
     return 0;
 }

core/libs/prx/libSceSsl/Export.cpp

@@ -433,13 +433,14 @@ struct Session {
         auto& session = *static_cast<Session*>(argument);
         const auto chunk = static_cast<int>(std::min<std::size_t>(length, INT_MAX));
         for (;;) {
-#ifdef _WIN32
             auto* owner = static_cast<KernelSocketPoll::NativeOwner*>(session.socketOwner.get());
             const auto sent = owner && owner->transfer
                 ? owner->transfer(owner, true, const_cast<unsigned char*>(buffer), chunk)
-                : ::send(static_cast<SOCKET>(session.socket), reinterpret_cast<const char*>(buffer), chunk, 0);
+                :
+#ifdef _WIN32
+                  ::send(static_cast<SOCKET>(session.socket), reinterpret_cast<const char*>(buffer), chunk, 0);
 #else
-            const auto sent = ::send(static_cast<int>(session.socket), buffer, static_cast<std::size_t>(chunk), MSG_NOSIGNAL);
+                  ::send(static_cast<int>(session.socket), buffer, static_cast<std::size_t>(chunk), MSG_NOSIGNAL);
 #endif
             if (sent >= 0) return static_cast<int>(sent);
             const int error = HostError();
@@ -455,13 +456,14 @@ struct Session {
         auto& session = *static_cast<Session*>(argument);
         const auto chunk = static_cast<int>(std::min<std::size_t>(length, INT_MAX));
         for (;;) {
-#ifdef _WIN32
             auto* owner = static_cast<KernelSocketPoll::NativeOwner*>(session.socketOwner.get());
             const auto received = owner && owner->transfer
                 ? owner->transfer(owner, false, buffer, chunk)
-                : ::recv(static_cast<SOCKET>(session.socket), reinterpret_cast<char*>(buffer), chunk, 0);
+                :
+#ifdef _WIN32
+                  ::recv(static_cast<SOCKET>(session.socket), reinterpret_cast<char*>(buffer), chunk, 0);
 #else
-            const auto received = ::recv(static_cast<int>(session.socket), buffer, static_cast<std::size_t>(chunk), 0);
+                  ::recv(static_cast<int>(session.socket), buffer, static_cast<std::size_t>(chunk), 0);
 #endif
             if (received >= 0) return static_cast<int>(received);
             const int error = HostError();

core/libs/prx/libc/CMakeLists.txt

@@ -116,6 +116,7 @@ target_sources(libc PRIVATE
         ${CMAKE_CURRENT_SOURCE_DIR}/src/FileAndHeap.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/HostErrno.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/FileLock.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/DescriptorAccess.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/StdioExtras.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/StandardStreams.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/StreamPurge.cpp

core/libs/prx/libc/include/Api.hpp

@@ -8,6 +8,7 @@
 #include "prx/libc/include/GuestDirectory.hpp"
 #include "prx/libc/include/GuestErrno.hpp"
 #include "prx/libc/include/FileStream.hpp"
+#include "prx/libc/include/JumpBuffer.hpp"
 #include "prx/libc/include/exceptions/Unwind.hpp"
 #include "prx/libc/include/exceptions/Runtime.hpp"
 #include "prx/libc/include/LegacySignals.hpp"
@@ -1576,6 +1577,8 @@ int APS5_VABI dl_iterate_phdr_nid_postfix(int (*callback)(dl_phdr_info*, std::si
 
 [[gnu::returns_twice]] int APS5_VABI setjmp_nid_postfix(std::uint64_t* buffer);
 [[noreturn]] void APS5_VABI longjmp_nid_postfix(std::uint64_t* buffer, int value);
+[[gnu::returns_twice]] int APS5_VABI _setjmp_nid_postfix(std::uint64_t* buffer);
+[[noreturn]] void APS5_VABI _longjmp_nid_postfix(std::uint64_t* buffer, int value);
 
 std::uint8_t APS5_VABI __atomic_load_1_nid_postfix(const volatile std::uint8_t* target, int);
 std::uint16_t APS5_VABI __atomic_load_2_nid_postfix(const volatile std::uint16_t* target, int);

core/libs/prx/libc/include/DescriptorAccess.hpp

@@ -0,0 +1,123 @@
+#ifndef CORE_LIBS_PRX_LIBC_INCLUDE_DESCRIPTORACCESS_HPP
+#define CORE_LIBS_PRX_LIBC_INCLUDE_DESCRIPTORACCESS_HPP
+
+#include <memory>
+#include <mutex>
+#include <cstdint>
+#include <atomic>
+
+extern "C" {
+void FileStreamSetCloseHookForTest_nid_no_patch(void (*hook)(int, int));
+bool FileStreamCloseHookActive_nid_no_patch();
+void FileStreamCloseEventForTest_nid_no_patch(int descriptor, int event);
+void DescriptorAccessInitialize_nid_no_patch(void* access, int descriptor);
+void DescriptorAccessLock_nid_no_patch(void* access);
+bool DescriptorAccessTryLock_nid_no_patch(void* access);
+void DescriptorAccessUnlock_nid_no_patch(void* access);
+bool DescriptorAccessReadOrWait_nid_no_patch(void* access);
+void DescriptorAccessWake_nid_no_patch(void* access) noexcept;
+bool DescriptorVersionUnchanged_nid_no_patch(const void* version);
+void DescriptorAccessSnapshot_nid_no_patch(const void* access, void* version);
+void DescriptorOperationInitialize_nid_no_patch(void* operation, void* access);
+void DescriptorOperationDestroy_nid_no_patch(void* operation);
+bool DescriptorOperationInterrupted_nid_no_patch();
+void DescriptorWakeInitialize_nid_no_patch(void* registration);
+void DescriptorWakeDestroy_nid_no_patch(void* registration);
+}
+
+class GuestDescriptorAccess {
+    struct State;
+public:
+    class Version {
+    public:
+        bool Unchanged() const { return DescriptorVersionUnchanged_nid_no_patch(this); }
+    private:
+        friend class GuestDescriptorAccess;
+        friend bool DescriptorVersionUnchanged_nid_no_patch(const void* version);
+        friend void DescriptorAccessSnapshot_nid_no_patch(const void* access, void* version);
+        Version() = default;
+        std::shared_ptr<State> state;
+        std::uint64_t value = 0;
+    };
+    enum class Mode { Read, Change, Update, Close };
+    class Operation {
+    public:
+        explicit Operation(GuestDescriptorAccess& access) { DescriptorOperationInitialize_nid_no_patch(this, &access); }
+        ~Operation() { DescriptorOperationDestroy_nid_no_patch(this); }
+        Operation(const Operation&) = delete;
+        Operation& operator=(const Operation&) = delete;
+        bool Interrupted() const { return interrupted.load(); }
+        static bool CurrentInterrupted() { return DescriptorOperationInterrupted_nid_no_patch(); }
+        class WakeRegistration {
+        public:
+            WakeRegistration(void (*interrupt)(void*) noexcept, void* argument)
+                : interrupt(interrupt), argument(argument) { DescriptorWakeInitialize_nid_no_patch(this); }
+            ~WakeRegistration() { DescriptorWakeDestroy_nid_no_patch(this); }
+            WakeRegistration(const WakeRegistration&) = delete;
+            WakeRegistration& operator=(const WakeRegistration&) = delete;
+        private:
+            friend class Operation;
+            friend void DescriptorWakeInitialize_nid_no_patch(void* registration);
+            friend void DescriptorWakeDestroy_nid_no_patch(void* registration);
+            WakeRegistration* previous = nullptr;
+            Operation* operation = nullptr;
+            void (*interrupt)(void*) noexcept;
+            void* argument;
+        };
+    private:
+        friend struct State;
+        friend void DescriptorOperationInitialize_nid_no_patch(void* operation, void* access);
+        friend void DescriptorOperationDestroy_nid_no_patch(void* operation);
+        friend bool DescriptorOperationInterrupted_nid_no_patch();
+        friend void DescriptorWakeInitialize_nid_no_patch(void* registration);
+        friend void DescriptorWakeDestroy_nid_no_patch(void* registration);
+        static thread_local Operation* current;
+        std::shared_ptr<State> state;
+        Operation* previous = nullptr;
+        WakeRegistration* wake = nullptr;
+        std::atomic<bool> interrupted{false};
+        void Interrupt() noexcept;
+    };
+    GuestDescriptorAccess(int descriptor, Mode mode)
+        : GuestDescriptorAccess(descriptor, mode, std::defer_lock) { Lock(); }
+    GuestDescriptorAccess(int descriptor, Mode mode, std::defer_lock_t)
+        : mode(mode) { DescriptorAccessInitialize_nid_no_patch(this, descriptor); }
+    ~GuestDescriptorAccess() { if (held) Unlock(); }
+    GuestDescriptorAccess(const GuestDescriptorAccess&) = delete;
+    GuestDescriptorAccess& operator=(const GuestDescriptorAccess&) = delete;
+    void Lock() { DescriptorAccessLock_nid_no_patch(this); }
+    bool TryLock() { return DescriptorAccessTryLock_nid_no_patch(this); }
+    void Unlock() { DescriptorAccessUnlock_nid_no_patch(this); }
+    bool ReadOrWait() { return DescriptorAccessReadOrWait_nid_no_patch(this); }
+    void Wake() noexcept { DescriptorAccessWake_nid_no_patch(this); }
+    Version Snapshot() const {
+        Version result;
+        DescriptorAccessSnapshot_nid_no_patch(this, &result);
+        return result;
+    }
+    static void LockTogether(GuestDescriptorAccess& first, GuestDescriptorAccess& second) {
+        struct Lockable {
+            GuestDescriptorAccess& access;
+            void lock() { access.Lock(); }
+            bool try_lock() { return access.TryLock(); }
+            void unlock() { access.Unlock(); }
+        } firstLock{first}, secondLock{second};
+        std::lock(firstLock, secondLock);
+    }
+
+private:
+    friend void DescriptorAccessInitialize_nid_no_patch(void* access, int descriptor);
+    friend void DescriptorAccessLock_nid_no_patch(void* access);
+    friend bool DescriptorAccessTryLock_nid_no_patch(void* access);
+    friend void DescriptorAccessUnlock_nid_no_patch(void* access);
+    friend bool DescriptorAccessReadOrWait_nid_no_patch(void* access);
+    friend void DescriptorAccessWake_nid_no_patch(void* access) noexcept;
+    friend void DescriptorAccessSnapshot_nid_no_patch(const void* access, void* version);
+    friend void DescriptorOperationInitialize_nid_no_patch(void* operation, void* access);
+    static std::shared_ptr<State> Get(int descriptor);
+    std::shared_ptr<State> state;
+    Mode mode;
+    bool held = false;
+};
+
+#endif

core/libs/prx/libc/include/FileStream.hpp

@@ -13,6 +13,7 @@
 #include <cstdint>
 #include <cstddef>
 #include <type_traits>
+#include "prx/libc/include/DescriptorAccess.hpp"
 #ifdef _WIN32
 #include <io.h>
 #include "prx/libc/include/FileLock.hpp"
@@ -43,9 +44,9 @@ class ClosingDescriptor {
 public:
     ClosingDescriptor([[maybe_unused]] std::FILE* stream, int descriptor)
 #ifdef _WIN32
-        : _stream(stream), _closing(BeginClosingDescriptor_nid_no_patch(descriptor)) {}
+        : _stream(stream), _access(descriptor, GuestDescriptorAccess::Mode::Change), _closing(BeginClosingDescriptor_nid_no_patch(descriptor)) {}
 #else
-        : _closing(BeginClosingDescriptor_nid_no_patch(descriptor)) {}
+        : _access(descriptor, GuestDescriptorAccess::Mode::Change), _closing(BeginClosingDescriptor_nid_no_patch(descriptor)) {}
 #endif
     ~ClosingDescriptor() { EndClosingDescriptor_nid_no_patch(_closing); }
     ClosingDescriptor(const ClosingDescriptor&) = delete;
@@ -61,6 +62,7 @@ class ClosingDescriptor {
         std::FILE* stream;
     } _stream;
 #endif
+    GuestDescriptorAccess _access;
     void* _closing;
 };
 
@@ -89,7 +91,53 @@ static constexpr const char* FOPEN_MSG_OPEN_FAILED = "open failed";
 extern "C" int KeepHostStandardError_nid_no_patch();
 #endif
 
+extern "C" bool TryLockNativeStream_nid_no_patch(std::FILE* stream);
+
 class FileStream {
+    class NativeLock {
+        std::FILE* handle;
+    public:
+        explicit NativeLock(std::FILE* handle, bool closing = false) : handle(handle) {
+            if (!handle) return;
+            if (closing && FileStreamCloseHookActive_nid_no_patch()) {
+#ifdef _WIN32
+                const bool acquired = TryLockNativeStream_nid_no_patch(handle);
+                const int descriptor = ::_fileno(handle);
+#else
+                const bool acquired = ::ftrylockfile(handle) == 0;
+                const int descriptor = ::fileno(handle);
+#endif
+                FileStreamCloseEventForTest_nid_no_patch(descriptor, acquired ? 3 : 2);
+                if (acquired) return;
+            }
+#ifdef _WIN32
+            ::_lock_file(handle);
+#else
+            ::flockfile(handle);
+#endif
+        }
+        ~NativeLock() {
+            if (!handle) return;
+#ifdef _WIN32
+            ::_unlock_file(handle);
+#else
+            ::funlockfile(handle);
+#endif
+        }
+        NativeLock(const NativeLock&) = delete;
+        NativeLock& operator=(const NativeLock&) = delete;
+        void Forget() { handle = nullptr; }
+        void Retain(std::FILE* value) { handle = value; }
+        int Close() {
+#ifdef _WIN32
+            const int result = ::_fclose_nolock(handle);
+            ::_unlock_file(std::exchange(handle, nullptr));
+            return result;
+#else
+            return std::fclose(std::exchange(handle, nullptr));
+#endif
+        }
+    };
     // Only the macro-accessed FreeBSD prefix is exposed. The remaining guest
     // FILE area is reserved; host state lives beyond it and is never a guest FILE*.
     GuestFilePrefix _guest{};
@@ -217,6 +265,7 @@ class FileStream {
             return Adopt(open(filename, mode));
         }
         auto* previous = GetHandle();
+        NativeLock streamLock(previous, true);
         _guest = {};
         guestError = false;
         randomDevice = false;
@@ -234,7 +283,7 @@ class FileStream {
         if (open && !filename.empty()) {
             if (!IsHostStandard()) {
                 _handle = nullptr;
-                std::fclose(previous);
+                streamLock.Close();
                 closing.reset();
                 _handle = open(filename, mode);
             } else {
@@ -275,10 +324,13 @@ class FileStream {
         KeepStandardHandle_nid_no_patch(replaced, standard);
 #else
         if (::fileno(previous) == 2) KeepHostStandardError_nid_no_patch();
+        const bool hostStandard = IsHostStandard();
         const ClosingDescriptor closing(previous, ::fileno(previous));
         const int kept = IsHostStandard() ? DuplicateHostDescriptor_nid_no_patch(::fileno(previous)) : -1;
         if (kept >= 0) ::flockfile(previous);
+        if (!hostStandard) streamLock.Forget();
         _handle = std::freopen(filename.c_str(), mode, previous);
+        if (!hostStandard && _handle) streamLock.Retain(_handle);
         if (kept >= 0) RestoreHostStandard(previous, kept);
 #endif
         return Adopt(_handle);
@@ -438,14 +490,15 @@ class FileStream {
 
     int Close() {
         GetHandle();
+        NativeLock streamLock(_handle, true);
 #ifdef _WIN32
         GuestFileLockForget_nid_no_patch(::_fileno(_handle));
         if (std::exchange(directory, false)) ForgetDirectoryStream_nid_no_patch(::_fileno(_handle));
         const ClosingDescriptor closing(_handle, ::_fileno(_handle));
 #else
         const ClosingDescriptor closing(_handle, ::fileno(_handle));
 #endif
-        const int result = std::fclose(_handle);
+        const int result = streamLock.Close();
         _handle = nullptr;
         _guest.flags = 0;
         _guest.descriptor = -1;