docs: add changelog for 1.2.3

subrepo:
  subdir:   "libraries"
  merged:   "e7b84767c"
upstream:
  origin:   "https://github.com/Atmosphere-NX/Atmosphere-libs"
  branch:   "master"
  commit:   "e7b84767c"
git-subrepo:
  version:  "0.4.1"
  origin:   "???"
  commit:   "???"

Makefile

@@ -112,6 +112,7 @@ dist-no-debug: all
 	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000042
 	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000420
 	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000B240
+	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000D609
 	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000D623
 	cp stratosphere/boot2/boot2.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000008/exefs.nsp
 	cp stratosphere/dmnt/dmnt.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000000D/exefs.nsp
@@ -125,6 +126,7 @@ dist-no-debug: all
 	cp stratosphere/pgl/pgl.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000042/exefs.nsp
 	cp stratosphere/LogManager/LogManager.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000420/exefs.nsp
 	cp stratosphere/htc/htc.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000B240/exefs.nsp
+	cp stratosphere/dmnt.gen2/dmnt.gen2.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000D609/exefs.nsp
 	cp stratosphere/TioServer/TioServer.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000D623/exefs.nsp
 	@build_romfs atmosphere-$(AMSVER)/stratosphere_romfs atmosphere-$(AMSVER)/atmosphere/stratosphere.romfs
 	rm -r atmosphere-$(AMSVER)/stratosphere_romfs

docs/changelog.md

@@ -1,4 +1,32 @@
 # Changelog
+## 1.2.3
++ Because ams.TMA is taking longer to develop than expected, experimental support for Atmosphère's gdbstub as a standalone is now available.
+  + To enable it, set `atmosphere!enable_standalone_gdbstub` = u8!0x1 in system_settings.ini.
+    + The standalone also requires `atmosphere!enable_htc` = u8!0x0, but this should be the case for everyone since ams.TMA isn't actually usable yet.
+  + Once enabled, open the devkitPro provided-gdb (`aarch64-none-elf-gdb` for 64-bit or `arm-none-eabi-gdb` for 32-bit).
+    + The standalone stub exposes itself on port 22225 -- so the command to connect is `target extended-remote <ip address>:22225`.
+    + Type `info os processes` to get a list of process IDs that can be attached to.
+      + The stub should work on both system programs, games, and homebrew -- but please note that debugging certain processes (like sockets) can cause hang due to the stub using them itself.
+  + Software break-points, hardware break-points, hardware watch-points, and hardware single-step are all supported/implemented.
+  + The following monitor commands are currently supported:
+    + `monitor get info`: Get process info, address space layout, and information on modules.
+    + `monitor get mappings`: Get all memory mappings.
+    + `monitor get mapping <addr>`: Get the memory mapping for a specific address.
+    + `monitor wait application`: Causes the stub to wait for an application to be launched. The next application will be started suspended.
+      + User is expected to send `attach <pid>` after launching, which will cause attach-on-first-instruction. Failure to attach may cause system instability, this probably needs work.
+  + **Please Note**: The GDBstub is new and may have bugs/need work. If you find issues, please report them to SciresM#0524 -- all help finding/fixing bugs is appreciated, here.
+  + Generally speaking, if you would like to report information about fixes needed/discuss development of the gdbstub, join ReSwitched's #dev-support channel.
++ Changes were made to the way fs.mitm builds images when providing a layeredfs romfs.
+  + Animal Crossing's 2.0.0 update contains >99000 files, and has tables so big that we ran out of memory even after the optimizations made in 0.10.5.
+    + Previously, we used fixed-sized 0x40000 work buffers for file/directory tables and simultaneously built hash/content tables in one loop over files/directories.
+    + We now iterate over the file/directory tables multiple times, first once to determine the hash table indices, then repeatedly to build hash tables, then once to build content tables.
+    + We also now allow smaller-than-0x40000 work buffers, trying half-as-big buffers until allocation succeeds (or work buffer would be <0x4000, which is a safeguard against truly horrible performance).
+  + There is a slight speed penalty to these changes, but it's on the order of seconds for the worst case (Animal Crossing) and trivial for most games with reasonable tables.
+  + If you encounter a game that exhausts ams.mitm's memory (crashing it) when loading layeredfs mods, please contact `SciresM#0524`.
+    + It's really hard to imagine any game being worse than Animal Crossing, but if it happens again I will drop everything to fix it as usual.
++ `creport` now attempts to parse symbol tables if present.
+  + If a game executable has a symbol for a given address, the function-relative-offset will now be printed after the module-relative-offset.
++ General system stability improvements to enhance the user's experience.
 ## 1.2.2
 + A number of fixes were made to Atmosphère's implementation of the new "sprofile" service added in 13.0.0.
   + Nintendo is finally transmitting data over the internet to certain consoles, which has allowed for validating our service implementation.

libraries/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/Atmosphere-NX/Atmosphere-libs
 	branch = master
-	commit = ceff2f3712d66904747f77619cd6dc12a5dcea8b
-	parent = 6cf5205a28cfeb30930fd1cfd3c8369cd13edfa3
+	commit = e7b84767c6f3dd4c2a97fa00201342c237bf67b4
+	parent = 0bbc907907f909f67c1ba1ce89f8efb3b79b704a
 	method = merge
 	cmdver = 0.4.1

libraries/libmesosphere/include/mesosphere/kern_build_config.hpp

@@ -40,6 +40,12 @@
 /* of the right side, and so this does not actually cost any space. */
 #define MESOSPHERE_ENABLE_DEVIRTUALIZED_DYNAMIC_CAST
 
+/* NOTE: This enables usage of KDebug handles as parameter for svc::GetInfo */
+/* calls which require a process parameter. This enables a debugger to obtain */
+/* address space/layout information, for example. However, it changes abi, and so */
+/* this define allows toggling the extension. */
+#define MESOSPHERE_ENABLE_GET_INFO_OF_DEBUG_PROCESS
+
 /* NOTE: This uses currently-reserved bits inside the MapRange capability */
 /* in order to support large physical addresses (40-bit instead of 36). */
 /* This is toggleable in order to disable it if N ever uses those bits. */

libraries/libmesosphere/source/kern_k_memory_block_manager.cpp

@@ -19,7 +19,7 @@ namespace ams::kern {
 
     namespace {
 
-        constexpr std::tuple<KMemoryState, const char *> MemoryStateNames[] = {
+        constexpr const std::pair<KMemoryState, const char *> MemoryStateNames[] = {
             {KMemoryState_Free               , "----- Free -----"},
             {KMemoryState_Io                 , "Io              "},
             {KMemoryState_Static             , "Static          "},
@@ -41,6 +41,7 @@ namespace ams::kern {
             {KMemoryState_Kernel             , "Kernel          "},
             {KMemoryState_GeneratedCode      , "GeneratedCode   "},
             {KMemoryState_CodeOut            , "CodeOut         "},
+            {KMemoryState_Coverage           , "Coverage        "},
         };
 
         constexpr const char *GetMemoryStateName(KMemoryState state) {

libraries/libmesosphere/source/svc/kern_svc_info.cpp

@@ -38,6 +38,80 @@ namespace ams::kern::svc {
             return ResultSuccess();
         }
 
+        Result GetInfoImpl(u64 *out, ams::svc::InfoType info_type, KProcess *process) {
+            switch (info_type) {
+                case ams::svc::InfoType_CoreMask:
+                    *out = process->GetCoreMask();
+                    break;
+                case ams::svc::InfoType_PriorityMask:
+                    *out = process->GetPriorityMask();
+                    break;
+                case ams::svc::InfoType_AliasRegionAddress:
+                    *out = GetInteger(process->GetPageTable().GetAliasRegionStart());
+                    break;
+                case ams::svc::InfoType_AliasRegionSize:
+                    *out = process->GetPageTable().GetAliasRegionSize();
+                    break;
+                case ams::svc::InfoType_HeapRegionAddress:
+                    *out = GetInteger(process->GetPageTable().GetHeapRegionStart());
+                    break;
+                case ams::svc::InfoType_HeapRegionSize:
+                    *out = process->GetPageTable().GetHeapRegionSize();
+                    break;
+                case ams::svc::InfoType_TotalMemorySize:
+                    *out = process->GetTotalUserPhysicalMemorySize();
+                    break;
+                case ams::svc::InfoType_UsedMemorySize:
+                    *out = process->GetUsedUserPhysicalMemorySize();
+                    break;
+                case ams::svc::InfoType_AslrRegionAddress:
+                    *out = GetInteger(process->GetPageTable().GetAliasCodeRegionStart());
+                    break;
+                case ams::svc::InfoType_AslrRegionSize:
+                    *out = process->GetPageTable().GetAliasCodeRegionSize();
+                    break;
+                case ams::svc::InfoType_StackRegionAddress:
+                    *out = GetInteger(process->GetPageTable().GetStackRegionStart());
+                    break;
+                case ams::svc::InfoType_StackRegionSize:
+                    *out = process->GetPageTable().GetStackRegionSize();
+                    break;
+                case ams::svc::InfoType_SystemResourceSizeTotal:
+                    *out = process->GetTotalSystemResourceSize();
+                    break;
+                case ams::svc::InfoType_SystemResourceSizeUsed:
+                    *out = process->GetUsedSystemResourceSize();
+                    break;
+                case ams::svc::InfoType_ProgramId:
+                    *out = process->GetProgramId();
+                    break;
+                case ams::svc::InfoType_UserExceptionContextAddress:
+                    *out = GetInteger(process->GetProcessLocalRegionAddress());
+                    break;
+                case ams::svc::InfoType_TotalNonSystemMemorySize:
+                    *out = process->GetTotalNonSystemUserPhysicalMemorySize();
+                    break;
+                case ams::svc::InfoType_UsedNonSystemMemorySize:
+                    *out = process->GetUsedNonSystemUserPhysicalMemorySize();
+                    break;
+                case ams::svc::InfoType_IsApplication:
+                    *out = process->IsApplication();
+                    break;
+                case ams::svc::InfoType_FreeThreadCount:
+                    if (KResourceLimit *resource_limit = process->GetResourceLimit(); resource_limit != nullptr) {
+                        const auto current_value = resource_limit->GetCurrentValue(ams::svc::LimitableResource_ThreadCountMax);
+                        const auto limit_value   = resource_limit->GetLimitValue(ams::svc::LimitableResource_ThreadCountMax);
+                        *out = limit_value - current_value;
+                    } else {
+                        *out = 0;
+                    }
+                    break;
+                MESOSPHERE_UNREACHABLE_DEFAULT_CASE();
+            }
+
+            return ResultSuccess();
+        }
+
         Result GetInfo(u64 *out, ams::svc::InfoType info_type, ams::svc::Handle handle, u64 info_subtype) {
             switch (info_type) {
                 case ams::svc::InfoType_CoreMask:
@@ -66,77 +140,34 @@ namespace ams::kern::svc {
 
                         /* Get the process from its handle. */
                         KScopedAutoObject process = GetCurrentProcess().GetHandleTable().GetObject<KProcess>(handle);
+
+                        #if defined(MESOSPHERE_ENABLE_GET_INFO_OF_DEBUG_PROCESS)
+                        /* If we the process is valid, use it. */
+                        if (process.IsNotNull()) {
+                            return GetInfoImpl(out, info_type, process.GetPointerUnsafe());
+                        }
+
+                        /* Otherwise, as a mesosphere extension check if we were passed a usable KDebug. */
+                        KScopedAutoObject debug = GetCurrentProcess().GetHandleTable().GetObject<KDebug>(handle);
+                        R_UNLESS(debug.IsNotNull(), svc::ResultInvalidHandle());
+
+                        /* Get the process from the debug object. */
+                        /* TODO: ResultInvalidHandle()? */
+                        R_UNLESS(debug->IsAttached(),  svc::ResultProcessTerminated());
+                        R_UNLESS(debug->OpenProcess(), svc::ResultProcessTerminated());
+
+                        /* Close the process when we're done. */
+                        ON_SCOPE_EXIT { debug->CloseProcess(); };
+
+                        /* Return the info. */
+                        return GetInfoImpl(out, info_type, debug->GetProcessUnsafe());
+                        #else
+                        /* Verify that the process is valid. */
                         R_UNLESS(process.IsNotNull(), svc::ResultInvalidHandle());
 
-                        switch (info_type) {
-                            case ams::svc::InfoType_CoreMask:
-                                *out = process->GetCoreMask();
-                                break;
-                            case ams::svc::InfoType_PriorityMask:
-                                *out = process->GetPriorityMask();
-                                break;
-                            case ams::svc::InfoType_AliasRegionAddress:
-                                *out = GetInteger(process->GetPageTable().GetAliasRegionStart());
-                                break;
-                            case ams::svc::InfoType_AliasRegionSize:
-                                *out = process->GetPageTable().GetAliasRegionSize();
-                                break;
-                            case ams::svc::InfoType_HeapRegionAddress:
-                                *out = GetInteger(process->GetPageTable().GetHeapRegionStart());
-                                break;
-                            case ams::svc::InfoType_HeapRegionSize:
-                                *out = process->GetPageTable().GetHeapRegionSize();
-                                break;
-                            case ams::svc::InfoType_TotalMemorySize:
-                                *out = process->GetTotalUserPhysicalMemorySize();
-                                break;
-                            case ams::svc::InfoType_UsedMemorySize:
-                                *out = process->GetUsedUserPhysicalMemorySize();
-                                break;
-                            case ams::svc::InfoType_AslrRegionAddress:
-                                *out = GetInteger(process->GetPageTable().GetAliasCodeRegionStart());
-                                break;
-                            case ams::svc::InfoType_AslrRegionSize:
-                                *out = process->GetPageTable().GetAliasCodeRegionSize();
-                                break;
-                            case ams::svc::InfoType_StackRegionAddress:
-                                *out = GetInteger(process->GetPageTable().GetStackRegionStart());
-                                break;
-                            case ams::svc::InfoType_StackRegionSize:
-                                *out = process->GetPageTable().GetStackRegionSize();
-                                break;
-                            case ams::svc::InfoType_SystemResourceSizeTotal:
-                                *out = process->GetTotalSystemResourceSize();
-                                break;
-                            case ams::svc::InfoType_SystemResourceSizeUsed:
-                                *out = process->GetUsedSystemResourceSize();
-                                break;
-                            case ams::svc::InfoType_ProgramId:
-                                *out = process->GetProgramId();
-                                break;
-                            case ams::svc::InfoType_UserExceptionContextAddress:
-                                *out = GetInteger(process->GetProcessLocalRegionAddress());
-                                break;
-                            case ams::svc::InfoType_TotalNonSystemMemorySize:
-                                *out = process->GetTotalNonSystemUserPhysicalMemorySize();
-                                break;
-                            case ams::svc::InfoType_UsedNonSystemMemorySize:
-                                *out = process->GetUsedNonSystemUserPhysicalMemorySize();
-                                break;
-                            case ams::svc::InfoType_IsApplication:
-                                *out = process->IsApplication();
-                                break;
-                            case ams::svc::InfoType_FreeThreadCount:
-                                if (KResourceLimit *resource_limit = process->GetResourceLimit(); resource_limit != nullptr) {
-                                    const auto current_value = resource_limit->GetCurrentValue(ams::svc::LimitableResource_ThreadCountMax);
-                                    const auto limit_value   = resource_limit->GetLimitValue(ams::svc::LimitableResource_ThreadCountMax);
-                                    *out = limit_value - current_value;
-                                } else {
-                                    *out = 0;
-                                }
-                                break;
-                            MESOSPHERE_UNREACHABLE_DEFAULT_CASE();
-                        }
+                        /* Return the relevant info. */
+                        return GetInfoImpl(out, info_type, process.GetPointerUnsafe());
+                        #endif
                     }
                     break;
                 case ams::svc::InfoType_DebuggerAttached:

libraries/libstratosphere/include/stratosphere/fssystem/fssystem_utility.hpp

@@ -118,12 +118,12 @@ namespace ams::fssystem {
 
     /* Copy API. */
     Result CopyFile(fs::fsa::IFileSystem *dst_fs, fs::fsa::IFileSystem *src_fs, const char *dst_parent_path, const char *src_path, const fs::DirectoryEntry *dir_ent, void *work_buf, size_t work_buf_size);
-    NX_INLINE Result CopyFile(fs::fsa::IFileSystem *fs, const char *dst_parent_path, const char *src_path, const fs::DirectoryEntry *dir_ent, void *work_buf, size_t work_buf_size) {
+    ALWAYS_INLINE Result CopyFile(fs::fsa::IFileSystem *fs, const char *dst_parent_path, const char *src_path, const fs::DirectoryEntry *dir_ent, void *work_buf, size_t work_buf_size) {
         return CopyFile(fs, fs, dst_parent_path, src_path, dir_ent, work_buf, work_buf_size);
     }
 
     Result CopyDirectoryRecursively(fs::fsa::IFileSystem *dst_fs, fs::fsa::IFileSystem *src_fs, const char *dst_path, const char *src_path, void *work_buf, size_t work_buf_size);
-    NX_INLINE Result CopyDirectoryRecursively(fs::fsa::IFileSystem *fs, const char *dst_path, const char *src_path, void *work_buf, size_t work_buf_size) {
+    ALWAYS_INLINE Result CopyDirectoryRecursively(fs::fsa::IFileSystem *fs, const char *dst_path, const char *src_path, void *work_buf, size_t work_buf_size) {
         return CopyDirectoryRecursively(fs, fs, dst_path, src_path, work_buf, work_buf_size);
     }
 
@@ -148,11 +148,11 @@ namespace ams::fssystem {
     Result EnsureDirectoryRecursively(fs::fsa::IFileSystem *fs, const char *path);
     Result EnsureParentDirectoryRecursively(fs::fsa::IFileSystem *fs, const char *path);
 
-    template<typename F>
-    NX_INLINE Result RetryFinitelyForTargetLocked(F f) {
+    template<s64 RetryMilliSeconds = 100>
+    ALWAYS_INLINE Result RetryFinitelyForTargetLocked(auto f) {
         /* Retry up to 10 times, 100ms between retries. */
         constexpr s32 MaxRetryCount = 10;
-        constexpr TimeSpan RetryWaitTime = TimeSpan::FromMilliSeconds(100);
+        constexpr TimeSpan RetryWaitTime = TimeSpan::FromMilliSeconds(RetryMilliSeconds);
 
         s32 remaining_retries = MaxRetryCount;
         while (true) {

libraries/libstratosphere/include/stratosphere/socket/socket_api.hpp

@@ -43,6 +43,7 @@ namespace ams::socket {
 
     s32 Shutdown(s32 desc, ShutdownMethod how);
 
+    s32 Socket(Family domain, Type type, Protocol protocol);
     s32 SocketExempt(Family domain, Type type, Protocol protocol);
 
     s32 Accept(s32 desc, SockAddr *out_address, SockLenT *out_addr_len);

libraries/libstratosphere/include/stratosphere/socket/socket_system_config.hpp

@@ -57,4 +57,42 @@ namespace ams::socket {
             }
     };
 
+    class SystemConfigLightDefault : public Config {
+        public:
+            static constexpr size_t DefaultTcpInitialSendBufferSize     = 16_KB;
+            static constexpr size_t DefaultTcpInitialReceiveBufferSize  = 16_KB;
+            static constexpr size_t DefaultTcpAutoSendBufferSizeMax     = 0_KB;
+            static constexpr size_t DefaultTcpAutoReceiveBufferSizeMax  = 0_KB;
+            static constexpr size_t DefaultUdpSendBufferSize            = 9_KB;
+            static constexpr size_t DefaultUdpReceiveBufferSize         = 42240;
+            static constexpr auto   DefaultSocketBufferEfficiency       = 2;
+            static constexpr auto   DefaultConcurrency                  = 2;
+            static constexpr size_t DefaultAllocatorPoolSize            = 64_KB;
+
+            static constexpr size_t PerTcpSocketWorstCaseMemoryPoolSize = [] {
+                constexpr size_t WorstCaseTcpSendBufferSize    = AlignMss(std::max(DefaultTcpInitialSendBufferSize, DefaultTcpAutoSendBufferSizeMax));
+                constexpr size_t WorstCaseTcpReceiveBufferSize = AlignMss(std::max(DefaultTcpInitialReceiveBufferSize, DefaultTcpAutoReceiveBufferSizeMax));
+
+                return util::AlignUp(WorstCaseTcpSendBufferSize * DefaultSocketBufferEfficiency + WorstCaseTcpReceiveBufferSize * DefaultSocketBufferEfficiency, os::MemoryPageSize);
+            }();
+
+            static constexpr size_t PerUdpSocketWorstCaseMemoryPoolSize = [] {
+                constexpr size_t WorstCaseUdpSendBufferSize    = AlignMss(DefaultUdpSendBufferSize);
+                constexpr size_t WorstCaseUdpReceiveBufferSize = AlignMss(DefaultUdpReceiveBufferSize);
+
+                return util::AlignUp(WorstCaseUdpSendBufferSize * DefaultSocketBufferEfficiency + WorstCaseUdpReceiveBufferSize * DefaultSocketBufferEfficiency, os::MemoryPageSize);
+            }();
+        public:
+            constexpr SystemConfigLightDefault(void *mp, size_t mp_sz, size_t ap, int c=DefaultConcurrency)
+                : Config(mp, mp_sz, ap,
+                         DefaultTcpInitialSendBufferSize, DefaultTcpInitialReceiveBufferSize,
+                         DefaultTcpAutoSendBufferSizeMax, DefaultTcpAutoReceiveBufferSizeMax,
+                         DefaultUdpSendBufferSize, DefaultUdpReceiveBufferSize,
+                         DefaultSocketBufferEfficiency, c)
+            {
+                /* Mark as system. */
+                m_system = true;
+            }
+    };
+
 }

libraries/libstratosphere/source/boot2/boot2_api.cpp

@@ -188,6 +188,12 @@ namespace ams::boot2 {
             return enable_htc != 0;
         }
 
+        bool IsStandaloneGdbstubEnabled() {
+            u8 enable_gdbstub = 0;
+            settings::fwdbg::GetSettingsItemValue(std::addressof(enable_gdbstub), sizeof(enable_gdbstub), "atmosphere", "enable_standalone_gdbstub");
+            return enable_gdbstub != 0;
+        }
+
         bool IsAtmosphereLogManagerEnabled() {
             /* If htc is enabled, ams log manager is enabled. */
             if (IsHtcEnabled()) {
@@ -403,6 +409,9 @@ namespace ams::boot2 {
             LaunchProgram(nullptr, ncm::ProgramLocation::Make(ncm::SystemProgramId::Htc,      ncm::StorageId::None), 0);
             LaunchProgram(nullptr, ncm::ProgramLocation::Make(ncm::SystemProgramId::Cs,       ncm::StorageId::None), 0);
             LaunchProgram(nullptr, ncm::ProgramLocation::Make(ncm::SystemProgramId::DmntGen2, ncm::StorageId::None), 0);
+        } else if (IsStandaloneGdbstubEnabled()) {
+            LaunchProgram(nullptr, ncm::ProgramLocation::Make(ncm::SystemProgramId::DmntGen2, ncm::StorageId::None), 0);
+            LaunchProgram(nullptr, ncm::ProgramLocation::Make(ncm::SystemProgramId::Tma,  ncm::StorageId::BuiltInSystem), 0);
         } else {
             LaunchProgram(nullptr, ncm::ProgramLocation::Make(ncm::SystemProgramId::Dmnt, ncm::StorageId::None), 0);
             LaunchProgram(nullptr, ncm::ProgramLocation::Make(ncm::SystemProgramId::Tma,  ncm::StorageId::BuiltInSystem), 0);

libraries/libstratosphere/source/os/impl/os_thread_manager_impl.os.horizon.cpp

@@ -52,6 +52,26 @@ namespace ams::os::impl {
         /* Get the thread impl object from libnx. */
         ThreadImpl *thread_impl = ::threadGetSelf();
 
+        /* Hack around libnx's main thread, to ensure stratosphere thread type consistency. */
+        {
+            auto *tlr = reinterpret_cast<uintptr_t *>(svc::GetThreadLocalRegion());
+            for (size_t i = sizeof(svc::ThreadLocalRegion) / sizeof(uintptr_t); i > 0; --i) {
+                if (auto *candidate = reinterpret_cast<ThreadImpl *>(tlr[i - 1]); candidate == thread_impl) {
+                    ThreadImpl *embedded_thread = std::addressof(main_thread->thread_impl_storage);
+
+                    *embedded_thread = *thread_impl;
+
+                    if (embedded_thread->next) {
+                        embedded_thread->next->prev_next = std::addressof(embedded_thread->next);
+                    }
+
+                    thread_impl = embedded_thread;
+                    tlr[i-1]    = reinterpret_cast<uintptr_t>(thread_impl);
+                    break;
+                }
+            }
+        }
+
         /* Get the thread priority. */
         s32 horizon_priority;
         R_ABORT_UNLESS(svc::GetThreadPriority(std::addressof(horizon_priority), thread_impl->handle));

libraries/libstratosphere/source/osdbg/impl/osdbg_thread_local_region.os.horizon.hpp

@@ -54,7 +54,7 @@ namespace ams::osdbg::impl {
     static_assert(AMS_OFFSETOF(ThreadLocalRegionIlp32, tls) == 0x1C0);
 
     struct LibnxThreadVars {
-        static constexpr u32 Magic = util::FourCC<'!','T','V','$'>::Code;
+        static constexpr u32 Magic = util::ReverseFourCC<'!','T','V','$'>::Code;
 
         u32 magic;
         ::Handle handle;
@@ -69,11 +69,11 @@ namespace ams::osdbg::impl {
         volatile u16 disable_counter;
         volatile u16 interrupt_flag;
         u32 reserved0;
-        u64 tls[(0x1E0 - 0x108) / sizeof(u64)];
+        u64 tls[(0x200 - sizeof(LibnxThreadVars) - 0x108) / sizeof(u64)];
         LibnxThreadVars thread_vars;
     };
     static_assert(sizeof(ThreadLocalRegionLibnx) == sizeof(svc::ThreadLocalRegion));
-    static_assert(AMS_OFFSETOF(ThreadLocalRegionLibnx, thread_vars) == 0x1E0);
+    static_assert(AMS_OFFSETOF(ThreadLocalRegionLibnx, thread_vars) == 0x200 - sizeof(LibnxThreadVars));
 
     struct LibnxThreadEntryArgs {
         u64 t;

libraries/libstratosphere/source/osdbg/osdbg_thread.cpp

@@ -50,9 +50,9 @@ namespace ams::osdbg {
         } else {
             /* Special-case libnx threads. */
             if (thread_info->_thread_type_type == ThreadTypeType_Libnx) {
-                util::TSNPrintf(dst, os::ThreadNameLengthMax, "libnx Thread_0x%p", reinterpret_cast<void *>(thread_info->_thread_type));
+                util::TSNPrintf(dst, os::ThreadNameLengthMax, "libnx Thread_0x%010lx", reinterpret_cast<uintptr_t>(thread_info->_thread_type));
             } else {
-                util::TSNPrintf(dst, os::ThreadNameLengthMax, "Thread_0x%p", reinterpret_cast<void *>(thread_info->_thread_type));
+                util::TSNPrintf(dst, os::ThreadNameLengthMax, "Thread_0x%010lx", reinterpret_cast<uintptr_t>(thread_info->_thread_type));
             }
 
             return ResultSuccess();

libraries/libstratosphere/source/socket/impl/socket_api.hpp

@@ -41,6 +41,7 @@ namespace ams::socket::impl {
 
     s32 Shutdown(s32 desc, ShutdownMethod how);
 
+    s32 Socket(Family domain, Type type, Protocol protocol);
     s32 SocketExempt(Family domain, Type type, Protocol protocol);
 
     s32 Accept(s32 desc, SockAddr *out_address, SockLenT *out_addr_len);

libraries/libstratosphere/source/socket/impl/socket_api.os.horizon.cpp

@@ -206,6 +206,8 @@ namespace ams::socket::impl {
 
             /* TODO: socket::resolver::EnableResolverCalls()? Not necessary in our case (htc), but consider calling it. */
 
+            g_initialized = true;
+
             return ResultSuccess();
         }
 
@@ -422,6 +424,22 @@ namespace ams::socket::impl {
         return result;
     }
 
+    s32 Socket(Family domain, Type type, Protocol protocol) {
+        /* Check pre-conditions. */
+        AMS_ABORT_UNLESS(IsInitialized());
+
+        /* Perform the call. */
+        Errno error = Errno::ESuccess;
+        int result  = ::bsdSocket(static_cast<int>(domain), static_cast<int>(type), static_cast<int>(protocol));
+        TranslateResultToBsdError(error, result);
+
+        if (result < 0) {
+            socket::impl::SetLastError(error);
+        }
+
+        return result;
+    }
+
     s32 SocketExempt(Family domain, Type type, Protocol protocol) {
         /* Check pre-conditions. */
         AMS_ABORT_UNLESS(IsInitialized());

libraries/libstratosphere/source/socket/socket_api.cpp

@@ -74,6 +74,10 @@ namespace ams::socket {
         return impl::Shutdown(desc, how);
     }
 
+    s32 Socket(Family domain, Type type, Protocol protocol) {
+        return impl::Socket(domain, type, protocol);
+    }
+
     s32 SocketExempt(Family domain, Type type, Protocol protocol) {
         return impl::SocketExempt(domain, type, protocol);
     }

libraries/libvapours/include/vapours/ams/ams_api_version.h

@@ -17,7 +17,7 @@
 
 #define ATMOSPHERE_RELEASE_VERSION_MAJOR    1
 #define ATMOSPHERE_RELEASE_VERSION_MINOR    2
-#define ATMOSPHERE_RELEASE_VERSION_MICRO    2
+#define ATMOSPHERE_RELEASE_VERSION_MICRO    3
 
 #define ATMOSPHERE_RELEASE_VERSION ATMOSPHERE_RELEASE_VERSION_MAJOR, ATMOSPHERE_RELEASE_VERSION_MINOR, ATMOSPHERE_RELEASE_VERSION_MICRO
 

libraries/libvapours/include/vapours/util/util_string_view.hpp

@@ -201,7 +201,7 @@ namespace ams::util {
 
             constexpr size_type find(basic_string_view str, size_type pos = 0) const noexcept { return this->find(str.m_str, pos, str.m_len); }
 
-            __attribute__((nonnull(1)))
+            __attribute__((nonnull(2)))
             constexpr size_type find(const _CharT *str, size_type pos = 0) const noexcept { return this->find(str, pos, traits_type::length(str)); }
 
             constexpr size_type rfind(const _CharT *str, size_type pos, size_type n) const noexcept {
@@ -234,7 +234,7 @@ namespace ams::util {
 
             constexpr size_type rfind(basic_string_view str, size_type pos = 0) const noexcept { return this->rfind(str.m_str, pos, str.m_len); }
 
-            __attribute__((nonnull(1)))
+            __attribute__((nonnull(2)))
             constexpr size_type rfind(const _CharT *str, size_type pos = 0) const noexcept { return this->rfind(str, pos, traits_type::length(str)); }
 
             constexpr size_type find_first_of(const _CharT *str, size_type pos, size_t n) const noexcept {
@@ -249,7 +249,7 @@ namespace ams::util {
             constexpr size_type find_first_of(basic_string_view str, size_type pos = 0) const noexcept { return this->find_first_of(str.m_str, pos, str.m_len); }
             constexpr size_type find_first_of(_CharT c, size_type pos = 0) const noexcept { return this->find(c, pos); }
 
-            __attribute__((nonnull(1)))
+            __attribute__((nonnull(2)))
             constexpr size_type find_first_of(const _CharT *str, size_type pos = 0) const noexcept { return this->find_first_of(str, pos, traits_type::length(str)); }
 
             constexpr size_type find_last_of(const _CharT *str, size_type pos, size_t n) const noexcept {
@@ -270,7 +270,7 @@ namespace ams::util {
             constexpr size_type find_last_of(basic_string_view str, size_type pos = 0) const noexcept { return this->find_last_of(str.m_str, pos, str.m_len); }
             constexpr size_type find_last_of(_CharT c, size_type pos = 0) const noexcept { return this->rfind(c, pos); }
 
-            __attribute__((nonnull(1)))
+            __attribute__((nonnull(2)))
             constexpr size_type find_last_of(const _CharT *str, size_type pos = 0) const noexcept { return this->find_first_of(str, pos, traits_type::length(str)); }
 
             constexpr size_type find_first_not_of(const _CharT *str, size_type pos, size_t n) const noexcept {
@@ -293,7 +293,7 @@ namespace ams::util {
 
             constexpr size_type find_first_not_of(basic_string_view str, size_type pos = 0) const noexcept { return this->find_first_not_of(str.m_str, pos, str.m_len); }
 
-            __attribute__((nonnull(1)))
+            __attribute__((nonnull(2)))
             constexpr size_type find_first_not_of(const _CharT *str, size_type pos = 0) const noexcept { return this->find_first_not_of(str, pos, traits_type::length(str)); }
 
             constexpr size_type find_last_not_of(const _CharT *str, size_type pos, size_t n) const noexcept {
@@ -328,7 +328,7 @@ namespace ams::util {
 
             constexpr size_type find_last_not_of(basic_string_view str, size_type pos = 0) const noexcept { return this->find_last_not_of(str.m_str, pos, str.m_len); }
 
-            __attribute__((nonnull(1)))
+            __attribute__((nonnull(2)))
             constexpr size_type find_last_not_of(const _CharT *str, size_type pos = 0) const noexcept { return this->find_last_not_of(str, pos, traits_type::length(str)); }
 
             constexpr friend bool operator==(const basic_string_view &lhs, const basic_string_view &rhs) noexcept { return lhs.compare(rhs) == 0; }

stratosphere/ams_mitm/source/fs_mitm/fsmitm_romfs.cpp

@@ -64,28 +64,61 @@ namespace ams::mitm::fs {
             };
             static_assert(util::is_pod<FileEntry>::value && sizeof(FileEntry) == 0x20);
 
+            class DynamicTableCache {
+                NON_COPYABLE(DynamicTableCache);
+                NON_MOVEABLE(DynamicTableCache);
+                private:
+                    static constexpr size_t MaxCachedSize = (1_MB / 4);
+                private:
+                    size_t m_cache_bitsize;
+                protected:
+                    void *m_cache;
+                protected:
+                    DynamicTableCache(size_t sz) {
+                        size_t cache_size = util::CeilingPowerOfTwo(std::min(sz, MaxCachedSize));
+                        m_cache = std::malloc(cache_size);
+                        while (m_cache == nullptr) {
+                            cache_size >>= 1;
+                            AMS_ABORT_UNLESS(cache_size >= 16_KB);
+                        }
+                        m_cache_bitsize = util::CountTrailingZeros(cache_size);
+                    }
+
+                    ~DynamicTableCache() {
+                        std::free(m_cache);
+                    }
+
+                    ALWAYS_INLINE size_t GetCacheSize() const { return static_cast<size_t>(1) << m_cache_bitsize; }
+            };
+
+            class HashTableStorage : public DynamicTableCache {
+                public:
+                    HashTableStorage(size_t sz) : DynamicTableCache(sz) { /* ... */ }
+
+                    ALWAYS_INLINE u32 *GetBuffer() { return reinterpret_cast<u32 *>(m_cache); }
+                    ALWAYS_INLINE size_t GetBufferSize() const { return DynamicTableCache::GetCacheSize(); }
+            };
+
             template<typename Entry>
-            class TableReader {
+            class TableReader : public DynamicTableCache {
                 NON_COPYABLE(TableReader);
                 NON_MOVEABLE(TableReader);
                 private:
-                    static constexpr size_t MaxCachedSize = (1_MB / 4);
                     static constexpr size_t FallbackCacheSize = 1_KB;
                 private:
                     ams::fs::IStorage *m_storage;
                     size_t m_offset;
                     size_t m_size;
                     size_t m_cache_idx;
-                    void *m_cache;
                     u8 m_fallback_cache[FallbackCacheSize];
                 private:
                     ALWAYS_INLINE void Read(size_t ofs, void *dst, size_t size) {
                         R_ABORT_UNLESS(m_storage->Read(m_offset + ofs, dst, size));
                     }
                     ALWAYS_INLINE void ReloadCacheImpl(size_t idx) {
-                        const size_t rel_ofs = idx * MaxCachedSize;
+                        const size_t rel_ofs = idx * this->GetCacheSize();
                         AMS_ABORT_UNLESS(rel_ofs < m_size);
-                        const size_t new_cache_size = std::min(m_size - rel_ofs, MaxCachedSize);
+                        const size_t new_cache_size = std::min(m_size - rel_ofs, this->GetCacheSize());
                         this->Read(rel_ofs, m_cache, new_cache_size);
                         m_cache_idx = idx;
                     }
@@ -97,23 +130,18 @@ namespace ams::mitm::fs {
                     }
 
                     ALWAYS_INLINE size_t GetCacheIndex(u32 ofs) {
-                        return ofs / MaxCachedSize;
+                        return ofs / this->GetCacheSize();
                     }
                 public:
-                    TableReader(ams::fs::IStorage *s, size_t ofs, size_t sz) : m_storage(s), m_offset(ofs), m_size(sz), m_cache_idx(0) {
-                        m_cache = std::malloc(std::min(sz, MaxCachedSize));
+                    TableReader(ams::fs::IStorage *s, size_t ofs, size_t sz) : DynamicTableCache(sz), m_storage(s), m_offset(ofs), m_size(sz), m_cache_idx(0) {
                         AMS_ABORT_UNLESS(m_cache != nullptr);
                         this->ReloadCacheImpl(0);
                     }
 
-                    ~TableReader() {
-                        std::free(m_cache);
-                    }
-
                     const Entry *GetEntry(u32 entry_offset) {
                         this->ReloadCache(this->GetCacheIndex(entry_offset));
 
-                        const size_t ofs = entry_offset % MaxCachedSize;
+                        const size_t ofs = entry_offset % this->GetCacheSize();
 
                         const Entry *entry = reinterpret_cast<const Entry *>(reinterpret_cast<uintptr_t>(m_cache) + ofs);
                         if (AMS_UNLIKELY(this->GetCacheIndex(entry_offset) != this->GetCacheIndex(entry_offset + sizeof(Entry) + entry->name_size + sizeof(u32)))) {
@@ -125,18 +153,16 @@ namespace ams::mitm::fs {
             };
 
             template<typename Entry>
-            class TableWriter {
+            class TableWriter : public DynamicTableCache {
                 NON_COPYABLE(TableWriter);
                 NON_MOVEABLE(TableWriter);
                 private:
-                    static constexpr size_t MaxCachedSize = (1_MB / 4);
                     static constexpr size_t FallbackCacheSize = 1_KB;
                 private:
                     ::FsFile *m_file;
                     size_t m_offset;
                     size_t m_size;
                     size_t m_cache_idx;
-                    void *m_cache;
                     u8 m_fallback_cache[FallbackCacheSize];
                     size_t m_fallback_cache_entry_offset;
                     size_t m_fallback_cache_entry_size;
@@ -157,8 +183,8 @@ namespace ams::mitm::fs {
                         AMS_ABORT_UNLESS(!(m_cache_dirty && m_fallback_cache_dirty));
 
                         if (m_cache_dirty) {
-                            const size_t ofs = m_cache_idx * MaxCachedSize;
-                            this->Write(ofs, m_cache, std::min(m_size - ofs, MaxCachedSize));
+                            const size_t ofs = m_cache_idx * this->GetCacheSize();
+                            this->Write(ofs, m_cache, std::min(m_size - ofs, this->GetCacheSize()));
                             m_cache_dirty = false;
                         }
                         if (m_fallback_cache_dirty) {
@@ -168,12 +194,12 @@ namespace ams::mitm::fs {
                     }
 
                     ALWAYS_INLINE size_t GetCacheIndex(u32 ofs) {
-                        return ofs / MaxCachedSize;
+                        return ofs / this->GetCacheSize();
                     }
 
                     ALWAYS_INLINE void RefreshCacheImpl() {
-                        const size_t cur_cache = m_cache_idx * MaxCachedSize;
-                        this->Read(cur_cache, m_cache, std::min(m_size - cur_cache, MaxCachedSize));
+                        const size_t cur_cache = m_cache_idx * this->GetCacheSize();
+                        this->Read(cur_cache, m_cache, std::min(m_size - cur_cache, this->GetCacheSize()));
                     }
 
                     ALWAYS_INLINE void RefreshCache(u32 entry_offset) {
@@ -184,29 +210,27 @@ namespace ams::mitm::fs {
                         }
                     }
                 public:
-                    TableWriter(::FsFile *f, size_t ofs, size_t sz) : m_file(f), m_offset(ofs), m_size(sz), m_cache_idx(0), m_fallback_cache_entry_offset(), m_fallback_cache_entry_size(), m_cache_dirty(), m_fallback_cache_dirty() {
-                        const size_t cache_size = std::min(sz, MaxCachedSize);
-                        m_cache = std::malloc(cache_size);
+                    TableWriter(::FsFile *f, size_t ofs, size_t sz) : DynamicTableCache(sz), m_file(f), m_offset(ofs), m_size(sz), m_cache_idx(0), m_fallback_cache_entry_offset(), m_fallback_cache_entry_size(), m_cache_dirty(), m_fallback_cache_dirty() {
                         AMS_ABORT_UNLESS(m_cache != nullptr);
-                        std::memset(m_cache, 0, cache_size);
+
+                        std::memset(m_cache, 0, this->GetCacheSize());
                         std::memset(m_fallback_cache, 0, sizeof(m_fallback_cache));
-                        for (size_t cur = 0; cur < m_size; cur += MaxCachedSize) {
-                            this->Write(cur, m_cache, std::min(m_size - cur, MaxCachedSize));
+                        for (size_t cur = 0; cur < m_size; cur += this->GetCacheSize()) {
+                            this->Write(cur, m_cache, std::min(m_size - cur, this->GetCacheSize()));
                         }
                     }
 
                     ~TableWriter() {
                         this->Flush();
-                        std::free(m_cache);
                     }
 
                     Entry *GetEntry(u32 entry_offset, u32 name_len) {
                         this->RefreshCache(entry_offset);
 
-                        const size_t ofs = entry_offset % MaxCachedSize;
+                        const size_t ofs = entry_offset % this->GetCacheSize();
 
                         Entry *entry = reinterpret_cast<Entry *>(reinterpret_cast<uintptr_t>(m_cache) + ofs);
-                        if (ofs + sizeof(Entry) + util::AlignUp(name_len, sizeof(u32)) > MaxCachedSize) {
+                        if (ofs + sizeof(Entry) + util::AlignUp(name_len, sizeof(u32)) > this->GetCacheSize()) {
                             this->Flush();
 
                             m_fallback_cache_entry_offset = entry_offset;
@@ -226,7 +250,6 @@ namespace ams::mitm::fs {
             using DirectoryTableWriter = TableWriter<DirectoryEntry>;
             using FileTableWriter      = TableWriter<FileEntry>;
 
-
             constexpr inline u32 CalculatePathHash(u32 parent, const char *_path, u32 start, size_t path_len) {
                 const unsigned char *path = reinterpret_cast<const unsigned char *>(_path);
                 u32 hash = parent ^ 123456789;
@@ -526,113 +549,151 @@ namespace ams::mitm::fs {
                 }
             }
 
-            /* Populate file tables. */
-            {
-                /* Allocate the hash table. */
-                void *fht_buf = std::malloc(m_file_hash_table_size);
-                AMS_ABORT_UNLESS(fht_buf != nullptr);
-                u32 *file_hash_table = reinterpret_cast<u32 *>(fht_buf);
-                std::memset(file_hash_table, 0xFF, m_file_hash_table_size);
-                ON_SCOPE_EXIT {
-                    R_ABORT_UNLESS(fsFileWrite(std::addressof(metadata_file), m_dir_hash_table_size + m_dir_table_size, file_hash_table, m_file_hash_table_size, FsWriteOption_None));
-                    std::free(fht_buf);
-                };
+            /* Set all files' hash value = hash index. */
+            for (const auto &it : m_files) {
+                BuildFileContext *cur_file = it.get();
+                cur_file->hash_value = CalculatePathHash(cur_file->parent->entry_offset, cur_file->path.get(), 0, cur_file->path_len) % num_file_hash_table_entries;
+            }
 
-                /* Write the file table. */
-                {
-                    FileTableWriter file_table(std::addressof(metadata_file), m_dir_hash_table_size + m_dir_table_size + m_file_hash_table_size, m_file_table_size);
+            /* Set all directories' hash value = hash index. */
+            for (const auto &it : m_directories) {
+                BuildDirectoryContext *cur_dir = it.get();
+                cur_dir->hash_value = CalculatePathHash(cur_dir == m_root ? 0 : cur_dir->parent->entry_offset, cur_dir->path.get(), 0, cur_dir->path_len) % num_dir_hash_table_entries;
+            }
+
+            /* Write hash tables. */
+            {
+                HashTableStorage hash_table_storage(std::max(m_dir_hash_table_size, m_file_hash_table_size));
+
+                u32 *hash_table = hash_table_storage.GetBuffer();
+                size_t hash_table_size = hash_table_storage.GetBufferSize();
+
+                /* Write the file hash table. */
+                for (size_t ofs = 0; ofs < m_file_hash_table_size; ofs += hash_table_size) {
+                    std::memset(hash_table, 0xFF, hash_table_size);
+
+                    const u32 ofs_ind = ofs / sizeof(u32);
+                    const u32 end_ind = (ofs + hash_table_size) / sizeof(u32);
 
                     for (const auto &it : m_files) {
                         BuildFileContext *cur_file = it.get();
-                        FileEntry *cur_entry = file_table.GetEntry(cur_file->entry_offset, cur_file->path_len);
+                        if (cur_file->HasHashMark()) {
+                            continue;
+                        }
 
-                        /* Set entry fields. */
-                        cur_entry->parent = cur_file->parent->entry_offset;
-                        cur_entry->sibling = (cur_file->sibling == nullptr) ? EmptyEntry : cur_file->sibling->entry_offset;
-                        cur_entry->offset = cur_file->offset;
-                        cur_entry->size = cur_file->size;
+                        if (const auto hash_ind = cur_file->hash_value; ofs_ind <= hash_ind && hash_ind < end_ind) {
+                            cur_file->hash_value = hash_table[hash_ind - ofs_ind];
+                            hash_table[hash_ind - ofs_ind] = cur_file->entry_offset;
 
-                        /* Insert into hash table. */
-                        const u32 name_size = cur_file->path_len;
-                        const size_t hash_ind = CalculatePathHash(cur_entry->parent, cur_file->path.get(), 0, name_size) % num_file_hash_table_entries;
-                        cur_entry->hash = file_hash_table[hash_ind];
-                        file_hash_table[hash_ind] = cur_file->entry_offset;
+                            cur_file->SetHashMark();
+                        }
+                    }
 
-                        /* Set name. */
-                        cur_entry->name_size = name_size;
-                        if (name_size) {
-                            std::memcpy(cur_entry->name, cur_file->path.get(), name_size);
-                            for (size_t i = name_size; i < util::AlignUp(name_size, 4); i++) {
-                                cur_entry->name[i] = 0;
+                    R_ABORT_UNLESS(fsFileWrite(std::addressof(metadata_file), m_dir_hash_table_size + m_dir_table_size + ofs, hash_table, std::min(m_file_hash_table_size - ofs, hash_table_size), FsWriteOption_None));
+                }
+
+                /* Write the directory hash table. */
+                for (size_t ofs = 0; ofs < m_dir_hash_table_size; ofs += hash_table_size) {
+                    std::memset(hash_table, 0xFF, hash_table_size);
+
+                    const u32 ofs_ind = ofs / sizeof(u32);
+                    const u32 end_ind = (ofs + hash_table_size) / sizeof(u32);
+
+                    for (const auto &it : m_directories) {
+                        BuildDirectoryContext *cur_dir = it.get();
+                        if (cur_dir->HasHashMark()) {
+                            continue;
+                        }
+
+                        if (const auto hash_ind = cur_dir->hash_value; ofs_ind <= hash_ind && hash_ind < end_ind) {
+                            cur_dir->hash_value = hash_table[hash_ind - ofs_ind];
+                            hash_table[hash_ind - ofs_ind] = cur_dir->entry_offset;
+
+                            cur_dir->SetHashMark();
+                        }
+                    }
+
+                    R_ABORT_UNLESS(fsFileWrite(std::addressof(metadata_file), ofs, hash_table, std::min(m_dir_hash_table_size - ofs, hash_table_size), FsWriteOption_None));
+                }
+            }
+
+            /* Write the file table. */
+            {
+                FileTableWriter file_table(std::addressof(metadata_file), m_dir_hash_table_size + m_dir_table_size + m_file_hash_table_size, m_file_table_size);
+
+                for (const auto &it : m_files) {
+                    BuildFileContext *cur_file = it.get();
+                    FileEntry *cur_entry = file_table.GetEntry(cur_file->entry_offset, cur_file->path_len);
+
+                    cur_file->ClearHashMark();
+
+                    /* Set entry fields. */
+                    cur_entry->parent  = cur_file->parent->entry_offset;
+                    cur_entry->sibling = (cur_file->sibling == nullptr) ? EmptyEntry : cur_file->sibling->entry_offset;
+                    cur_entry->offset  = cur_file->offset;
+                    cur_entry->size    = cur_file->size;
+                    cur_entry->hash    = cur_file->hash_value;
+
+                    /* Set name. */
+                    const u32 name_size = cur_file->path_len;
+                    cur_entry->name_size = name_size;
+                    if (name_size) {
+                        std::memcpy(cur_entry->name, cur_file->path.get(), name_size);
+                        for (size_t i = name_size; i < util::AlignUp(name_size, 4); i++) {
+                            cur_entry->name[i] = 0;
+                        }
+                    }
+
+                    /* Emplace a source. */
+                    switch (cur_file->source_type) {
+                        case DataSourceType::Storage:
+                        case DataSourceType::File:
+                            {
+                                /* Try to compact if possible. */
+                                auto &back = out_infos->back();
+                                if (back.source_type == cur_file->source_type) {
+                                    back.size = cur_file->offset + FilePartitionOffset + cur_file->size - back.virtual_offset;
+                                } else {
+                                    out_infos->emplace_back(cur_file->offset + FilePartitionOffset, cur_file->size, cur_file->source_type, cur_file->orig_offset + FilePartitionOffset);
+                                }
                             }
-                        }
-
-                        /* Emplace a source. */
-                        switch (cur_file->source_type) {
-                            case DataSourceType::Storage:
-                            case DataSourceType::File:
-                                {
-                                    /* Try to compact if possible. */
-                                    auto &back = out_infos->back();
-                                    if (back.source_type == cur_file->source_type) {
-                                        back.size = cur_file->offset + FilePartitionOffset + cur_file->size - back.virtual_offset;
-                                    } else {
-                                        out_infos->emplace_back(cur_file->offset + FilePartitionOffset, cur_file->size, cur_file->source_type, cur_file->orig_offset + FilePartitionOffset);
-                                    }
-                                }
-                                break;
-                            case DataSourceType::LooseSdFile:
-                                {
-                                    char *new_path = new char[cur_file->GetPathLength() + 1];
-                                    cur_file->GetPath(new_path);
-                                    out_infos->emplace_back(cur_file->offset + FilePartitionOffset, cur_file->size, cur_file->source_type, new_path);
-                                }
-                                break;
-                            AMS_UNREACHABLE_DEFAULT_CASE();
-                        }
+                            break;
+                        case DataSourceType::LooseSdFile:
+                            {
+                                char *new_path = new char[cur_file->GetPathLength() + 1];
+                                cur_file->GetPath(new_path);
+                                out_infos->emplace_back(cur_file->offset + FilePartitionOffset, cur_file->size, cur_file->source_type, new_path);
+                            }
+                            break;
+                        AMS_UNREACHABLE_DEFAULT_CASE();
                     }
                 }
             }
 
-            /* Populate directory tables. */
+            /* Write the directory table. */
             {
-                /* Allocate the hash table. */
-                void *dht_buf = std::malloc(m_dir_hash_table_size);
-                AMS_ABORT_UNLESS(dht_buf != nullptr);
-                u32 *dir_hash_table = reinterpret_cast<u32 *>(dht_buf);
-                std::memset(dir_hash_table, 0xFF, m_dir_hash_table_size);
-                ON_SCOPE_EXIT {
-                    R_ABORT_UNLESS(fsFileWrite(std::addressof(metadata_file), 0, dir_hash_table, m_dir_hash_table_size, FsWriteOption_None));
-                    std::free(dht_buf);
-                };
+                DirectoryTableWriter dir_table(std::addressof(metadata_file), m_dir_hash_table_size, m_dir_table_size);
 
-                /* Write the file table. */
-                {
-                    DirectoryTableWriter dir_table(std::addressof(metadata_file), m_dir_hash_table_size, m_dir_table_size);
+                for (const auto &it : m_directories) {
+                    BuildDirectoryContext *cur_dir = it.get();
+                    DirectoryEntry *cur_entry = dir_table.GetEntry(cur_dir->entry_offset, cur_dir->path_len);
 
-                    for (const auto &it : m_directories) {
-                        BuildDirectoryContext *cur_dir = it.get();
-                        DirectoryEntry *cur_entry = dir_table.GetEntry(cur_dir->entry_offset, cur_dir->path_len);
+                    cur_dir->ClearHashMark();
 
-                        /* Set entry fields. */
-                        cur_entry->parent = cur_dir == m_root ? 0 : cur_dir->parent->entry_offset;
-                        cur_entry->sibling = (cur_dir->sibling == nullptr) ? EmptyEntry : cur_dir->sibling->entry_offset;
-                        cur_entry->child   = (cur_dir->child   == nullptr) ? EmptyEntry : cur_dir->child->entry_offset;
-                        cur_entry->file    = (cur_dir->file    == nullptr) ? EmptyEntry : cur_dir->file->entry_offset;
+                    /* Set entry fields. */
+                    cur_entry->parent  = cur_dir == m_root ? 0 : cur_dir->parent->entry_offset;
+                    cur_entry->sibling = (cur_dir->sibling == nullptr) ? EmptyEntry : cur_dir->sibling->entry_offset;
+                    cur_entry->child   = (cur_dir->child   == nullptr) ? EmptyEntry : cur_dir->child->entry_offset;
+                    cur_entry->file    = (cur_dir->file    == nullptr) ? EmptyEntry : cur_dir->file->entry_offset;
+                    cur_entry->hash    = cur_dir->hash_value;
 
-                        /* Insert into hash table. */
-                        const u32 name_size = cur_dir->path_len;
-                        const size_t hash_ind = CalculatePathHash(cur_entry->parent, cur_dir->path.get(), 0, name_size) % num_dir_hash_table_entries;
-                        cur_entry->hash = dir_hash_table[hash_ind];
-                        dir_hash_table[hash_ind] = cur_dir->entry_offset;
-
-                        /* Set name. */
-                        cur_entry->name_size = name_size;
-                        if (name_size) {
-                            std::memcpy(cur_entry->name, cur_dir->path.get(), name_size);
-                            for (size_t i = name_size; i < util::AlignUp(name_size, 4); i++) {
-                                cur_entry->name[i] = 0;
-                            }
+                    /* Set name. */
+                    const u32 name_size = cur_dir->path_len;
+                    cur_entry->name_size = name_size;
+                    if (name_size) {
+                        std::memcpy(cur_entry->name, cur_dir->path.get(), name_size);
+                        for (size_t i = name_size; i < util::AlignUp(name_size, 4); i++) {
+                            cur_entry->name[i] = 0;
                         }
                     }
                 }

stratosphere/ams_mitm/source/fs_mitm/fsmitm_romfs.hpp

@@ -19,7 +19,7 @@
 
 namespace ams::mitm::fs::romfs {
 
-    enum class DataSourceType {
+    enum class DataSourceType : u8 {
         Storage,
         File,
         LooseSdFile,
@@ -120,10 +120,11 @@ namespace ams::mitm::fs::romfs {
         BuildFileContext *file;
         u32 path_len;
         u32 entry_offset;
+        u32 hash_value;
 
         struct RootTag{};
 
-        BuildDirectoryContext(RootTag) : parent(nullptr), child(nullptr), sibling(nullptr), file(nullptr), path_len(0), entry_offset(0) {
+        BuildDirectoryContext(RootTag) : parent(nullptr), child(nullptr), sibling(nullptr), file(nullptr), path_len(0), entry_offset(0), hash_value(0xFFFFFFFF) {
             this->path = std::make_unique<char[]>(1);
         }
 
@@ -154,6 +155,18 @@ namespace ams::mitm::fs::romfs {
             dst[parent_len + 1 + this->path_len] = '\x00';
             return parent_len + 1 + this->path_len;
         }
+
+        bool HasHashMark() const {
+            return reinterpret_cast<uintptr_t>(this->sibling) & UINT64_C(0x8000000000000000);
+        }
+
+        void SetHashMark() {
+            this->sibling = reinterpret_cast<BuildDirectoryContext *>(reinterpret_cast<uintptr_t>(this->sibling) | UINT64_C(0x8000000000000000));
+        }
+
+        void ClearHashMark() {
+            this->sibling = reinterpret_cast<BuildDirectoryContext *>(reinterpret_cast<uintptr_t>(this->sibling) & ~UINT64_C(0x8000000000000000));
+        }
     };
 
     struct BuildFileContext {
@@ -168,9 +181,10 @@ namespace ams::mitm::fs::romfs {
         s64 orig_offset;
         u32 path_len;
         u32 entry_offset;
+        u32 hash_value;
         DataSourceType source_type;
 
-        BuildFileContext(const char *entry_name, size_t entry_name_len, s64 sz, s64 o_o, DataSourceType type) : parent(nullptr), sibling(nullptr), offset(0), size(sz), orig_offset(o_o), entry_offset(0), source_type(type) {
+        BuildFileContext(const char *entry_name, size_t entry_name_len, s64 sz, s64 o_o, DataSourceType type) : parent(nullptr), sibling(nullptr), offset(0), size(sz), orig_offset(o_o), entry_offset(0), hash_value(0xFFFFFFFF), source_type(type) {
             this->path_len = entry_name_len;
             this->path = std::unique_ptr<char[]>(new char[this->path_len + 1]);
             std::memcpy(this->path.get(), entry_name, entry_name_len);
@@ -197,6 +211,18 @@ namespace ams::mitm::fs::romfs {
             dst[parent_len + 1 + this->path_len] = '\x00';
             return parent_len + 1 + this->path_len;
         }
+
+        bool HasHashMark() const {
+            return reinterpret_cast<uintptr_t>(this->sibling) & UINT64_C(0x8000000000000000);
+        }
+
+        void SetHashMark() {
+            this->sibling = reinterpret_cast<BuildFileContext *>(reinterpret_cast<uintptr_t>(this->sibling) | UINT64_C(0x8000000000000000));
+        }
+
+        void ClearHashMark() {
+            this->sibling = reinterpret_cast<BuildFileContext *>(reinterpret_cast<uintptr_t>(this->sibling) & ~UINT64_C(0x8000000000000000));
+        }
     };
 
     class DirectoryTableReader;

stratosphere/ams_mitm/source/set_mitm/settings_sd_kvs.cpp

@@ -378,6 +378,12 @@ namespace ams::settings::fwdbg {
             /* 0 = Disabled, 1 = Enabled */
             R_ABORT_UNLESS(ParseSettingsItemValue("atmosphere", "enable_htc", "u8!0x0"));
 
+            /* Controls whether atmosphere's dmnt.gen2 gdbstub should run as a standalone via sockets. */
+            /* Note that this setting is ignored (and treated as 0) when htc is enabled. */
+            /* Note that this setting may disappear in the future. */
+            /* 0 = Disabled, 1 = Enabled */
+            R_ABORT_UNLESS(ParseSettingsItemValue("atmosphere", "enable_standalone_gdbstub", "u8!0x0"));
+
             /* Controls whether atmosphere's log manager is enabled. */
             /* Note that this setting is ignored (and treated as 1) when htc is enabled. */
             /* 0 = Disabled, 1 = Enabled */

stratosphere/creport/source/creport_modules.cpp

@@ -27,7 +27,7 @@ namespace ams::creport {
 
         struct ModulePath {
             u32  zero;
-            u32  path_length;
+            s32  path_length;
             char path[ModulePathLengthMax];
         };
         static_assert(sizeof(ModulePath) == 0x208, "ModulePath definition!");
@@ -210,7 +210,7 @@ namespace ams::creport {
             }
 
             /* Also validate that we're looking at a valid name. */
-            if (rodata_start.module_path.zero != 0 || rodata_start.module_path.path_length != strnlen(rodata_start.module_path.path, sizeof(rodata_start.module_path.path))) {
+            if (rodata_start.module_path.zero != 0 || rodata_start.module_path.path_length <= 0) {
                 return;
             }
         }
@@ -219,7 +219,7 @@ namespace ams::creport {
         /* Start after last slash in path. */
         const char *path = rodata_start.module_path.path;
         int ofs;
-        for (ofs = rodata_start.module_path.path_length; ofs >= 0; ofs--) {
+        for (ofs = std::min<size_t>(rodata_start.module_path.path_length, sizeof(rodata_start.module_path.path)); ofs >= 0; ofs--) {
             if (path[ofs] == '/' || path[ofs] == '\\') {
                 break;
             }
@@ -227,8 +227,8 @@ namespace ams::creport {
         ofs++;
 
         /* Copy name to output. */
-        const size_t name_size = std::min(ModuleNameLengthMax, sizeof(rodata_start.module_path.path) - ofs);
-        std::strncpy(out_name, path + ofs, name_size);
+        const size_t name_size = std::min(ModuleNameLengthMax, std::min<size_t>(rodata_start.module_path.path_length, sizeof(rodata_start.module_path.path)) - ofs);
+        std::memcpy(out_name, path + ofs, name_size);
         out_name[ModuleNameLengthMax - 1] = '\x00';
     }
 

stratosphere/dmnt.gen2/dmnt.gen2.json

@@ -15,7 +15,7 @@
 	"filesystem_access":	{
 		"permissions":	"0xFFFFFFFFFFFFFFFF"
 	},
-	"service_access":	["pm:dmnt", "ldr:dmnt", "ro:dmnt", "ns:dev", "lr", "fsp-srv", "fatal:u", "pgl", "htcs"],
+	"service_access":	["pm:dmnt", "ldr:dmnt", "ro:dmnt", "ns:dev", "lr", "fsp-srv", "fatal:u", "pgl", "htcs", "bsd:s", "set:sys"],
 	"service_host":	[],
 	"kernel_capabilities":	[{
 			"type":	"kernel_flags",

stratosphere/dmnt.gen2/source/dmnt2_debug_log.cpp

@@ -16,7 +16,8 @@
 #include <stratosphere.hpp>
 #include "dmnt2_debug_log.hpp"
 
-#define AMS_DMNT2_ENABLE_HTCS_DEBUG_LOG
+// TODO: This should be converted to use log manager. */
+//#define AMS_DMNT2_ENABLE_HTCS_DEBUG_LOG
 
 #if defined(AMS_DMNT2_ENABLE_HTCS_DEBUG_LOG)
 
@@ -164,15 +165,78 @@ namespace ams::dmnt {
 
 namespace ams::dmnt {
 
+    //#define AMS_DMNT2_ENABLE_SD_CARD_DEBUG_LOG
+
+    #if defined(AMS_DMNT2_ENABLE_SD_CARD_DEBUG_LOG)
+
+    namespace {
+
+        alignas(0x40) constinit u8 g_buffer[os::MemoryPageSize * 4];
+        constinit lmem::HeapHandle g_debug_log_heap;
+        constinit fs::FileHandle g_debug_log_file;
+
+        constinit os::SdkMutex g_fs_mutex;
+        constinit s64 g_fs_offset = 0;
+
+        void *Allocate(size_t size) {
+            return lmem::AllocateFromExpHeap(g_debug_log_heap, size);
+        }
+
+        void Deallocate(void *p, size_t size) {
+            AMS_UNUSED(size);
+            return lmem::FreeToExpHeap(g_debug_log_heap, p);
+        }
+
+    }
 
     void InitializeDebugLog() {
-        /* Do nothing. */
+        g_debug_log_heap = lmem::CreateExpHeap(g_buffer, sizeof(g_buffer), lmem::CreateOption_ThreadSafe);
+
+        fs::SetAllocator(Allocate, Deallocate);
+        fs::InitializeForSystem();
+        fs::SetEnabledAutoAbort(false);
+
+        R_ABORT_UNLESS(fs::MountSdCard("sdmc"));
+
+        fs::DeleteFile("sdmc:/dmnt2.log");
+        R_ABORT_UNLESS(fs::CreateFile("sdmc:/dmnt2.log", 0));
+        R_ABORT_UNLESS(fs::OpenFile(std::addressof(g_debug_log_file), "sdmc:/dmnt2.log", fs::OpenMode_Write | fs::OpenMode_AllowAppend));
     }
 
     void DebugLog(const char *prefix, const char *fmt, ...) {
         /* Do nothing. */
+        char buffer[0x200];
+        {
+            const auto prefix_len = std::strlen(prefix);
+            std::memcpy(buffer, prefix, prefix_len);
+
+            std::va_list vl;
+            va_start(vl, fmt);
+            util::VSNPrintf(buffer + prefix_len, sizeof(buffer) - prefix_len, fmt, vl);
+            va_end(vl);
+        }
+
+        const auto len = std::strlen(buffer);
+
+        std::scoped_lock lk(g_fs_mutex);
+        R_ABORT_UNLESS(fs::WriteFile(g_debug_log_file, g_fs_offset, buffer, len, fs::WriteOption::Flush));
+        g_fs_offset += len;
     }
 
+    #else
+
+    void InitializeDebugLog() {
+        /* ... */
+    }
+
+    void DebugLog(const char *prefix, const char *fmt, ...) {
+        AMS_UNUSED(prefix, fmt);
+    }
+
+    #endif
+
+
+
 }
 
 

stratosphere/dmnt.gen2/source/dmnt2_debug_process.cpp

@@ -27,10 +27,15 @@ namespace ams::dmnt {
 
     }
 
-    Result DebugProcess::Attach(os::ProcessId process_id) {
+    Result DebugProcess::Attach(os::ProcessId process_id, bool start_process) {
         /* Attach to the process. */
         R_TRY(svc::DebugActiveProcess(std::addressof(m_debug_handle), process_id.value));
 
+        /* If necessary, start the process. */
+        if (start_process) {
+            R_ABORT_UNLESS(pm::dmnt::StartProcess(process_id));
+        }
+
         /* Collect initial information. */
         R_TRY(this->Start());
 
@@ -42,6 +47,10 @@ namespace ams::dmnt {
         svc::GetProcessId(std::addressof(pid_value), m_debug_handle);
 
         m_process_id = { pid_value };
+
+        /* Get process info. */
+        this->CollectProcessInfo();
+
         return ResultSuccess();
     }
 
@@ -187,13 +196,25 @@ namespace ams::dmnt {
                         char path[ModuleDefinition::PathLengthMax];
                     } module_path;
                     if (R_SUCCEEDED(this->ReadMemory(std::addressof(module_path), memory_info.base_address + memory_info.size, sizeof(module_path)))) {
-                        if (module_path.zero == 0 && module_path.path_length == util::Strnlen(module_path.path, sizeof(module_path.path))) {
-                            std::memcpy(module_name, module_path.path, ModuleDefinition::PathLengthMax);
+                        if (module_path.zero == 0 && module_path.path_length > 0) {
+                            std::memcpy(module_name, module_path.path, std::min<size_t>(ModuleDefinition::PathLengthMax, module_path.path_length));
                         }
+                    } else {
+                        module_path.path_length = 0;
                     }
 
                     /* Truncate module name. */
                     module_name[ModuleDefinition::PathLengthMax - 1] = 0;
+
+                    /* Set default module name start. */
+                    module.SetNameStart(0);
+
+                    /* Ignore leading directories. */
+                    for (size_t i = 0; i < std::min<size_t>(ModuleDefinition::PathLengthMax, module_path.path_length) && module_name[i] != 0; ++i) {
+                        if (module_name[i] == '/' || module_name[i] == '\\') {
+                            module.SetNameStart(i + 1);
+                        }
+                    }
                 }
             }
 
@@ -212,6 +233,53 @@ namespace ams::dmnt {
         return ResultSuccess();
     }
 
+    void DebugProcess::CollectProcessInfo() {
+        /* Define helper for getting process info. */
+        auto CollectProcessInfoImpl = [&](os::NativeHandle handle) -> Result {
+            /* Collect all values. */
+            R_TRY(svc::GetInfo(std::addressof(m_process_alias_address), svc::InfoType_AliasRegionAddress, handle, 0));
+            R_TRY(svc::GetInfo(std::addressof(m_process_alias_size),    svc::InfoType_AliasRegionSize,    handle, 0));
+            R_TRY(svc::GetInfo(std::addressof(m_process_heap_address),  svc::InfoType_HeapRegionAddress,  handle, 0));
+            R_TRY(svc::GetInfo(std::addressof(m_process_heap_size),     svc::InfoType_HeapRegionSize,     handle, 0));
+            R_TRY(svc::GetInfo(std::addressof(m_process_aslr_address),  svc::InfoType_AslrRegionAddress,  handle, 0));
+            R_TRY(svc::GetInfo(std::addressof(m_process_aslr_size),     svc::InfoType_AslrRegionSize,     handle, 0));
+            R_TRY(svc::GetInfo(std::addressof(m_process_stack_address), svc::InfoType_StackRegionAddress, handle, 0));
+            R_TRY(svc::GetInfo(std::addressof(m_process_stack_size),    svc::InfoType_StackRegionSize,    handle, 0));
+
+            if (m_program_location.program_id == ncm::InvalidProgramId) {
+                R_TRY(svc::GetInfo(std::addressof(m_program_location.program_id.value), svc::InfoType_ProgramId, handle, 0));
+            }
+
+            u64 value;
+            R_TRY(svc::GetInfo(std::addressof(value), svc::InfoType_IsApplication, handle, 0));
+            m_is_application = value != 0;
+
+            return ResultSuccess();
+        };
+
+        /* Get process info/status. */
+        os::NativeHandle process_handle;
+        if (R_FAILED(pm::dmnt::AtmosphereGetProcessInfo(std::addressof(process_handle), std::addressof(m_program_location), std::addressof(m_process_override_status), m_process_id))) {
+            process_handle            = os::InvalidNativeHandle;
+            m_program_location        = { ncm::InvalidProgramId, };
+            m_process_override_status = {};
+        }
+        ON_SCOPE_EXIT { os::CloseNativeHandle(process_handle); };
+
+        /* Try collecting from our debug handle, then the process handle. */
+        if (R_FAILED(CollectProcessInfoImpl(m_debug_handle)) && R_FAILED(CollectProcessInfoImpl(process_handle))) {
+            m_process_alias_address = 0;
+            m_process_alias_size    = 0;
+            m_process_heap_address  = 0;
+            m_process_heap_size     = 0;
+            m_process_aslr_address  = 0;
+            m_process_aslr_size     = 0;
+            m_process_stack_address = 0;
+            m_process_stack_size    = 0;
+            m_is_application        = false;
+        }
+    }
+
     Result DebugProcess::GetThreadContext(svc::ThreadContext *out, u64 thread_id, u32 flags) {
         return svc::GetDebugThreadContext(out, m_debug_handle, thread_id, flags);
     }
@@ -228,6 +296,11 @@ namespace ams::dmnt {
         return svc::WriteDebugProcessMemory(m_debug_handle, reinterpret_cast<uintptr_t>(src), address, size);
     }
 
+    Result DebugProcess::QueryMemory(svc::MemoryInfo *out, uintptr_t address) {
+        svc::PageInfo dummy;
+        return svc::QueryDebugProcessMemory(out, std::addressof(dummy), m_debug_handle, address);
+    }
+
     Result DebugProcess::Continue() {
         AMS_DMNT2_GDB_LOG_DEBUG("DebugProcess::Continue() all\n");
 
@@ -522,5 +595,25 @@ namespace ams::dmnt {
         return ResultSuccess();
     }
 
+    void DebugProcess::GetThreadName(char *dst, u64 thread_id) const {
+        for (size_t i = 0; i < ThreadCountMax; ++i) {
+            if (m_thread_valid[i] && m_thread_ids[i] == thread_id) {
+                if (R_FAILED(osdbg::GetThreadName(dst, std::addressof(m_thread_infos[i])))) {
+                    if (m_thread_infos[i]._thread_type != 0) {
+                        if (m_thread_infos[i]._thread_type_type == osdbg::ThreadTypeType_Libnx) {
+                            util::TSNPrintf(dst, os::ThreadNameLengthMax, "libnx Thread_0x%010lx", reinterpret_cast<uintptr_t>(m_thread_infos[i]._thread_type));
+                        } else {
+                            util::TSNPrintf(dst, os::ThreadNameLengthMax, "Thread_0x%010lx", reinterpret_cast<uintptr_t>(m_thread_infos[i]._thread_type));
+                        }
+                    } else {
+                        break;
+                    }
+                }
+                return;
+            }
+        }
+
+        util::TSNPrintf(dst, os::ThreadNameLengthMax, "Thread_ID=%lu", thread_id);
+    }
 
 }

stratosphere/dmnt.gen2/source/dmnt2_debug_process.hpp

@@ -50,6 +50,7 @@ namespace ams::dmnt {
             u64 m_last_thread_id{};
             u64 m_thread_id_override{};
             u64 m_continue_thread_id{};
+            u64 m_preferred_debug_break_thread_id{};
             GdbSignal m_last_signal{};
             bool m_stepping{false};
             bool m_use_hardware_single_step{false};
@@ -64,6 +65,17 @@ namespace ams::dmnt {
             ModuleDefinition m_module_definitions[ModuleCountMax]{};
             size_t m_module_count{};
             size_t m_main_module{};
+            u64 m_process_alias_address{};
+            u64 m_process_alias_size{};
+            u64 m_process_heap_address{};
+            u64 m_process_heap_size{};
+            u64 m_process_aslr_address{};
+            u64 m_process_aslr_size{};
+            u64 m_process_stack_address{};
+            u64 m_process_stack_size{};
+            ncm::ProgramLocation m_program_location{};
+            cfg::OverrideStatus m_process_override_status{};
+            bool m_is_application{false};
         public:
             DebugProcess() : m_software_breakpoints(this), m_hardware_breakpoints(this), m_hardware_watchpoints(this), m_step_breakpoints(m_software_breakpoints) {
                 if (svc::IsKernelMesosphere()) {
@@ -80,7 +92,8 @@ namespace ams::dmnt {
             size_t GetModuleCount() const { return m_module_count; }
             size_t GetMainModuleIndex() const { return m_main_module; }
             const char *GetModuleName(size_t ix) const { return m_module_definitions[ix].GetName(); }
-            uintptr_t GetBaseAddress(size_t ix) const { return m_module_definitions[ix].GetAddress(); }
+            uintptr_t GetModuleBaseAddress(size_t ix) const { return m_module_definitions[ix].GetAddress(); }
+            uintptr_t GetModuleSize(size_t ix) const { return m_module_definitions[ix].GetSize(); }
             ProcessStatus GetStatus() const { return m_status; }
             os::ProcessId GetProcessId() const { return m_process_id; }
 
@@ -95,20 +108,37 @@ namespace ams::dmnt {
             u64 GetLastThreadId();
             u64 GetThreadIdOverride() { this->GetLastThreadId(); return m_thread_id_override; }
 
+            u64 GetPreferredDebuggerBreakThreadId() { return m_preferred_debug_break_thread_id; }
+
             void SetLastThreadId(u64 tid) {
                 m_last_thread_id     = tid;
                 m_thread_id_override = tid;
             }
 
             void SetThreadIdOverride(u64 tid) {
-                m_thread_id_override = tid;
+                m_thread_id_override              = tid;
+                m_preferred_debug_break_thread_id = tid;
             }
 
             void SetDebugBreaked() {
                 m_status = ProcessStatus_DebugBreak;
             }
+
+            u64 GetAliasRegionAddress() const { return m_process_alias_address; }
+            u64 GetAliasRegionSize()    const { return m_process_alias_size; }
+            u64 GetHeapRegionAddress()  const { return m_process_heap_address; }
+            u64 GetHeapRegionSize()     const { return m_process_heap_size; }
+            u64 GetAslrRegionAddress()  const { return m_process_aslr_address; }
+            u64 GetAslrRegionSize()     const { return m_process_aslr_size; }
+            u64 GetStackRegionAddress() const { return m_process_stack_address; }
+            u64 GetStackRegionSize()    const { return m_process_stack_size; }
+
+            const ncm::ProgramLocation &GetProgramLocation() const { return m_program_location; }
+            const cfg::OverrideStatus &GetOverrideStatus() const { return m_process_override_status; }
+
+            bool IsApplication() const { return m_is_application; }
         public:
-            Result Attach(os::ProcessId process_id);
+            Result Attach(os::ProcessId process_id, bool start_process = false);
             void Detach();
 
             Result GetThreadContext(svc::ThreadContext *out, u64 thread_id, u32 flags);
@@ -117,6 +147,8 @@ namespace ams::dmnt {
             Result ReadMemory(void *dst, uintptr_t address, size_t size);
             Result WriteMemory(const void *src, uintptr_t address, size_t size);
 
+            Result QueryMemory(svc::MemoryInfo *out, uintptr_t address);
+
             Result Continue();
             Result Continue(u64 thread_id);
             Result Step();
@@ -146,9 +178,13 @@ namespace ams::dmnt {
             void GetBranchTarget(svc::ThreadContext &ctx, u64 thread_id, u64 &current_pc, u64 &target);
 
             Result CollectModules();
+
+            void GetThreadName(char *dst, u64 thread_id) const;
         private:
             Result Start();
 
+            void CollectProcessInfo();
+
             s32 ThreadCreate(u64 thread_id);
             void ThreadExit(u64 thread_id);
     };

stratosphere/dmnt.gen2/source/dmnt2_gdb_packet_io.cpp

@@ -41,7 +41,7 @@ namespace ams::dmnt {
 
     }
 
-    void GdbPacketIo::SendPacket(bool *out_break, const char *src, HtcsSession *session) {
+    void GdbPacketIo::SendPacket(bool *out_break, const char *src, TransportSession *session) {
         /* Default to not breaked. */
         *out_break = false;
 
@@ -99,7 +99,7 @@ namespace ams::dmnt {
         }
     }
 
-    char *GdbPacketIo::ReceivePacket(bool *out_break, char *dst, size_t size, HtcsSession *session) {
+    char *GdbPacketIo::ReceivePacket(bool *out_break, char *dst, size_t size, TransportSession *session) {
         /* Default to not breaked. */
         *out_break = false;
 

stratosphere/dmnt.gen2/source/dmnt2_gdb_packet_io.hpp

@@ -15,11 +15,11 @@
  */
 #pragma once
 #include <stratosphere.hpp>
-#include "dmnt2_htcs_session.hpp"
+#include "dmnt2_transport_session.hpp"
 
 namespace ams::dmnt {
 
-    static constexpr size_t GdbPacketBufferSize = 16_KB;
+    static constexpr size_t GdbPacketBufferSize = 32_KB;
 
     class GdbPacketIo {
         private:
@@ -30,8 +30,8 @@ namespace ams::dmnt {
 
             void SetNoAck() { m_no_ack = true; }
 
-            void SendPacket(bool *out_break, const char *src, HtcsSession *session);
-            char *ReceivePacket(bool *out_break, char *dst, size_t size, HtcsSession *session);
+            void SendPacket(bool *out_break, const char *src, TransportSession *session);
+            char *ReceivePacket(bool *out_break, char *dst, size_t size, TransportSession *session);
     };
 
 }

stratosphere/dmnt.gen2/source/dmnt2_gdb_server.cpp

@@ -15,6 +15,7 @@
  */
 #include <stratosphere.hpp>
 #include "dmnt2_debug_log.hpp"
+#include "dmnt2_transport_layer.hpp"
 #include "dmnt2_gdb_server.hpp"
 #include "dmnt2_gdb_server_impl.hpp"
 
@@ -36,34 +37,28 @@ namespace ams::dmnt {
             while (true) {
                 /* Get a socket. */
                 int fd;
-                while ((fd = htcs::Socket()) == -1) {
+                while ((fd = transport::Socket()) == -1) {
                     os::SleepThread(TimeSpan::FromSeconds(1));
                 }
 
                 /* Ensure we cleanup the socket when we're done with it. */
                 ON_SCOPE_EXIT {
-                    htcs::Close(fd);
+                    transport::Close(fd);
                     os::SleepThread(TimeSpan::FromSeconds(1));
                 };
 
-                /* Create a sock addr for our server. */
-                htcs::SockAddrHtcs addr;
-                addr.family    = htcs::HTCS_AF_HTCS;
-                addr.peer_name = htcs::GetPeerNameAny();
-                std::strcpy(addr.port_name.name, "iywys@$gdb");
-
                 /* Bind. */
-                if (htcs::Bind(fd, std::addressof(addr)) == -1) {
+                if (transport::Bind(fd, transport::PortName_GdbServer) == -1) {
                     continue;
                 }
 
                 /* Listen on our port. */
-                while (htcs::Listen(fd, 0) == 0) {
+                while (transport::Listen(fd, 0) == 0) {
                     /* Continue accepting clients, so long as we can. */
                     int client_fd;
                     while (true) {
                         /* Try to accept a client. */
-                        if (client_fd = htcs::Accept(fd, std::addressof(addr)); client_fd < 0) {
+                        if (client_fd = transport::Accept(fd); client_fd < 0) {
                             break;
                         }
 
@@ -77,7 +72,7 @@ namespace ams::dmnt {
                         }
 
                         /* Close the client socket. */
-                        htcs::Close(client_fd);
+                        transport::Close(client_fd);
                     }
                 }
             }

stratosphere/dmnt.gen2/source/dmnt2_gdb_server_impl.hpp

@@ -31,10 +31,11 @@ namespace ams::dmnt {
             };
         private:
             int m_socket;
-            HtcsSession m_session;
+            TransportSession m_session;
             GdbPacketIo m_packet_io;
             char *m_receive_packet{nullptr};
-            char *m_reply_packet{nullptr};
+            char *m_reply_cur{nullptr};
+            char *m_reply_end{nullptr};
             char m_buffer[GdbPacketBufferSize / 2];
             bool m_killed{false};
             os::ThreadType m_events_thread;
@@ -42,6 +43,7 @@ namespace ams::dmnt {
             DebugProcess m_debug_process;
             os::ProcessId m_process_id{os::InvalidProcessId};
             os::Event m_event;
+            os::ProcessId m_wait_process_id{os::InvalidProcessId};
         public:
             GdbServerImpl(int socket, void *thread_stack, size_t stack_size);
             ~GdbServerImpl();
@@ -60,7 +62,7 @@ namespace ams::dmnt {
             static void DebugEventsThreadEntry(void *arg) { static_cast<GdbServerImpl *>(arg)->DebugEventsThread(); }
             void DebugEventsThread();
             void ProcessDebugEvents();
-            void SetStopReplyPacket(GdbSignal signal);
+            void AppendStopReplyPacket(GdbSignal signal);
         private:
             void D();
 
@@ -98,6 +100,7 @@ namespace ams::dmnt {
 
             void qAttached();
             void qC();
+            void qRcmd();
             void qSupported();
             void qXfer();
             void qXferFeaturesRead();

stratosphere/dmnt.gen2/source/dmnt2_main.cpp

@@ -16,15 +16,22 @@
 #include <stratosphere.hpp>
 #include "dmnt2_debug_log.hpp"
 #include "dmnt2_gdb_server.hpp"
+#include "dmnt2_transport_layer.hpp"
 
 namespace ams {
 
-    namespace dmnt {
+    namespace {
 
-        namespace {
-
-            alignas(0x40) constinit u8 g_htcs_buffer[4_KB];
+        bool IsHtcEnabled() {
+            u8 enable_htc = 0;
+            settings::fwdbg::GetSettingsItemValue(std::addressof(enable_htc), sizeof(enable_htc), "atmosphere", "enable_htc");
+            return enable_htc != 0;
+        }
 
+        bool IsStandaloneGdbstubEnabled() {
+            u8 enable_gdbstub = 0;
+            settings::fwdbg::GetSettingsItemValue(std::addressof(enable_gdbstub), sizeof(enable_gdbstub), "atmosphere", "enable_standalone_gdbstub");
+            return enable_gdbstub != 0;
         }
 
     }
@@ -35,6 +42,9 @@ namespace ams {
             /* Initialize our connection to sm. */
             R_ABORT_UNLESS(sm::Initialize());
 
+            /* Initialize other services we need. */
+            R_ABORT_UNLESS(pmdmntInitialize());
+
             /* Verify that we can sanely execute. */
             ams::CheckApiVersion();
         }
@@ -50,11 +60,23 @@ namespace ams {
         os::SetThreadNamePointer(os::GetCurrentThread(), AMS_GET_SYSTEM_THREAD_NAME(dmnt, Main));
         AMS_ASSERT(os::GetThreadPriority(os::GetCurrentThread()) == AMS_GET_SYSTEM_THREAD_PRIORITY(dmnt, Main));
 
-        /* Initialize htcs. */
-        constexpr auto HtcsSocketCountMax = 8;
-        const size_t buffer_size = htcs::GetWorkingMemorySize(HtcsSocketCountMax);
-        AMS_ABORT_UNLESS(sizeof(dmnt::g_htcs_buffer) >= buffer_size);
-        htcs::InitializeForSystem(dmnt::g_htcs_buffer, buffer_size, HtcsSocketCountMax);
+        bool use_htcs = false, use_tcp = false;
+        {
+            R_ABORT_UNLESS(::setsysInitialize());
+            ON_SCOPE_EXIT { ::setsysExit(); };
+
+            use_htcs = IsHtcEnabled();
+            use_tcp  = IsStandaloneGdbstubEnabled();
+        }
+
+        /* Initialize transport layer. */
+        if (use_htcs) {
+            dmnt::transport::InitializeByHtcs();
+        } else if (use_tcp) {
+            dmnt::transport::InitializeByTcp();
+        } else {
+            return;
+        }
 
         /* Initialize debug log thread. */
         dmnt::InitializeDebugLog();

stratosphere/dmnt.gen2/source/dmnt2_module_definition.hpp

@@ -26,6 +26,7 @@ namespace ams::dmnt {
             char m_name[PathLengthMax];
             u64 m_address;
             u64 m_size;
+            size_t m_name_start;
         public:
             constexpr ModuleDefinition() : m_name(), m_address(), m_size() { /* ... */ }
             constexpr ~ModuleDefinition() { /* ... */ }
@@ -34,9 +35,10 @@ namespace ams::dmnt {
             constexpr ModuleDefinition &operator=(const ModuleDefinition &rhs) = default;
 
             constexpr void Reset() {
-                m_name[0] = 0;
-                m_address = 0;
-                m_size    = 0;
+                m_name[0]    = 0;
+                m_address    = 0;
+                m_size       = 0;
+                m_name_start = 0;
             }
 
             constexpr bool operator==(const ModuleDefinition &rhs) const {
@@ -48,7 +50,7 @@ namespace ams::dmnt {
             }
 
             constexpr char *GetNameBuffer() { return m_name; }
-            constexpr const char *GetName() const { return m_name; }
+            constexpr const char *GetName() const { return m_name + m_name_start; }
 
             constexpr u64 GetAddress() const { return m_address; }
             constexpr u64 GetSize() const { return m_size; }
@@ -57,6 +59,10 @@ namespace ams::dmnt {
                 m_address = address;
                 m_size    = size;
             }
+
+            constexpr void SetNameStart(size_t offset) {
+                m_name_start = offset;
+            }
     };
 
 }

stratosphere/dmnt.gen2/source/dmnt2_transport_layer.cpp

@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <stratosphere.hpp>
+#include "dmnt2_transport_layer.hpp"
+
+namespace ams::dmnt::transport {
+
+    namespace {
+
+        enum SocketMode {
+            SocketMode_Invalid,
+            SocketMode_Htcs,
+            SocketMode_Tcp,
+        };
+
+        constexpr inline const u16 ListenPort_GdbServer   = 22225;
+        constexpr inline const u16 ListenPort_GdbDebugLog = 22227;
+
+        constinit os::SdkMutex g_socket_init_mutex;
+        constinit SocketMode g_socket_mode = SocketMode_Invalid;
+
+        constexpr inline size_t RequiredAlignment = std::max(os::ThreadStackAlignment, os::MemoryPageSize);
+
+        using SocketConfigType = socket::SystemConfigLightDefault;
+
+        /* TODO: If we ever use resolvers, increase this. */
+        constexpr inline size_t SocketAllocatorSize  = 4_KB;
+        constexpr inline size_t SocketMemoryPoolSize = util::AlignUp(SocketConfigType::PerTcpSocketWorstCaseMemoryPoolSize + SocketConfigType::PerUdpSocketWorstCaseMemoryPoolSize, os::MemoryPageSize);
+
+        constexpr inline size_t SocketRequiredSize   = util::AlignUp(SocketMemoryPoolSize + SocketAllocatorSize, os::MemoryPageSize);
+
+        /* Declare the memory pool. */
+        alignas(RequiredAlignment) constinit u8 g_socket_memory[SocketRequiredSize];
+
+        constexpr inline const SocketConfigType SocketConfig(g_socket_memory, SocketRequiredSize, SocketAllocatorSize, 2);
+
+    }
+
+    void InitializeByHtcs() {
+        std::scoped_lock lk(g_socket_init_mutex);
+        AMS_ABORT_UNLESS(g_socket_mode == SocketMode_Invalid);
+
+        constexpr auto HtcsSocketCountMax = 8;
+        const size_t buffer_size = htcs::GetWorkingMemorySize(HtcsSocketCountMax);
+        AMS_ABORT_UNLESS(sizeof(g_socket_memory) >= buffer_size);
+        htcs::InitializeForSystem(g_socket_memory, sizeof(g_socket_memory), HtcsSocketCountMax);
+
+        g_socket_mode = SocketMode_Htcs;
+    }
+
+    void InitializeByTcp() {
+        std::scoped_lock lk(g_socket_init_mutex);
+        AMS_ABORT_UNLESS(g_socket_mode == SocketMode_Invalid);
+
+        R_ABORT_UNLESS(socket::Initialize(SocketConfig));
+
+        g_socket_mode = SocketMode_Tcp;
+    }
+
+    s32 Socket() {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs: return htcs::Socket();
+            case SocketMode_Tcp:  return socket::Socket(socket::Family::Af_Inet, socket::Type::Sock_Stream, socket::Protocol::IpProto_Tcp);
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    s32 Close(s32 desc) {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs:   return htcs::Close(desc);
+            case SocketMode_Tcp: return socket::Close(desc);
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    s32 Bind(s32 desc, PortName port_name) {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs:
+                {
+                    htcs::SockAddrHtcs addr;
+                    addr.family    = htcs::HTCS_AF_HTCS;
+                    addr.peer_name = htcs::GetPeerNameAny();
+                    switch (port_name) {
+                        case PortName_GdbServer:   std::strcpy(addr.port_name.name, "iywys@$gdb"); break;
+                        case PortName_GdbDebugLog: std::strcpy(addr.port_name.name, "iywys@$dmnt2_log"); break;
+                        AMS_UNREACHABLE_DEFAULT_CASE();
+                    }
+
+                    return htcs::Bind(desc, std::addressof(addr));
+                }
+                break;
+            case SocketMode_Tcp:
+                {
+                    socket::SockAddrIn addr = {};
+                    addr.sin_family      = socket::Family::Af_Inet;
+                    addr.sin_addr.s_addr = socket::InAddr_Any;
+
+                    switch (port_name){
+                        case PortName_GdbServer:   addr.sin_port = socket::InetHtons(static_cast<u16>(ListenPort_GdbServer)); break;
+                        case PortName_GdbDebugLog: addr.sin_port = socket::InetHtons(static_cast<u16>(ListenPort_GdbDebugLog)); break;
+                        AMS_UNREACHABLE_DEFAULT_CASE();
+                    }
+
+                    return socket::Bind(desc, reinterpret_cast<socket::SockAddr *>(std::addressof(addr)), sizeof(addr));
+                }
+                break;
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    s32 Listen(s32 desc, s32 backlog_count) {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs: return htcs::Listen(desc, backlog_count);
+            case SocketMode_Tcp:  return socket::Listen(desc, backlog_count);
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    s32 Accept(s32 desc) {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs:
+                {
+                    htcs::SockAddrHtcs addr;
+                    addr.family    = htcs::HTCS_AF_HTCS;
+                    addr.peer_name = htcs::GetPeerNameAny();
+                    addr.port_name.name[0] = '\x00';
+
+                    return htcs::Accept(desc, std::addressof(addr));
+                }
+                break;
+            case SocketMode_Tcp:
+                {
+                    socket::SockAddrIn addr = {};
+                    socket::SockLenT addr_len = sizeof(addr);
+
+                    return socket::Accept(desc, reinterpret_cast<socket::SockAddr *>(std::addressof(addr)), std::addressof(addr_len));
+                }
+                break;
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    s32 Shutdown(s32 desc) {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs: return htcs::Shutdown(desc, htcs::HTCS_SHUT_RDWR);
+            case SocketMode_Tcp:  return socket::Shutdown(desc, socket::ShutdownMethod::Shut_RdWr);
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    ssize_t Recv(s32 desc, void *buffer, size_t buffer_size, s32 flags) {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs: return htcs::Recv(desc, buffer, buffer_size, flags);
+            case SocketMode_Tcp:  return socket::Recv(desc, buffer, buffer_size, static_cast<socket::MsgFlag>(flags));
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    ssize_t Send(s32 desc, const void *buffer, size_t buffer_size, s32 flags) {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs: return htcs::Send(desc, buffer, buffer_size, flags);
+            case SocketMode_Tcp:  return socket::Send(desc, buffer, buffer_size, static_cast<socket::MsgFlag>(flags));
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    s32 GetLastError() {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs: return htcs::GetLastError();
+            case SocketMode_Tcp:  return static_cast<s32>(socket::GetLastError());
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    bool IsLastErrorEAgain() {
+        switch (g_socket_mode) {
+            case SocketMode_Htcs: return htcs::GetLastError() == htcs::HTCS_EAGAIN;
+            case SocketMode_Tcp:  return socket::GetLastError() == socket::Errno::EAgain;
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+}

stratosphere/dmnt.gen2/source/dmnt2_transport_layer.hpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <stratosphere.hpp>
+
+namespace ams::dmnt::transport {
+
+    void InitializeByHtcs();
+    void InitializeByTcp();
+
+    enum PortName {
+        PortName_GdbServer,
+        PortName_GdbDebugLog,
+    };
+
+    s32 Socket();
+    s32 Close(s32 desc);
+    s32 Bind(s32 desc, PortName port_name);
+    s32 Listen(s32 desc, s32 backlog_count);
+    s32 Accept(s32 desc);
+    s32 Shutdown(s32 desc);
+
+    ssize_t Recv(s32 desc, void *buffer, size_t buffer_size, s32 flags);
+    ssize_t Send(s32 desc, const void *buffer, size_t buffer_size, s32 flags);
+
+    s32 GetLastError();
+    bool IsLastErrorEAgain();
+
+}

stratosphere/dmnt.gen2/source/dmnt2_transport_receive_buffer.cpp

@@ -14,11 +14,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <stratosphere.hpp>
-#include "dmnt2_htcs_receive_buffer.hpp"
+#include "dmnt2_transport_receive_buffer.hpp"
 
 namespace ams::dmnt {
 
-    ssize_t HtcsReceiveBuffer::Read(void *dst, size_t size) {
+    ssize_t TransportReceiveBuffer::Read(void *dst, size_t size) {
         /* Acquire exclusive access to ourselves. */
         std::scoped_lock lk(m_mutex);
 
@@ -50,7 +50,7 @@ namespace ams::dmnt {
         return readable;
     }
 
-    ssize_t HtcsReceiveBuffer::Write(const void *src, size_t size) {
+    ssize_t TransportReceiveBuffer::Write(const void *src, size_t size) {
         /* Acquire exclusive access to ourselves. */
         std::scoped_lock lk(m_mutex);
 
@@ -71,7 +71,7 @@ namespace ams::dmnt {
         return size;
     }
 
-    bool HtcsReceiveBuffer::WaitToBeReadable() {
+    bool TransportReceiveBuffer::WaitToBeReadable() {
         /* Check if we're already readable. */
         {
             std::scoped_lock lk(m_mutex);
@@ -91,7 +91,7 @@ namespace ams::dmnt {
         return this->IsValid();
     }
 
-    bool HtcsReceiveBuffer::WaitToBeReadable(TimeSpan timeout) {
+    bool TransportReceiveBuffer::WaitToBeReadable(TimeSpan timeout) {
         /* Check if we're already readable. */
         {
             std::scoped_lock lk(m_mutex);
@@ -111,7 +111,7 @@ namespace ams::dmnt {
         return res && this->IsValid();
     }
 
-    bool HtcsReceiveBuffer::WaitToBeWritable() {
+    bool TransportReceiveBuffer::WaitToBeWritable() {
         /* Check if we're already writable. */
         {
             std::scoped_lock lk(m_mutex);
@@ -131,7 +131,7 @@ namespace ams::dmnt {
         return this->IsValid();
     }
 
-    void HtcsReceiveBuffer::Invalidate() {
+    void TransportReceiveBuffer::Invalidate() {
         /* Acquire exclusive access to ourselves. */
         std::scoped_lock lk(m_mutex);
 

stratosphere/dmnt.gen2/source/dmnt2_transport_receive_buffer.hpp

@@ -18,7 +18,7 @@
 
 namespace ams::dmnt {
 
-    class HtcsReceiveBuffer {
+    class TransportReceiveBuffer {
         public:
             static constexpr size_t ReceiveBufferSize = 4_KB;
         private:
@@ -30,7 +30,7 @@ namespace ams::dmnt {
             size_t m_offset;
             bool m_valid;
         public:
-            HtcsReceiveBuffer() : m_readable_event(os::EventClearMode_ManualClear), m_writable_event(os::EventClearMode_ManualClear), m_mutex(), m_readable_size(), m_offset(), m_valid(true) { /* ... */ }
+            TransportReceiveBuffer() : m_readable_event(os::EventClearMode_ManualClear), m_writable_event(os::EventClearMode_ManualClear), m_mutex(), m_readable_size(), m_offset(), m_valid(true) { /* ... */ }
 
             ALWAYS_INLINE bool IsReadable() const { return m_readable_size != 0; }
             ALWAYS_INLINE bool IsWritable() const { return m_readable_size == 0; }

stratosphere/dmnt.gen2/source/dmnt2_transport_session.cpp

@@ -14,12 +14,13 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <stratosphere.hpp>
-#include "dmnt2_htcs_session.hpp"
+#include "dmnt2_transport_layer.hpp"
+#include "dmnt2_transport_session.hpp"
 #include "dmnt2_debug_log.hpp"
 
 namespace ams::dmnt {
 
-    HtcsSession::HtcsSession(int fd) : m_socket(fd), m_valid(true) {
+    TransportSession::TransportSession(int fd) : m_socket(fd), m_valid(true) {
         /* Create our thread. */
         R_ABORT_UNLESS(os::CreateThread(std::addressof(m_receive_thread), ReceiveThreadEntry, this, m_receive_thread_stack, sizeof(m_receive_thread_stack), os::HighestThreadPriority - 1));
 
@@ -30,7 +31,7 @@ namespace ams::dmnt {
         AMS_DMNT2_GDB_LOG_INFO("Created Session %d\n", m_socket);
     }
 
-    HtcsSession::~HtcsSession() {
+    TransportSession::~TransportSession() {
         /* Note that we connected. */
         AMS_DMNT2_GDB_LOG_INFO("Closing Session %d\n", m_socket);
 
@@ -38,25 +39,25 @@ namespace ams::dmnt {
         m_receive_buffer.Invalidate();
 
         /* Shutdown our socket. */
-        htcs::Shutdown(m_socket, htcs::HTCS_SHUT_RDWR);
+        transport::Shutdown(m_socket);
 
         /* Wait for our thread. */
         os::WaitThread(std::addressof(m_receive_thread));
         os::DestroyThread(std::addressof(m_receive_thread));
 
         /* Close our socket. */
-        htcs::Close(m_socket);
+        transport::Close(m_socket);
     }
 
-    bool HtcsSession::WaitToBeReadable() {
+    bool TransportSession::WaitToBeReadable() {
         return m_receive_buffer.WaitToBeReadable();
     }
 
-    bool HtcsSession::WaitToBeReadable(TimeSpan timeout) {
+    bool TransportSession::WaitToBeReadable(TimeSpan timeout) {
         return m_receive_buffer.WaitToBeReadable(timeout);
     }
 
-    util::optional<char> HtcsSession::GetChar() {
+    util::optional<char> TransportSession::GetChar() {
         /* Wait for us to have data. */
         m_receive_buffer.WaitToBeReadable();
 
@@ -69,9 +70,9 @@ namespace ams::dmnt {
         }
     }
 
-    ssize_t HtcsSession::PutChar(char c) {
+    ssize_t TransportSession::PutChar(char c) {
         /* Send the character. */
-        const auto sent = htcs::Send(m_socket, std::addressof(c), sizeof(c), 0);
+        const auto sent = transport::Send(m_socket, std::addressof(c), sizeof(c), 0);
         if (sent < 0) {
             m_valid = false;
         }
@@ -79,13 +80,13 @@ namespace ams::dmnt {
         return sent;
     }
 
-    ssize_t HtcsSession::PutString(const char *str) {
+    ssize_t TransportSession::PutString(const char *str) {
         /* Repeatedly send until all is sent. */
         const size_t len = std::strlen(str);
 
         size_t remaining = len;
         while (remaining > 0) {
-            const auto sent = htcs::Send(m_socket, str, remaining, 0);
+            const auto sent = transport::Send(m_socket, str, remaining, 0);
             if (sent >= 0) {
                 remaining -= sent;
                 str += sent;
@@ -98,22 +99,22 @@ namespace ams::dmnt {
         return len;
     }
 
-    void HtcsSession::ReceiveThreadFunction() {
+    void TransportSession::ReceiveThreadFunction() {
         /* Create temporary buffer. */
-        u8 buffer[HtcsReceiveBuffer::ReceiveBufferSize];
+        u8 buffer[TransportReceiveBuffer::ReceiveBufferSize];
 
         /* Loop receiving data. */
         while (true) {
             /* Receive data. */
-            const auto res = htcs::Recv(m_socket, buffer, sizeof(buffer), 0);
+            const auto res = transport::Recv(m_socket, buffer, sizeof(buffer), 0);
             if (res > 0) {
                 /* Write the data to our buffer. */
                 m_receive_buffer.WaitToBeWritable();
                 m_receive_buffer.Write(buffer, res);
             } else {
                 /* Otherwise, if we got an error other than "try again", we're done. */
-                if (htcs::GetLastError() != htcs::HTCS_EAGAIN) {
-                    AMS_DMNT2_GDB_LOG_INFO("Session %d invalid, res=%ld, err=%d\n", m_socket, res, static_cast<int>(htcs::GetLastError()));
+                if (!transport::IsLastErrorEAgain()) {
+                    AMS_DMNT2_GDB_LOG_INFO("Session %d invalid, res=%ld, err=%d\n", m_socket, res, static_cast<int>(transport::GetLastError()));
                     m_valid = false;
                     break;
                 }

stratosphere/dmnt.gen2/source/dmnt2_transport_session.hpp

@@ -15,20 +15,20 @@
  */
 #pragma once
 #include <stratosphere.hpp>
-#include "dmnt2_htcs_receive_buffer.hpp"
+#include "dmnt2_transport_receive_buffer.hpp"
 
 namespace ams::dmnt {
 
-    class HtcsSession {
+    class TransportSession {
         private:
-            alignas(os::ThreadStackAlignment) u8 m_receive_thread_stack[util::AlignUp(os::MemoryPageSize + HtcsReceiveBuffer::ReceiveBufferSize, os::ThreadStackAlignment)];
-            HtcsReceiveBuffer m_receive_buffer;
+            alignas(os::ThreadStackAlignment) u8 m_receive_thread_stack[util::AlignUp(os::MemoryPageSize + TransportReceiveBuffer::ReceiveBufferSize, os::ThreadStackAlignment)];
+            TransportReceiveBuffer m_receive_buffer;
             os::ThreadType m_receive_thread;
             int m_socket;
             bool m_valid;
         public:
-            HtcsSession(int fd);
-            ~HtcsSession();
+            TransportSession(int fd);
+            ~TransportSession();
 
             ALWAYS_INLINE bool IsValid() const { return m_valid; }
 
@@ -41,7 +41,7 @@ namespace ams::dmnt {
 
         private:
             static void ReceiveThreadEntry(void *arg) {
-                static_cast<HtcsSession *>(arg)->ReceiveThreadFunction();
+                static_cast<TransportSession *>(arg)->ReceiveThreadFunction();
             }
 
             void ReceiveThreadFunction();

stratosphere/dmnt/source/cheat/impl/dmnt_cheat_api.cpp

@@ -248,7 +248,6 @@ namespace ams::dmnt::cheat::impl {
                 void StartProcess(os::ProcessId process_id) const {
                     R_ABORT_UNLESS(pm::dmnt::StartProcess(process_id));
                 }
-
             public:
                 CheatProcessManager() : m_cheat_lock(), m_unsafe_break_event(os::EventClearMode_ManualClear), m_debug_events_event(os::EventClearMode_AutoClear), m_cheat_process_event(os::EventClearMode_AutoClear, true) {
                     /* Learn whether we should enable cheats by default. */