benchmark-toolbox: make cpu readings *actually* match memtoolkit

Source/Atmosphere-Patches/secmon_define_exception_vectors_access_table.inc

@@ -1,25 +0,0 @@
-/*
- * 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/>.
- */
-
-#define __ACCESS_TABLE_NAME__    ExceptionVectorsAccessTable
-#define __ACCESS_TABLE_ADDRESS__ MemoryRegionPhysicalDeviceExceptionVectors.GetAddress()
-#define __ACCESS_TABLE_INC__     "secmon_exception_vectors_access_table_data.inc"
-
-#include "secmon_define_access_table.inc"
-
-#undef __ACCESS_TABLE_INC__
-#undef __ACCESS_TABLE_ADDRESS__
-#undef __ACCESS_TABLE_NAME__

Source/Atmosphere-Patches/secmon_define_flow_controller_access_table.inc

@@ -1,25 +0,0 @@
-/*
- * 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/>.
- */
-
-#define __ACCESS_TABLE_NAME__    FlowControllerAccessTable
-#define __ACCESS_TABLE_ADDRESS__ MemoryRegionPhysicalDeviceFlowController.GetAddress()
-#define __ACCESS_TABLE_INC__     "secmon_flow_controller_access_table_data.inc"
-
-#include "secmon_define_access_table.inc"
-
-#undef __ACCESS_TABLE_INC__
-#undef __ACCESS_TABLE_ADDRESS__
-#undef __ACCESS_TABLE_NAME__

Source/Atmosphere-Patches/secmon_smc_register_access.cpp

@@ -100,8 +100,6 @@ namespace ams::secmon::smc {
         #include "secmon_define_mc_access_table.inc"
         #include "secmon_define_emc_access_table.inc"
         #include "secmon_define_emc01_access_table.inc"
-        #include "secmon_define_flow_controller_access_table.inc"
-        #include "secmon_define_exception_vectors_access_table.inc"
         #include "secmon_define_rtc_pmc_access_table.inc"
         #include "secmon_define_mc01_access_table.inc"
 
@@ -111,8 +109,6 @@ namespace ams::secmon::smc {
             { EmcAccessTable::ReducedAccessTable.data(),              MemoryRegionVirtualDeviceExternalMemoryController.GetAddress(),                     EmcAccessTable::Address,                                                             EmcAccessTable::Size,              },
             { Emc01AccessTable::ReducedAccessTable.data(),            Emc01AccessTable::Address + MemoryRegionVirtualDeviceExternalMemoryController0.GetAddress(), Emc01AccessTable::Address + MemoryRegionPhysicalDeviceExternalMemoryController0.GetAddress(), Emc01AccessTable::Size, },
             { Emc01AccessTable::ReducedAccessTable.data(),            Emc01AccessTable::Address + MemoryRegionVirtualDeviceExternalMemoryController1.GetAddress(), Emc01AccessTable::Address + MemoryRegionPhysicalDeviceExternalMemoryController1.GetAddress(), Emc01AccessTable::Size, },
-            { FlowControllerAccessTable::ReducedAccessTable.data(),   MemoryRegionVirtualDeviceFlowController.GetAddress(),                               FlowControllerAccessTable::Address,                                                  FlowControllerAccessTable::Size,   },
-            { ExceptionVectorsAccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDeviceExceptionVectors.GetAddress(),                             ExceptionVectorsAccessTable::Address,                                                ExceptionVectorsAccessTable::Size, },
             { RtcPmcAccessTable::ReducedAccessTable.data(),           MemoryRegionVirtualDeviceRtcPmc.GetAddress(),                                       RtcPmcAccessTable::Address,                                                          RtcPmcAccessTable::Size,           },
             { Mc01AccessTable::ReducedAccessTable.data(),             Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController0.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController0.GetAddress(), Mc01AccessTable::Size,             },
             { Mc01AccessTable::ReducedAccessTable.data(),             Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController1.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController1.GetAddress(), Mc01AccessTable::Size,             },

Source/Atmosphere/stratosphere/loader/source/ldr_process_creation.cpp

@@ -126,8 +126,7 @@ namespace ams::ldr {
         bool g_is_ptm;
 
         /* Global Zstd decompression context. */
-        constexpr size_t ZstdDctxWorkspaceSize = 0x176E8;
-        alignas(8) u8 g_zstd_dctx_workspace[ZstdDctxWorkspaceSize];
+        alignas(8) u8 g_zstd_dctx_workspace[util::DecompressZstdWithBicWorkBufferSizeDefault];
 
         Result ValidateProgramVersion(ncm::ProgramId program_id, u32 version) {
             /* No version verification is done before 8.1.0. */
@@ -181,8 +180,8 @@ namespace ams::ldr {
             return (MakeProgramInfoFlag(static_cast<const util::BitPack32 *>(meta->aci_kac), meta->aci->kac_size / sizeof(util::BitPack32)) & ProgramInfoFlag_ApplicationTypeMask) == ProgramInfoFlag_Application;
         }
 
-        Npdm::AddressSpaceType GetAddressSpaceType(const Meta *meta) {
-            return static_cast<Npdm::AddressSpaceType>((meta->npdm->flags & Npdm::MetaFlag_AddressSpaceTypeMask) >> Npdm::MetaFlag_AddressSpaceTypeShift);
+        Npdm::ProcessAddressSpace GetProcessAddressSpace(const Meta *meta) {
+            return static_cast<Npdm::ProcessAddressSpace>((meta->npdm->flags0 & Npdm::MetaFlag0_ProcessAddressSpaceMask) >> Npdm::MetaFlag0_ProcessAddressSpaceShift);
         }
 
         Acid::PoolPartition GetPoolPartition(const Meta *meta) {
@@ -225,7 +224,7 @@ namespace ams::ldr {
                     /* Read NSO header. */
                     size_t read_size;
                     R_TRY(fs::ReadFile(std::addressof(read_size), file, 0, g_nso_headers + ctx.nso_count, sizeof(NsoHeader)));
-                    R_UNLESS(read_size == sizeof(NsoHeader), ldr::ResultInvalidNso());
+                    R_UNLESS_LOG(read_size == sizeof(NsoHeader), ldr::ResultInvalidNso(), "[ldr] NSO header truncated!\n");
 
                     /* Note nso is present. */
                     switch (i) {
@@ -264,7 +263,7 @@ namespace ams::ldr {
 
         Result CheckAutoLoad(const AutoLoadModuleContext &ctx, u32 acid_flags) {
             /* We must always have a main. */
-            R_UNLESS(ctx.ali.has_main, ldr::ResultInvalidNso());
+            R_UNLESS_LOG(ctx.ali.has_main, ldr::ResultInvalidNso(), "[ldr] Missing main!\n");
 
             /* Validate flags and extents for all present NSOs. */
             for (int i = 0; i < ctx.nso_count; ++i) {
@@ -272,11 +271,11 @@ namespace ams::ldr {
 
                 /* All NSOs must not be --X. */
                 /* This is "probably" not checked on Ounce? */
-                R_UNLESS((hdr.flags & NsoHeader::Flag_PreventCodeReads) == 0, ldr::ResultInvalidNso());
+                R_UNLESS_LOG((hdr.flags & NsoHeader::Flag_PreventCodeReads) == 0, ldr::ResultInvalidNso(), "[ldr] NSO[%d] --x not allowed!\n", i);
 
                 /* Zstd compression only allowed on main, and only when both rtld+sdk are present. */
                 if (i != ctx.main_nso_idx || ctx.rtld_idx < 0 || ctx.sdk_nso_idx < 0) {
-                    R_UNLESS((hdr.flags & NsoHeader::Flag_UseZbicCompression) == 0, ldr::ResultInvalidNso());
+                    R_UNLESS_LOG((hdr.flags & NsoHeader::Flag_UseZbicCompression) == 0, ldr::ResultInvalidNso(), "[ldr] NSO[%d] zbic not allowed!\n", i);
                 }
 
                 /* NSOs must have page-aligned segments. */
@@ -299,13 +298,13 @@ namespace ams::ldr {
             const bool has_browser_dll = (acid_flags & Acid::AcidFlag_LoadBrowserCoreDll) != 0;
             if (ctx.ali.has_rtld || ctx.ali.has_sdk) {
                 /* If we have sdk we must have rtld. */
-                R_UNLESS(ctx.ali.has_rtld, ldr::ResultInvalidNso());
+                R_UNLESS_LOG(ctx.ali.has_rtld, ldr::ResultInvalidNso(), "[ldr] Missing rtld!\n");
 
                 /* If we have rtld, we must not have browser core dll. */
-                R_UNLESS(!has_browser_dll, ldr::ResultInvalidNso());
+                R_UNLESS_LOG(!has_browser_dll, ldr::ResultInvalidNso(), "[ldr] BrowserCoreDll must not be present!\n");
             } else {
                 /* We must not have both subsdk and browser dll. */
-                R_UNLESS(!(ctx.ali.has_subsdk && has_browser_dll), ldr::ResultInvalidNso());
+                R_UNLESS_LOG(!(ctx.ali.has_subsdk && has_browser_dll), ldr::ResultInvalidNso(), "[ldr] Can't have both subsdk and BrowserCoreDll!\n");
             }
 
             R_SUCCEED();
@@ -394,6 +393,8 @@ namespace ams::ldr {
 
                 /* If the signature check fails, we need to check if this is allowable. */
                 if (!is_signature_valid) {
+                    AMS_LOG("[ldr] invalid signature!\n");
+
                     /* We have to enforce signature checks on prod and when we have a signature to check on dev. */
                     R_UNLESS(IsDevelopmentForAcidProductionCheck(), ldr::ResultInvalidNcaSignature());
                     R_UNLESS(!code_verification_data.has_data,      ldr::ResultInvalidNcaSignature());
@@ -407,52 +408,56 @@ namespace ams::ldr {
             R_SUCCEED();
         }
 
-        Result GetCreateProcessFlags(u32 *out, const Meta *meta, const u32 ldr_flags) {
-            const u8 meta_flags = meta->npdm->flags;
+        Result GetCreateProcessParameterFlags(u32 *out, const Meta *meta, const u32 ldr_flags) {
+            const u8 meta_flags0 = meta->npdm->flags0;
+            const u8 meta_flags1 = meta->npdm->flags1;
 
             u32 flags = 0;
 
             /* Set Is64Bit. */
-            if (meta_flags & Npdm::MetaFlag_Is64Bit) {
-                flags |= svc::CreateProcessFlag_Is64Bit;
+            if (meta_flags0 & Npdm::MetaFlag0_Is64BitInstruction) {
+                flags |= svc::CreateProcessParameterFlag_64Bit;
             }
 
-            /* Set AddressSpaceType. */
-            switch (GetAddressSpaceType(meta)) {
-                case Npdm::AddressSpaceType_32Bit:
-                    flags |= svc::CreateProcessFlag_AddressSpace32Bit;
+            /* Set ProcessAddressSpace. */
+            switch (GetProcessAddressSpace(meta)) {
+                case Npdm::ProcessAddressSpace_32Bit:
+                    flags |= svc::CreateProcessParameterFlag_AddressSpace32Bit;
                     break;
-                case Npdm::AddressSpaceType_64BitDeprecated:
-                    flags |= svc::CreateProcessFlag_AddressSpace64BitDeprecated;
+                case Npdm::ProcessAddressSpace_64Bit36:
+                    flags |= svc::CreateProcessParameterFlag_AddressSpace64Bit36;
                     break;
-                case Npdm::AddressSpaceType_32BitWithoutAlias:
-                    flags |= svc::CreateProcessFlag_AddressSpace32BitWithoutAlias;
+                case Npdm::ProcessAddressSpace_32BitNoReserved:
+                    flags |= svc::CreateProcessParameterFlag_AddressSpace32BitNoReserved;
                     break;
-                case Npdm::AddressSpaceType_64Bit:
-                    flags |= svc::CreateProcessFlag_AddressSpace64Bit;
+                case Npdm::ProcessAddressSpace_64Bit39:
+                    flags |= svc::CreateProcessParameterFlag_AddressSpace64Bit39;
+                    break;
+                case Npdm::ProcessAddressSpace_64Bit42:
+                    flags |= svc::CreateProcessParameterFlag_AddressSpace64Bit42;
                     break;
                 default:
                     R_THROW(ldr::ResultInvalidMeta());
             }
 
             /* Set Enable Debug. */
-            if (ldr_flags & CreateProcessFlag_EnableDebug) {
-                flags |= svc::CreateProcessFlag_EnableDebug;
+            if (ldr_flags & CreateProcessParameterFlag_EnableJitDebug) {
+                flags |= svc::CreateProcessParameterFlag_EnableJitDebug;
             }
 
             /* Set Enable ASLR. */
-            if (!(ldr_flags & CreateProcessFlag_DisableAslr)) {
-                flags |= svc::CreateProcessFlag_EnableAslr;
+            if (!(ldr_flags & CreateProcessParameterFlag_DisableAslr)) {
+                flags |= svc::CreateProcessParameterFlag_EnableAslr;
             }
 
             /* Set Is Application. */
             if (IsApplication(meta)) {
-                flags |= svc::CreateProcessFlag_IsApplication;
+                flags |= svc::CreateProcessParameterFlag_IsApplication;
 
                 /* 7.0.0+: Set OptimizeMemoryAllocation if relevant. */
                 if (hos::GetVersion() >= hos::Version_7_0_0) {
-                    if (meta_flags & Npdm::MetaFlag_OptimizeMemoryAllocation) {
-                        flags |= svc::CreateProcessFlag_OptimizeMemoryAllocation;
+                    if (meta_flags0 & Npdm::MetaFlag0_OptimizeMemoryAllocation) {
+                        flags |= svc::CreateProcessParameterFlag_OptimizeMemoryAllocation;
                     }
                 }
             }
@@ -464,19 +469,19 @@ namespace ams::ldr {
                 switch (GetPoolPartition(meta)) {
                     case Acid::PoolPartition_Application:
                         if (IsApplet(meta)) {
-                            flags |= svc::CreateProcessFlag_PoolPartitionApplet;
+                            flags |= svc::CreateProcessParameterFlag_PoolPartitionApplet;
                         } else {
-                            flags |= svc::CreateProcessFlag_PoolPartitionApplication;
+                            flags |= svc::CreateProcessParameterFlag_PoolPartitionApplication;
                         }
                         break;
                     case Acid::PoolPartition_Applet:
-                        flags |= svc::CreateProcessFlag_PoolPartitionApplet;
+                        flags |= svc::CreateProcessParameterFlag_PoolPartitionApplet;
                         break;
                     case Acid::PoolPartition_System:
-                        flags |= svc::CreateProcessFlag_PoolPartitionSystem;
+                        flags |= svc::CreateProcessParameterFlag_PoolPartitionSystem;
                         break;
                     case Acid::PoolPartition_SystemNonSecure:
-                        flags |= svc::CreateProcessFlag_PoolPartitionSystemNonSecure;
+                        flags |= svc::CreateProcessParameterFlag_PoolPartitionSystemNonSecure;
                         break;
                     default:
                         R_THROW(ldr::ResultInvalidMeta());
@@ -484,18 +489,23 @@ namespace ams::ldr {
             } else if (hos::GetVersion() >= hos::Version_4_0_0) {
                 /* On 4.0.0+, the corresponding bit was simply "UseSecureMemory". */
                 if (meta->acid->flags & Acid::AcidFlag_DeprecatedUseSecureMemory) {
-                    flags |= svc::CreateProcessFlag_DeprecatedUseSecureMemory;
+                    flags |= svc::CreateProcessParameterFlag_DeprecatedUseSecureMemory;
                 }
             }
 
-            /* 11.0.0+/meso Set Disable DAS merge. */
-            if (meta_flags & Npdm::MetaFlag_DisableDeviceAddressSpaceMerge) {
-                flags |= svc::CreateProcessFlag_DisableDeviceAddressSpaceMerge;
+            /* 11.0.0+/meso Set Disable DAS Merge. */
+            if (meta_flags0 & Npdm::MetaFlag0_DisableDeviceAddressSpaceMerge) {
+                flags |= svc::CreateProcessParameterFlag_DisableDeviceAddressSpaceMerge;
             }
 
-            /* 18.0.0+/meso Set Alias region extra size. */
-            if (meta_flags & Npdm::MetaFlag_EnableAliasRegionExtraSize) {
-                flags |= svc::CreateProcessFlag_EnableAliasRegionExtraSize;
+            /* 18.0.0+/meso Set Enable Address Sanitizer . */
+            if (meta_flags0 & Npdm::MetaFlag0_EnableAddressSanitizer) {
+                flags |= svc::CreateProcessParameterFlag_EnableAddressSanitizer;
+            }
+
+            /* 23.0.0+/meso Set Enable Shadow Stack. */
+            if (meta_flags1 & Npdm::MetaFlag1_EnableShadowStack) {
+                flags |= svc::CreateProcessParameterFlag_EnableShadowStack;
             }
 
             *out = flags;
@@ -513,7 +523,7 @@ namespace ams::ldr {
             out->reslimit   = resource_limit;
 
             /* Set flags. */
-            R_TRY(GetCreateProcessFlags(std::addressof(out->flags), meta, flags));
+            R_TRY(GetCreateProcessParameterFlags(std::addressof(out->flags), meta, flags));
 
             /* 3.0.0+ System Resource Size. */
             if (hos::GetVersion() >= hos::Version_3_0_0) {
@@ -523,7 +533,7 @@ namespace ams::ldr {
                 /* Validate system resource usage. */
                 if (meta->npdm->system_resource_size) {
                     /* Process must be 64-bit. */
-                    R_UNLESS((out->flags & svc::CreateProcessFlag_AddressSpace64Bit), ldr::ResultInvalidMeta());
+                    R_UNLESS((out->flags & svc::CreateProcessParameterFlag_AddressSpace64Bit39), ldr::ResultInvalidMeta());
 
                     /* Process must be application or applet. */
                     R_UNLESS(IsApplication(meta) || IsApplet(meta), ldr::ResultInvalidMeta());
@@ -596,25 +606,29 @@ namespace ams::ldr {
             uintptr_t aslr_start = 0;
             size_t aslr_size     = 0;
             if (hos::GetVersion() >= hos::Version_2_0_0) {
-                switch (out_param->flags & svc::CreateProcessFlag_AddressSpaceMask) {
-                    case svc::CreateProcessFlag_AddressSpace32Bit:
-                    case svc::CreateProcessFlag_AddressSpace32BitWithoutAlias:
+                switch (out_param->flags & svc::CreateProcessParameterFlag_AddressSpaceMask) {
+                    case svc::CreateProcessParameterFlag_AddressSpace32Bit:
+                    case svc::CreateProcessParameterFlag_AddressSpace32BitNoReserved:
                         aslr_start = svc::AddressSmallMap32Start;
                         aslr_size  = svc::AddressSmallMap32Size;
                         break;
-                    case svc::CreateProcessFlag_AddressSpace64BitDeprecated:
+                    case svc::CreateProcessParameterFlag_AddressSpace64Bit36:
                         aslr_start = svc::AddressSmallMap36Start;
                         aslr_size  = svc::AddressSmallMap36Size;
                         break;
-                    case svc::CreateProcessFlag_AddressSpace64Bit:
+                    case svc::CreateProcessParameterFlag_AddressSpace64Bit39:
                         aslr_start = svc::AddressMap39Start;
                         aslr_size  = svc::AddressMap39Size;
                         break;
+                    case svc::CreateProcessParameterFlag_AddressSpace64Bit42:
+                        aslr_start = svc::AddressMap42Start;
+                        aslr_size  = svc::AddressMap42Size;
+                        break;
                     AMS_UNREACHABLE_DEFAULT_CASE();
                 }
             } else {
                 /* On 1.0.0, only 2 address space types existed. */
-                if (out_param->flags & svc::CreateProcessFlag_AddressSpace64BitDeprecated) {
+                if (out_param->flags & svc::CreateProcessParameterFlag_AddressSpace64Bit36) {
                     aslr_start = svc::AddressSmallMap36Start;
                     aslr_size  = svc::AddressSmallMap36Size;
                 } else {
@@ -627,7 +641,7 @@ namespace ams::ldr {
             /* Set Create Process output. */
             uintptr_t aslr_slide = 0;
             size_t free_size     = (aslr_size - total_size);
-            if (out_param->flags & svc::CreateProcessFlag_EnableAslr) {
+            if (out_param->flags & svc::CreateProcessParameterFlag_EnableAslr) {
                 aslr_slide = GenerateSecureRandom(free_size / os::MemoryBlockUnitSize) * os::MemoryBlockUnitSize;
             }
 
@@ -649,10 +663,13 @@ namespace ams::ldr {
             R_SUCCEED();
         }
 
-        Result LoadAutoLoadModuleSegment(fs::FileHandle file, size_t file_offset, size_t compressed_size, size_t segment_size, bool is_compressed, bool is_zstd, uintptr_t map_base, uintptr_t map_end) {
+        Result LoadAutoLoadModuleSegment(fs::FileHandle file, size_t file_offset, size_t compressed_size, size_t segment_size, bool is_compressed, bool is_zbic, uintptr_t map_base, uintptr_t map_end) {
             /* Select read size based on compression. */
             size_t file_size = is_compressed ? compressed_size : segment_size;
 
+            AMS_LOG("[ldr] Loading segment @ 0x%016lx: compressed=%d, file_size=0x%08lx, compressed_size=0x%08lx, segment_size=0x%08lx\n",
+                    map_base, is_compressed, file_size, compressed_size, segment_size);
+
             /* Validate size. */
             R_UNLESS(file_size <= segment_size,                       ldr::ResultInvalidNso());
             R_UNLESS(file_size    <= std::numeric_limits<s32>::max(), ldr::ResultInvalidNso());
@@ -662,19 +679,19 @@ namespace ams::ldr {
             uintptr_t load_address = is_compressed ? map_end - compressed_size : map_base;
             size_t read_size;
             R_TRY(fs::ReadFile(std::addressof(read_size), file, file_offset, reinterpret_cast<void *>(load_address), file_size));
-            R_UNLESS(read_size == file_size, ldr::ResultInvalidNso());
+            R_UNLESS_LOG(read_size == file_size, ldr::ResultInvalidNso(), "[ldr] Couldn't read segment from file!\n");
 
             /* Uncompress if necessary. */
             R_SUCCEED_IF(!is_compressed);
 
             auto compressed_data_buf = reinterpret_cast<const void *>(load_address);
 
-            if (is_zstd) {
-                bool decompressed = util::DecompressZstdForLoader(reinterpret_cast<void *>(g_zstd_dctx_workspace), ZstdDctxWorkspaceSize, reinterpret_cast<void *>(map_base), static_cast<size_t>(map_end - map_base), segment_size, compressed_data_buf, file_size);
-                R_UNLESS(decompressed, ldr::ResultInvalidNso());
+            if (is_zbic) {
+                bool decompressed = util::DecompressZstdWithBic(reinterpret_cast<void *>(g_zstd_dctx_workspace), sizeof(g_zstd_dctx_workspace), reinterpret_cast<void *>(map_base), static_cast<size_t>(map_end - map_base), segment_size, compressed_data_buf, file_size);
+                R_UNLESS_LOG(decompressed, ldr::ResultInvalidNso(), "[ldr] Failed to decompress segment with zbic!\n");
             } else {
                 bool decompressed = (util::DecompressLZ4(reinterpret_cast<void *>(map_base), segment_size, compressed_data_buf, file_size) == static_cast<int>(segment_size));
-                R_UNLESS(decompressed, ldr::ResultInvalidNso());
+                R_UNLESS_LOG(decompressed, ldr::ResultInvalidNso(), "[ldr] Failed to decompress segment with lz4!\n");
             }
 
             R_SUCCEED();
@@ -689,12 +706,12 @@ namespace ams::ldr {
             crypto::GenerateSha256(hash, sizeof(hash),
                 reinterpret_cast<void *>(map_address + nso_header->segments[segment].dst_offset),
                 nso_header->segments[segment].size);
-            R_UNLESS(std::memcmp(hash, nso_header->segment_hashes[segment], sizeof(hash)) == 0, ldr::ResultInvalidNso());
+            R_UNLESS_LOG(std::memcmp(hash, nso_header->segment_hashes[segment], sizeof(hash)) == 0, ldr::ResultInvalidNso(), "[ldr] Invalid segment hash!\n");
             R_SUCCEED();
         }
 
         Result LoadAutoLoadModule(os::NativeHandle process_handle, fs::FileHandle file, const NsoHeader *nso_header, uintptr_t nso_address, size_t nso_size, size_t map_size) {
-            const bool is_zstd = (nso_header->flags & NsoHeader::Flag_UseZbicCompression) != 0;
+            const bool is_zbic = (nso_header->flags & NsoHeader::Flag_UseZbicCompression) != 0;
 
             const size_t module_size = static_cast<size_t>(nso_header->rw_dst_offset) + util::AlignUp(nso_header->rw_size + nso_header->bss_size, os::MemoryPageSize);
             const size_t arena_size  = (nso_size > module_size) ? (nso_size - module_size) : 0;
@@ -711,11 +728,11 @@ namespace ams::ldr {
 
                 /* Load NSO segments. */
                 R_TRY(LoadAutoLoadModuleSegment(file, nso_header->segments[NsoHeader::Segment_Text].file_offset, nso_header->text_compressed_size, nso_header->text_size,
-                                                      (nso_header->flags & NsoHeader::Flag_CompressedText) != 0, is_zstd, map_address + nso_header->text_dst_offset, map_end));
+                                                      (nso_header->flags & NsoHeader::Flag_CompressedText) != 0, is_zbic, map_address + nso_header->text_dst_offset, map_end));
                 R_TRY(LoadAutoLoadModuleSegment(file, nso_header->segments[NsoHeader::Segment_Ro].file_offset, nso_header->ro_compressed_size, nso_header->ro_size,
-                                                      (nso_header->flags & NsoHeader::Flag_CompressedRo) != 0, is_zstd, map_address + nso_header->ro_dst_offset, map_end));
+                                                      (nso_header->flags & NsoHeader::Flag_CompressedRo) != 0, is_zbic, map_address + nso_header->ro_dst_offset, map_end));
                 R_TRY(LoadAutoLoadModuleSegment(file, nso_header->segments[NsoHeader::Segment_Rw].file_offset, nso_header->rw_compressed_size, nso_header->rw_size,
-                                                      (nso_header->flags & NsoHeader::Flag_CompressedRw) != 0, is_zstd, map_address + nso_header->rw_dst_offset, map_end));
+                                                      (nso_header->flags & NsoHeader::Flag_CompressedRw) != 0, is_zbic, map_address + nso_header->rw_dst_offset, map_end));
 
                 /* Clear unused space to zero. */
                 const size_t text_end = static_cast<size_t>(nso_header->text_dst_offset) + static_cast<size_t>(nso_header->text_size);
@@ -778,15 +795,17 @@ namespace ams::ldr {
 
             for (int i = 0; i < ctx.nso_count; i++) {
                 const NsoIndex nso_idx = static_cast<NsoIndex>(ctx.ali.nso_indices[i]);
+                const bool is_zbic    = (ctx.headers[i].flags & NsoHeader::Flag_UseZbicCompression) != 0;
+                const size_t map_size = is_zbic ? (total_end - process_info->nso_address[i]) : process_info->nso_size[i];
+
+                AMS_LOG("[ldr] module[%d]: idx=%d, path='%s', zbic=%d\n", i, (int)nso_idx, GetNsoPath(nso_idx), is_zbic);
 
                 fs::FileHandle file;
                 R_TRY(fs::OpenFile(std::addressof(file), GetNsoPath(nso_idx), fs::OpenMode_Read));
                 ON_SCOPE_EXIT { fs::CloseFile(file); };
 
-                const bool is_zstd    = (ctx.headers[i].flags & NsoHeader::Flag_UseZbicCompression) != 0;
-                const size_t map_size = is_zstd ? (total_end - process_info->nso_address[i]) : process_info->nso_size[i];
-
-                R_TRY(LoadAutoLoadModule(process_info->process_handle, file, ctx.headers + i, process_info->nso_address[i], process_info->nso_size[i], map_size));
+                R_TRY(LoadAutoLoadModule(process_info->process_handle, file, ctx.headers + i,
+                      process_info->nso_address[i], process_info->nso_size[i], map_size));
             }
 
             /* Load arguments, if present. */
@@ -827,7 +846,7 @@ namespace ams::ldr {
             /* Set the output handle, and ensure that if we fail after this point we clean it up. */
             out->process_handle = process_handle;
             out->code_address   = param.code_address;
-            ON_RESULT_FAILURE { svc::CloseHandle(process_handle); };
+            ON_RESULT_FAILURE { R_DISCARD(svc::CloseHandle(process_handle)); };
 
             /* Load all auto load modules. */
             R_RETURN(LoadAutoLoadModules(out, ctx, argument));
@@ -885,8 +904,8 @@ namespace ams::ldr {
             os::ProcessId process_id = os::GetProcessId(info.process_handle);
 
             /* Register new process. */
-            const auto as_type = GetAddressSpaceType(std::addressof(meta));
-            RoManager::GetInstance().RegisterProcess(pin_id, process_id, meta.aci->program_id, as_type == Npdm::AddressSpaceType_64Bit || as_type == Npdm::AddressSpaceType_64BitDeprecated);
+            const auto as_type = GetProcessAddressSpace(std::addressof(meta));
+            RoManager::GetInstance().RegisterProcess(pin_id, process_id, meta.aci->program_id, as_type == Npdm::ProcessAddressSpace_64Bit39 || as_type == Npdm::ProcessAddressSpace_64Bit36);
 
             /* Register all NSOs. */
             for (int i = 0; i < ctx.nso_count; i++) {
@@ -897,7 +916,7 @@ namespace ams::ldr {
         /* If we're overriding for HBL, perform HTML document redirection. */
         if (override_status.IsHbl()) {
             /* Don't validate result, failure is okay. */
-            RedirectHtmlDocumentPathForHbl(loc);
+            R_DISCARD(RedirectHtmlDocumentPathForHbl(loc));
         }
 
         /* Clear the external code for the program. */

Source/Benchmark-Toolbox/source/bench.c

@@ -8,7 +8,6 @@
  */
 
 #include <math.h>
-#include <pthread.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -24,110 +23,178 @@
 #define ALIGN_PADDING 0x100000
 #define CACHE_LINE_SIZE 128
 
-struct f_data {
-    void (*func)(int64_t *, int64_t *, int);
-    int64_t *arg1;
-    int64_t *arg2;
-    int arg3;
-};
+#define BW_MAX_THREADS 4
 
-static pthread_cond_t p_ready, p_start;
-static pthread_mutex_t p_lock;
-static pthread_t *p_worker = NULL;
-static struct f_data *worker_data = NULL;
-static int p_worker_not_ready, p_workers_ready;
+typedef void (*bench_kernel_fn)(int64_t *dst, int64_t *src, long size);
 
-static void *thread_func(void *data) {
-    struct f_data *d = data;
-    pthread_mutex_lock(&p_lock);
-    p_worker_not_ready--;
-    if (!p_worker_not_ready)
-        pthread_cond_signal(&p_ready);
-    while (p_workers_ready != 1)
-        pthread_cond_wait(&p_start, &p_lock);
-    pthread_mutex_unlock(&p_lock);
-    (d->func)(d->arg1, d->arg2, d->arg3);
-    pthread_exit(NULL);
+struct bw_pool;
+
+typedef struct {
+    Thread thread;
+    Semaphore start;
+    struct bw_pool *pool;
+    bench_kernel_fn func;
+    int64_t *dst;
+    int64_t *src;
+    long size;
+    int core;
+    bool created;
+    uint64_t ticks;
+} bw_worker_t;
+
+typedef struct bw_pool {
+    bw_worker_t workers[BW_MAX_THREADS];
+    Semaphore done;
+    int threads;
+    bool ok;
+} bw_pool_t;
+
+static void bw_worker_entry(void *arg) {
+    bw_worker_t *w = (bw_worker_t *)arg;
+    bw_pool_t *p = w->pool;
+    /* Best-effort pin to own core. */
+    svcSetThreadCoreMask(CUR_THREAD_HANDLE, w->core, (u64)1 << w->core);
+    for (;;) {
+        semaphoreWait(&w->start);
+        bench_kernel_fn f = w->func;
+        if (!f)
+            break;
+        uint64_t t0 = armGetSystemTick();
+        f(w->dst, w->src, w->size);
+        w->ticks = armGetSystemTick() - t0;
+        semaphoreSignal(&p->done);
+    }
 }
 
-static void parallel_run(void) {
-    pthread_mutex_lock(&p_lock);
-    p_workers_ready = 1;
-    pthread_mutex_unlock(&p_lock);
-    pthread_cond_broadcast(&p_start);
+static bool bw_pool_init(bw_pool_t *p, int threads) {
+    memset(p, 0, sizeof(*p));
+    if (threads > BW_MAX_THREADS)
+        threads = BW_MAX_THREADS;
+    p->threads = threads;
+    semaphoreInit(&p->done, 0);
+    s32 prio = 0x2C;
+    svcGetThreadPriority(&prio, CUR_THREAD_HANDLE);
+    for (int i = 0; i < threads; i++) {
+        bw_worker_t *w = &p->workers[i];
+        w->core = i;
+        w->func = NULL;
+        w->pool = p;
+        semaphoreInit(&w->start, 0);
+        if (R_FAILED(threadCreate(&w->thread, bw_worker_entry, w, NULL, 0x8000, prio, i)))
+            return false;
+        w->created = true;
+        if (R_FAILED(threadStart(&w->thread)))
+            return false;
+    }
+    p->ok = true;
+    return true;
 }
 
-static void parallel_init(int threads) {
-    pthread_attr_t attr;
-    pthread_cond_init(&p_ready, NULL);
-    pthread_cond_init(&p_start, NULL);
-    pthread_mutex_init(&p_lock, NULL);
-    p_worker_not_ready = threads;
-    p_workers_ready = 0;
-    pthread_attr_init(&attr);
-    if (!p_worker || !worker_data) {
-        p_worker = malloc(threads * sizeof(pthread_t));
-        worker_data = malloc(threads * sizeof(struct f_data));
+static void bw_pool_free(bw_pool_t *p) {
+    for (int i = 0; i < p->threads; i++) {
+        bw_worker_t *w = &p->workers[i];
+        if (w->created) {
+            w->func = NULL; /* shutdown */
+            semaphoreSignal(&w->start);
+        }
+    }
+    for (int i = 0; i < p->threads; i++) {
+        bw_worker_t *w = &p->workers[i];
+        if (w->created) {
+            threadWaitForExit(&w->thread);
+            threadClose(&w->thread);
+            w->created = false;
+        }
+    }
+    p->ok = false;
+}
+
+static double bw_run_once(bw_pool_t *p, bench_kernel_fn f, int64_t *dstbuf, int64_t *srcbuf, long size) {
+    int threads = p->threads;
+    for (int i = 0; i < threads; i++) {
+        bw_worker_t *w = &p->workers[i];
+        w->func = f;
+        w->dst = dstbuf + (size * i) / (long)sizeof(int64_t);
+        w->src = srcbuf + (size * i) / (long)sizeof(int64_t);
+        w->size = size;
     }
     for (int i = 0; i < threads; i++)
-        pthread_create(p_worker + i, &attr, thread_func, worker_data + i);
-    pthread_mutex_lock(&p_lock);
-    while (p_worker_not_ready != 0)
-        pthread_cond_wait(&p_ready, &p_lock);
-    pthread_mutex_unlock(&p_lock);
+        semaphoreSignal(&p->workers[i].start);
+    for (int i = 0; i < threads; i++)
+        semaphoreWait(&p->done);
+    uint64_t sum = 0;
+    for (int i = 0; i < threads; i++)
+        sum += p->workers[i].ticks;
+    return (double)armTicksToNs(sum) / 1000000000.0 / threads;
 }
 
-static void aligned_block_copy(int64_t *__restrict dst_, int64_t *__restrict src, int size) {
-    volatile int64_t *dst = dst_;
-    int64_t t1, t2, t3, t4;
-    while ((size -= 64) >= 0) {
-        t1 = *src++;
-        t2 = *src++;
-        t3 = *src++;
-        t4 = *src++;
-        *dst++ = t1;
-        *dst++ = t2;
-        *dst++ = t3;
-        *dst++ = t4;
-        t1 = *src++;
-        t2 = *src++;
-        t3 = *src++;
-        t4 = *src++;
-        *dst++ = t1;
-        *dst++ = t2;
-        *dst++ = t3;
-        *dst++ = t4;
-    }
-}
+#define BW_GPR_CLOBBERS \
+    "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18"
 
-static void aligned_block_fetch(int64_t *__restrict dst, int64_t *__restrict src_, int size) {
-    volatile int64_t *src = src_;
-    (void)dst;
-    while ((size -= 64) >= 0) {
-        *src++;
-        *src++;
-        *src++;
-        *src++;
-        *src++;
-        *src++;
-        *src++;
-        *src++;
-    }
+static void aligned_block_copy(int64_t *dst, int64_t *src, long size) {
+    __asm__ __volatile__(
+        "1:\n"
+        "ldp x3, x4,   [%[s], #0x00]\n"
+        "ldp x5, x6,   [%[s], #0x10]\n"
+        "ldp x7, x8,   [%[s], #0x20]\n"
+        "ldp x9, x10,  [%[s], #0x30]\n"
+        "ldp x11, x12, [%[s], #0x40]\n"
+        "ldp x13, x14, [%[s], #0x50]\n"
+        "ldp x15, x16, [%[s], #0x60]\n"
+        "ldp x17, x18, [%[s], #0x70]\n"
+        "add %[s], %[s], #0x80\n"
+        "stp x3, x4,   [%[d], #0x00]\n"
+        "stp x5, x6,   [%[d], #0x10]\n"
+        "stp x7, x8,   [%[d], #0x20]\n"
+        "stp x9, x10,  [%[d], #0x30]\n"
+        "stp x11, x12, [%[d], #0x40]\n"
+        "stp x13, x14, [%[d], #0x50]\n"
+        "stp x15, x16, [%[d], #0x60]\n"
+        "stp x17, x18, [%[d], #0x70]\n"
+        "add %[d], %[d], #0x80\n"
+        "subs %[n], %[n], #0x80\n"
+        "b.gt 1b\n"
+        : [s] "+r"(src), [d] "+r"(dst), [n] "+r"(size)
+        :
+        : BW_GPR_CLOBBERS, "cc", "memory");
 }
-
-static void aligned_block_fill(int64_t *__restrict dst_, int64_t *__restrict src, int size) {
-    volatile int64_t *dst = dst_;
-    int64_t data = *src;
-    while ((size -= 64) >= 0) {
-        *dst++ = data;
-        *dst++ = data;
-        *dst++ = data;
-        *dst++ = data;
-        *dst++ = data;
-        *dst++ = data;
-        *dst++ = data;
-        *dst++ = data;
-    }
+static void aligned_block_fetch(int64_t *dst, int64_t *src, long size) {
+    (void)src;
+    __asm__ __volatile__(
+        "1:\n"
+        "ldp x3, x4,   [%[p], #0x00]\n"
+        "ldp x5, x6,   [%[p], #0x10]\n"
+        "ldp x7, x8,   [%[p], #0x20]\n"
+        "ldp x9, x10,  [%[p], #0x30]\n"
+        "ldp x11, x12, [%[p], #0x40]\n"
+        "ldp x13, x14, [%[p], #0x50]\n"
+        "ldp x15, x16, [%[p], #0x60]\n"
+        "ldp x17, x18, [%[p], #0x70]\n"
+        "add %[p], %[p], #0x80\n"
+        "subs %[n], %[n], #0x80\n"
+        "b.gt 1b\n"
+        : [p] "+r"(dst), [n] "+r"(size)
+        :
+        : BW_GPR_CLOBBERS, "cc", "memory");
+}
+static void aligned_block_fill(int64_t *dst, int64_t *src, long size) {
+    (void)src;
+    __asm__ __volatile__(
+        "1:\n"
+        "stp x3, x4,   [%[d], #0x00]\n"
+        "stp x5, x6,   [%[d], #0x10]\n"
+        "stp x7, x8,   [%[d], #0x20]\n"
+        "stp x9, x10,  [%[d], #0x30]\n"
+        "stp x11, x12, [%[d], #0x40]\n"
+        "stp x13, x14, [%[d], #0x50]\n"
+        "stp x15, x16, [%[d], #0x60]\n"
+        "stp x17, x18, [%[d], #0x70]\n"
+        "add %[d], %[d], #0x80\n"
+        "subs %[n], %[n], #0x80\n"
+        "b.gt 1b\n"
+        : [d] "+r"(dst), [n] "+r"(size)
+        :
+        : BW_GPR_CLOBBERS, "cc", "memory");
 }
 
 static double gettime(void) {
@@ -136,47 +203,29 @@ static double gettime(void) {
     return (double)((int64_t)tv.tv_sec * 1000000 + tv.tv_usec) / 1000000.;
 }
 
-static double bandwidth_bench_helper(int threads, int64_t *dstbuf, int64_t *srcbuf, int size, void (*f)(int64_t *, int64_t *, int)) {
+static double bandwidth_bench_helper(bw_pool_t *pool, int threads, int64_t *dstbuf, int64_t *srcbuf, long size, bench_kernel_fn f) {
     int i, loopcount, innerloopcount, n;
-    double t, t1, t2, speed, maxspeed, s, s0, s1, s2;
+    double t, speed, maxspeed;
+
+    if (!pool || !pool->ok)
+        return 0.;
 
-    s = s0 = s1 = s2 = 0.;
     maxspeed = 0.;
     for (n = 0; n < MAXREPEATS; n++) {
+        bw_run_once(pool, f, dstbuf, srcbuf, size);
         loopcount = 0;
         innerloopcount = 1;
         t = 0.;
         do {
             loopcount += innerloopcount;
-            for (i = 0; i < innerloopcount; i++) {
-                parallel_init(threads);
-                for (int pt = 0; pt < threads; pt++) {
-                    (worker_data + pt)->func = f;
-                    (worker_data + pt)->arg1 = dstbuf + size * pt / sizeof(int64_t);
-                    (worker_data + pt)->arg2 = srcbuf + size * pt / sizeof(int64_t);
-                    (worker_data + pt)->arg3 = size;
-                }
-                t1 = gettime();
-                parallel_run();
-                for (int pt = 0; pt < threads; pt++)
-                    pthread_join(p_worker[pt], NULL);
-                t2 = gettime();
-                t += t2 - t1;
-            }
+            for (i = 0; i < innerloopcount; i++)
+                t += bw_run_once(pool, f, dstbuf, srcbuf, size);
             innerloopcount *= 2;
-        } while (t < 0.5);
+        } while (t < 0.25);
 
         speed = (double)size * threads * loopcount / t / 1000000.;
-        s0 += 1.;
-        s1 += speed;
-        s2 += speed * speed;
         if (speed > maxspeed)
             maxspeed = speed;
-        if (s0 > 2.) {
-            s = sqrt((s0 * s2 - s1 * s1) / (s0 * (s0 - 1)));
-            if (s < maxspeed / 1000.)
-                break;
-        }
     }
     return maxspeed;
 }
@@ -306,13 +355,16 @@ void bench_run_full(bench_results_t *out, bench_progress_fn progress, void *user
 
     int64_t *srcbuf, *dstbuf;
     void *poolbuf = alloc_nonaliased_buffers((void **)&srcbuf, size * threads, (void **)&dstbuf, size * threads, NULL, 0);
+    bw_pool_t bw;
+    bw_pool_init(&bw, threads);
 
     STEP("CPU copy", 0.40f);
-    out->cpu_copy = bandwidth_bench_helper(threads, dstbuf, srcbuf, size, aligned_block_copy);
+    out->cpu_copy = bandwidth_bench_helper(&bw, threads, dstbuf, srcbuf, size, aligned_block_copy);
     STEP("CPU read", 0.55f);
-    out->cpu_read = bandwidth_bench_helper(threads, dstbuf, srcbuf, size, aligned_block_fetch);
+    out->cpu_read = bandwidth_bench_helper(&bw, threads, dstbuf, srcbuf, size, aligned_block_fetch);
     STEP("CPU write", 0.70f);
-    out->cpu_write = bandwidth_bench_helper(threads, dstbuf, srcbuf, size, aligned_block_fill);
+    out->cpu_write = bandwidth_bench_helper(&bw, threads, dstbuf, srcbuf, size, aligned_block_fill);
+    bw_pool_free(&bw);
     free(poolbuf);
 
     STEP("Latency", 0.85f);
@@ -325,9 +377,10 @@ void bench_run_full(bench_results_t *out, bench_progress_fn progress, void *user
 struct bench_ctx {
     int phase;
     bool is_4gb;
-    void *pool;
+    void *buf;
     int64_t *src;
     int64_t *dst;
+    bw_pool_t bw;
 };
 
 bench_ctx *bench_begin(void) {
@@ -335,7 +388,8 @@ bench_ctx *bench_begin(void) {
     if (!c)
         return NULL;
     c->is_4gb = (appletGetAppletType() == AppletType_Application);
-    c->pool = alloc_nonaliased_buffers((void **)&c->src, SIZE * 3, (void **)&c->dst, SIZE * 3, NULL, 0);
+    c->buf = alloc_nonaliased_buffers((void **)&c->src, SIZE * 3, (void **)&c->dst, SIZE * 3, NULL, 0);
+    bw_pool_init(&c->bw, 3);
     return c;
 }
 
@@ -349,24 +403,25 @@ bool bench_step(bench_ctx *c, bench_results_t *out, const char **label, float *f
             *frac = 0.25f;
             break;
         case 1:
-            out->cpu_copy = bandwidth_bench_helper(threads, c->dst, c->src, size, aligned_block_copy);
+            out->cpu_copy = bandwidth_bench_helper(&c->bw, threads, c->dst, c->src, size, aligned_block_copy);
             *label = "CPU copy";
             *frac = 0.45f;
             break;
         case 2:
-            out->cpu_read = bandwidth_bench_helper(threads, c->dst, c->src, size, aligned_block_fetch);
+            out->cpu_read = bandwidth_bench_helper(&c->bw, threads, c->dst, c->src, size, aligned_block_fetch);
             *label = "CPU read";
             *frac = 0.60f;
             break;
         case 3:
-            out->cpu_write = bandwidth_bench_helper(threads, c->dst, c->src, size, aligned_block_fill);
+            out->cpu_write = bandwidth_bench_helper(&c->bw, threads, c->dst, c->src, size, aligned_block_fill);
             *label = "CPU write";
             *frac = 0.75f;
             break;
         case 4:
-            if (c->pool) {
-                free(c->pool);
-                c->pool = NULL;
+            bw_pool_free(&c->bw);
+            if (c->buf) {
+                free(c->buf);
+                c->buf = NULL;
             }
             latency_bench(&out->l2_ns, &out->ram_ns);
             *label = "Latency";
@@ -384,7 +439,8 @@ bool bench_step(bench_ctx *c, bench_results_t *out, const char **label, float *f
 void bench_end(bench_ctx *c) {
     if (!c)
         return;
-    if (c->pool)
-        free(c->pool);
+    bw_pool_free(&c->bw);
+    if (c->buf)
+        free(c->buf);
     free(c);
-}
+}

Source/Old-Atmosphere-Patches/ldr_process_creation_1_12_0.cpp

@@ -0,0 +1,960 @@
+/*
+ * 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 "ldr_capabilities.hpp"
+#include "ldr_content_management.hpp"
+#include "ldr_development_manager.hpp"
+#include "ldr_launch_record.hpp"
+#include "ldr_meta.hpp"
+#include "ldr_patcher.hpp"
+#include "ldr_process_creation.hpp"
+#include "ldr_ro_manager.hpp"
+#include "oc/oc_loader.hpp"
+
+namespace ams::ldr {
+
+    namespace {
+
+        /* Convenience defines. */
+        constexpr size_t SystemResourceSizeMax = 0x1FE00000;
+        constexpr size_t AutoLoadModuleSizeMax = 0x800000000;
+
+        /* Types. */
+        enum NsoIndex {
+            Nso_Rtld    =  0,
+            Nso_Main    =  1,
+            Nso_Wkc0    =  2,
+            Nso_Wkc1    =  3,
+            Nso_Wkc2    =  4,
+            Nso_Wkc3    =  5,
+            Nso_Wkc4    =  6,
+            Nso_Wkc5    =  7,
+            Nso_Wkc6    =  8,
+            Nso_Wkc7    =  9,
+            Nso_Wkc8    = 10,
+            Nso_Wkc9    = 11,
+            Nso_SubSdk0 = 12,
+            Nso_SubSdk1 = 13,
+            Nso_SubSdk2 = 14,
+            Nso_SubSdk3 = 15,
+            Nso_SubSdk4 = 16,
+            Nso_SubSdk5 = 17,
+            Nso_SubSdk6 = 18,
+            Nso_SubSdk7 = 19,
+            Nso_SubSdk8 = 20,
+            Nso_SubSdk9 = 21,
+            Nso_Sdk     = 22,
+            Nso_Count,
+        };
+
+        constexpr inline const char *NsoPaths[Nso_Count] = {
+            ENCODE_ATMOSPHERE_CODE_PATH("/rtld"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/main"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc0"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc1"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc2"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc3"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc4"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc5"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc6"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc7"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc8"),
+            ENCODE_ATMOSPHERE_BDLL_PATH("/wkc9"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk0"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk1"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk2"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk3"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk4"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk5"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk6"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk7"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk8"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/subsdk9"),
+            ENCODE_ATMOSPHERE_CODE_PATH("/sdk"),
+        };
+
+        constexpr const char *GetNsoPath(size_t idx) {
+            AMS_ABORT_UNLESS(idx < Nso_Count);
+            return NsoPaths[idx];
+        }
+
+        struct ProcessInfo {
+            os::NativeHandle process_handle;
+            uintptr_t code_address;
+            size_t    total_size;
+            uintptr_t args_address;
+            size_t    args_size;
+            uintptr_t nso_address[Nso_Count];
+            size_t    nso_size[Nso_Count];
+        };
+
+        struct AutoLoadModuleInfo {
+            bool has_rtld;
+            bool has_main;
+            bool has_sdk;
+            bool has_subsdk;
+            s8   nso_indices[Nso_Count];
+        };
+
+        struct AutoLoadModuleContext {
+            NsoHeader *headers;
+            int        nso_count;
+            int        rtld_idx;
+            int        main_nso_idx;
+            int        sdk_nso_idx;
+            AutoLoadModuleInfo ali;
+        };
+
+        /* Global NSO header cache. */
+        NsoHeader g_nso_headers[Nso_Count];
+
+        /* Pcv/Ptm/NvServices check cache */
+        bool g_is_pcv;
+        bool g_is_ptm;
+        bool g_is_nvsrv;
+
+        /* Global Zstd decompression context. */
+        constexpr size_t ZstdDctxWorkspaceSize = 0x176E8;
+        alignas(8) u8 g_zstd_dctx_workspace[ZstdDctxWorkspaceSize];
+
+        Result ValidateProgramVersion(ncm::ProgramId program_id, u32 version) {
+            /* No version verification is done before 8.1.0. */
+            R_SUCCEED_IF(hos::GetVersion() < hos::Version_8_1_0);
+
+            /* No verification is done if development. */
+            R_SUCCEED_IF(IsDevelopmentForAntiDowngradeCheck());
+
+            /* TODO: Anti-downgrade checking does not make very much sense for us. Should we do anything? */
+            AMS_UNUSED(program_id, version);
+
+            R_SUCCEED();
+        }
+
+        /* Helpers. */
+        Result GetProgramInfoFromMeta(ProgramInfo *out, const Meta *meta) {
+            /* Copy basic info. */
+            out->main_thread_priority   = meta->npdm->main_thread_priority;
+            out->default_cpu_id         = meta->npdm->default_cpu_id;
+            out->main_thread_stack_size = meta->npdm->main_thread_stack_size;
+            out->program_id             = meta->aci->program_id;
+
+            /* Copy access controls. */
+            size_t offset = 0;
+#define COPY_ACCESS_CONTROL(source, which) \
+            ({ \
+                const size_t size = meta->source->which##_size; \
+                R_UNLESS(offset + size <= sizeof(out->ac_buffer), ldr::ResultInternalError()); \
+                out->source##_##which##_size = size; \
+                std::memcpy(out->ac_buffer + offset, meta->source##_##which, size); \
+                offset += size; \
+            })
+
+            /* Copy all access controls to buffer. */
+            COPY_ACCESS_CONTROL(acid, sac);
+            COPY_ACCESS_CONTROL(aci, sac);
+            COPY_ACCESS_CONTROL(acid, fac);
+            COPY_ACCESS_CONTROL(aci, fah);
+#undef COPY_ACCESS_CONTROL
+
+            /* Copy flags. */
+            out->flags = MakeProgramInfoFlag(static_cast<const util::BitPack32 *>(meta->aci_kac), meta->aci->kac_size / sizeof(util::BitPack32));
+            R_SUCCEED();
+        }
+
+        bool IsApplet(const Meta *meta) {
+            return (MakeProgramInfoFlag(static_cast<const util::BitPack32 *>(meta->aci_kac), meta->aci->kac_size / sizeof(util::BitPack32)) & ProgramInfoFlag_ApplicationTypeMask) == ProgramInfoFlag_Applet;
+        }
+
+        bool IsApplication(const Meta *meta) {
+            return (MakeProgramInfoFlag(static_cast<const util::BitPack32 *>(meta->aci_kac), meta->aci->kac_size / sizeof(util::BitPack32)) & ProgramInfoFlag_ApplicationTypeMask) == ProgramInfoFlag_Application;
+        }
+
+        Npdm::AddressSpaceType GetAddressSpaceType(const Meta *meta) {
+            return static_cast<Npdm::AddressSpaceType>((meta->npdm->flags & Npdm::MetaFlag_AddressSpaceTypeMask) >> Npdm::MetaFlag_AddressSpaceTypeShift);
+        }
+
+        Acid::PoolPartition GetPoolPartition(const Meta *meta) {
+            return static_cast<Acid::PoolPartition>((meta->acid->flags & Acid::AcidFlag_PoolPartitionMask) >> Acid::AcidFlag_PoolPartitionShift);
+        }
+
+        Result LoadAutoLoadHeaders(AutoLoadModuleContext &ctx, u32 acid_flags) {
+            /* Clear NSOs. */
+            std::memset(g_nso_headers, 0, sizeof(g_nso_headers));
+            ctx.headers      = g_nso_headers;
+            ctx.nso_count    = 0;
+            ctx.rtld_idx     = -1;
+            ctx.main_nso_idx = -1;
+            ctx.sdk_nso_idx  = -1;
+            ctx.ali          = {};
+
+            for (size_t i = 0; i < Nso_Count; i++) {
+                /* Only load browser DLLs if acid flags say to do so. */
+                switch (i) {
+                    case Nso_Wkc0:
+                    case Nso_Wkc1:
+                    case Nso_Wkc2:
+                    case Nso_Wkc3:
+                    case Nso_Wkc4:
+                    case Nso_Wkc5:
+                    case Nso_Wkc6:
+                    case Nso_Wkc7:
+                    case Nso_Wkc8:
+                    case Nso_Wkc9:
+                        if ((acid_flags & Acid::AcidFlag_LoadBrowserCoreDll) == 0) {
+                            continue;
+                        }
+                        break;
+                }
+
+                fs::FileHandle file;
+                if (R_SUCCEEDED(fs::OpenFile(std::addressof(file), GetNsoPath(i), fs::OpenMode_Read))) {
+                    ON_SCOPE_EXIT { fs::CloseFile(file); };
+
+                    /* Read NSO header. */
+                    size_t read_size;
+                    R_TRY(fs::ReadFile(std::addressof(read_size), file, 0, g_nso_headers + ctx.nso_count, sizeof(NsoHeader)));
+                    R_UNLESS(read_size == sizeof(NsoHeader), ldr::ResultInvalidNso());
+
+                    /* Note nso is present. */
+                    switch (i) {
+                        case Nso_Rtld:
+                            ctx.rtld_idx = ctx.nso_count;
+                            ctx.ali.has_rtld = true;
+                            break;
+                        case Nso_Main:
+                            ctx.main_nso_idx = ctx.nso_count;
+                            ctx.ali.has_main = true;
+                            break;
+                        case Nso_SubSdk0:
+                        case Nso_SubSdk1:
+                        case Nso_SubSdk2:
+                        case Nso_SubSdk3:
+                        case Nso_SubSdk4:
+                        case Nso_SubSdk5:
+                        case Nso_SubSdk6:
+                        case Nso_SubSdk7:
+                        case Nso_SubSdk8:
+                        case Nso_SubSdk9:
+                            ctx.ali.has_subsdk = true;
+                            break;
+                        case Nso_Sdk:
+                            ctx.sdk_nso_idx = ctx.nso_count;
+                            ctx.ali.has_sdk = true;
+                            break;
+                    }
+                    ctx.ali.nso_indices[ctx.nso_count] = static_cast<s8>(i);
+                    ctx.nso_count++;
+                }
+            }
+
+            R_SUCCEED();
+        }
+
+        Result CheckAutoLoad(const AutoLoadModuleContext &ctx, u32 acid_flags) {
+            /* We must always have a main. */
+            R_UNLESS(ctx.ali.has_main, ldr::ResultInvalidNso());
+
+            /* Validate flags and extents for all present NSOs. */
+            for (int i = 0; i < ctx.nso_count; ++i) {
+                const auto &hdr = ctx.headers[i];
+
+                /* All NSOs must not be --X. */
+                /* This is "probably" not checked on Ounce? */
+                R_UNLESS((hdr.flags & NsoHeader::Flag_PreventCodeReads) == 0, ldr::ResultInvalidNso());
+
+                /* Zstd compression only allowed on main, and only when both rtld+sdk are present. */
+                if (i != ctx.main_nso_idx || ctx.rtld_idx < 0 || ctx.sdk_nso_idx < 0) {
+                    R_UNLESS((hdr.flags & NsoHeader::Flag_UseZbicCompression) == 0, ldr::ResultInvalidNso());
+                }
+
+                /* NSOs must have page-aligned segments. */
+                R_UNLESS(util::IsAligned(hdr.text_dst_offset, os::MemoryPageSize), ldr::ResultInvalidNso());
+                R_UNLESS(util::IsAligned(hdr.ro_dst_offset,   os::MemoryPageSize), ldr::ResultInvalidNso());
+                R_UNLESS(util::IsAligned(hdr.rw_dst_offset,   os::MemoryPageSize), ldr::ResultInvalidNso());
+
+                /* NSOs must have zero text offset. */
+                R_UNLESS(hdr.text_dst_offset == 0, ldr::ResultInvalidNso());
+
+                /* NSO .text must precede .rodata. */
+                const size_t text_end = static_cast<size_t>(hdr.text_dst_offset) + static_cast<size_t>(hdr.text_size);
+                R_UNLESS(text_end <= static_cast<size_t>(hdr.ro_dst_offset), ldr::ResultInvalidNso());
+
+                /* NSO .rodata must precede .rwdata. */
+                const size_t ro_end = static_cast<size_t>(hdr.ro_dst_offset) + static_cast<size_t>(hdr.ro_size);
+                R_UNLESS(ro_end <= static_cast<size_t>(hdr.rw_dst_offset), ldr::ResultInvalidNso());
+            }
+
+            const bool has_browser_dll = (acid_flags & Acid::AcidFlag_LoadBrowserCoreDll) != 0;
+            if (ctx.ali.has_rtld || ctx.ali.has_sdk) {
+                /* If we have sdk we must have rtld. */
+                R_UNLESS(ctx.ali.has_rtld, ldr::ResultInvalidNso());
+
+                /* If we have rtld, we must not have browser core dll. */
+                R_UNLESS(!has_browser_dll, ldr::ResultInvalidNso());
+            } else {
+                /* We must not have both subsdk and browser dll. */
+                R_UNLESS(!(ctx.ali.has_subsdk && has_browser_dll), ldr::ResultInvalidNso());
+            }
+
+            R_SUCCEED();
+        }
+
+        constexpr const ncm::ProgramId UnqualifiedApprovalProgramIds[] = {
+            { 0x010003F003A34000 }, /* Pokemon: Let's Go, Pikachu! */
+            { 0x0100152000022000 }, /* Mario Kart 8 Deluxe */
+            { 0x0100165003504000 }, /* Nintendo Labo Toy-Con 04: VR Kit */
+            { 0x0100187003A36000 }, /* Pokemon: Let's Go, Eevee! */
+            { 0x01002E5008C56000 }, /* Pokemon Sword [Live Tournament] */
+            { 0x01002FF008C24000 }, /* Ring Fit Adventure */
+            { 0x010049900F546001 }, /* Super Mario 3D All-Stars: Super Mario 64 */
+            { 0x010057D00ECE4000 }, /* Nintendo Switch Online (Nintendo 64) [for Japan] */
+            { 0x01006F8002326000 }, /* Animal Crossing: New Horizons */
+            { 0x01006FB00F50E000 }, /* 宝可梦 走吧！伊布 [Pokemon: Let's Go, Eevee! for China] */
+            { 0x010070300F50C000 }, /* 宝可梦 走吧！皮卡丘 [Pokemon: Let's Go, Pikachu! for China] */
+            { 0x010075100E8EC000 }, /* 马力欧卡丁车8 豪华版 [Mario Kart 8 Deluxe for China] */
+            { 0x01008DB008C2C000 }, /* Pokemon Shield */
+            { 0x01009AD008C4C000 }, /* Pokemon: Let's Go, Pikachu! [Kiosk] */
+            { 0x0100A66003384000 }, /* Hulu */
+            { 0x0100ABF008968000 }, /* Pokemon Sword */
+            { 0x0100C9A00ECE6000 }, /* Nintendo Switch Online (Nintendo 64) [for America] */
+            { 0x0100ED100BA3A000 }, /* Mario Kart Live: Home Circuit */
+            { 0x0100F38011CFE000 }, /* Animal Crossing: New Horizons Island Transfer Tool */
+            { 0x0100F6B011028000 }, /* 健身环大冒险 [Ring Fit Adventure for China] */
+        };
+
+        /* Check that the unqualified approval programs are sorted. */
+        static_assert([]() -> bool {
+            for (size_t i = 0; i < util::size(UnqualifiedApprovalProgramIds) - 1; ++i) {
+                if (UnqualifiedApprovalProgramIds[i].value >= UnqualifiedApprovalProgramIds[i + 1].value) {
+                    return false;
+                }
+            }
+
+            return true;
+        }());
+
+        bool IsUnqualifiedApprovalProgramId(ncm::ProgramId program_id) {
+            /* Check if the program id is one with unqualified approval. */
+            return std::binary_search(std::begin(UnqualifiedApprovalProgramIds), std::end(UnqualifiedApprovalProgramIds), program_id);
+        }
+
+        bool IsUnqualifiedApproval(const Meta *meta) {
+            /* If the meta has unqualified approval flag, it's unqualified approval. */
+            if (meta->acid->flags & ldr::Acid::AcidFlag_UnqualifiedApproval) {
+                return true;
+            }
+
+            /* If the unqualified approval flag is not set, the program must be an application. */
+            if (!IsApplication(meta)) {
+                return false;
+            }
+
+            /* The program id must be a force unqualified approval program id. */
+            return IsUnqualifiedApprovalProgramId(meta->acid->program_id_min) && meta->acid->program_id_min == meta->acid->program_id_max;
+        }
+
+        Result ValidateMeta(const Meta *meta, const ncm::ProgramLocation &loc, const fs::CodeVerificationData &code_verification_data) {
+            /* Validate version. */
+            R_TRY(ValidateProgramVersion(loc.program_id, meta->npdm->version));
+
+            /* Validate program id. */
+            R_UNLESS(meta->aci->program_id >= meta->acid->program_id_min, ldr::ResultInvalidProgramId());
+            R_UNLESS(meta->aci->program_id <= meta->acid->program_id_max, ldr::ResultInvalidProgramId());
+
+            /* Validate the kernel capabilities. */
+            R_TRY(TestCapability(static_cast<const util::BitPack32 *>(meta->acid_kac), meta->acid->kac_size / sizeof(util::BitPack32), static_cast<const util::BitPack32 *>(meta->aci_kac), meta->aci->kac_size / sizeof(util::BitPack32)));
+
+            /* Check if NCA is PCV or PTM */
+            g_is_pcv = meta->aci->program_id == ncm::SystemProgramId::Pcv;
+            g_is_ptm = meta->aci->program_id == ncm::SystemProgramId::Ptm;
+            g_is_nvsrv = meta->aci->program_id == ncm::SystemProgramId::NvServices;
+
+            /* If we have data to validate, validate it. */
+            if (meta->check_verification_data) {
+                const u8 *sig         = code_verification_data.signature;
+                const size_t sig_size = sizeof(code_verification_data.signature);
+                const u8 *mod         = static_cast<u8 *>(meta->modulus);
+                const size_t mod_size = crypto::Rsa2048PssSha256Verifier::ModulusSize;
+                const u8 *exp         = fssystem::GetAcidSignatureKeyPublicExponent();
+                const size_t exp_size = fssystem::AcidSignatureKeyPublicExponentSize;
+                const u8 *hsh         = code_verification_data.target_hash;
+                const size_t hsh_size = sizeof(code_verification_data.target_hash);
+                const bool is_signature_valid = crypto::VerifyRsa2048PssSha256WithHash(sig, sig_size, mod, mod_size, exp, exp_size, hsh, hsh_size);
+
+                /* If the signature check fails, we need to check if this is allowable. */
+                if (!is_signature_valid) {
+                    /* We have to enforce signature checks on prod and when we have a signature to check on dev. */
+                    R_UNLESS(IsDevelopmentForAcidProductionCheck(), ldr::ResultInvalidNcaSignature());
+                    R_UNLESS(!code_verification_data.has_data,      ldr::ResultInvalidNcaSignature());
+
+                    /* There was no signature to check on dev. Check if this is acceptable. */
+                    R_UNLESS(IsUnqualifiedApproval(meta), ldr::ResultInvalidNcaSignature());
+                }
+            }
+
+            /* All good. */
+            R_SUCCEED();
+        }
+
+        Result GetCreateProcessFlags(u32 *out, const Meta *meta, const u32 ldr_flags) {
+            const u8 meta_flags = meta->npdm->flags;
+
+            u32 flags = 0;
+
+            /* Set Is64Bit. */
+            if (meta_flags & Npdm::MetaFlag_Is64Bit) {
+                flags |= svc::CreateProcessFlag_Is64Bit;
+            }
+
+            /* Set AddressSpaceType. */
+            switch (GetAddressSpaceType(meta)) {
+                case Npdm::AddressSpaceType_32Bit:
+                    flags |= svc::CreateProcessFlag_AddressSpace32Bit;
+                    break;
+                case Npdm::AddressSpaceType_64BitDeprecated:
+                    flags |= svc::CreateProcessFlag_AddressSpace64BitDeprecated;
+                    break;
+                case Npdm::AddressSpaceType_32BitWithoutAlias:
+                    flags |= svc::CreateProcessFlag_AddressSpace32BitWithoutAlias;
+                    break;
+                case Npdm::AddressSpaceType_64Bit:
+                    flags |= svc::CreateProcessFlag_AddressSpace64Bit;
+                    break;
+                default:
+                    R_THROW(ldr::ResultInvalidMeta());
+            }
+
+            /* Set Enable Debug. */
+            if (ldr_flags & CreateProcessFlag_EnableDebug) {
+                flags |= svc::CreateProcessFlag_EnableDebug;
+            }
+
+            /* Set Enable ASLR. */
+            if (!(ldr_flags & CreateProcessFlag_DisableAslr)) {
+                flags |= svc::CreateProcessFlag_EnableAslr;
+            }
+
+            /* Set Is Application. */
+            if (IsApplication(meta)) {
+                flags |= svc::CreateProcessFlag_IsApplication;
+
+                /* 7.0.0+: Set OptimizeMemoryAllocation if relevant. */
+                if (hos::GetVersion() >= hos::Version_7_0_0) {
+                    if (meta_flags & Npdm::MetaFlag_OptimizeMemoryAllocation) {
+                        flags |= svc::CreateProcessFlag_OptimizeMemoryAllocation;
+                    }
+                }
+            }
+
+            /* 5.0.0+ Set Pool Partition. */
+            if (hos::GetVersion() >= hos::Version_5_0_0) {
+                /* TODO: Nintendo no longer accepts Applet when pool partition == application. Would this break hbl/anything else in the hb ecosystem? */
+                /* TODO: Nintendo uses a helper bool MakeSvcPoolPartitionFlag(u32 *out, Acid::PoolPartition partition); */
+                switch (GetPoolPartition(meta)) {
+                    case Acid::PoolPartition_Application:
+                        if (IsApplet(meta)) {
+                            flags |= svc::CreateProcessFlag_PoolPartitionApplet;
+                        } else {
+                            flags |= svc::CreateProcessFlag_PoolPartitionApplication;
+                        }
+                        break;
+                    case Acid::PoolPartition_Applet:
+                        flags |= svc::CreateProcessFlag_PoolPartitionApplet;
+                        break;
+                    case Acid::PoolPartition_System:
+                        flags |= svc::CreateProcessFlag_PoolPartitionSystem;
+                        break;
+                    case Acid::PoolPartition_SystemNonSecure:
+                        flags |= svc::CreateProcessFlag_PoolPartitionSystemNonSecure;
+                        break;
+                    default:
+                        R_THROW(ldr::ResultInvalidMeta());
+                }
+            } else if (hos::GetVersion() >= hos::Version_4_0_0) {
+                /* On 4.0.0+, the corresponding bit was simply "UseSecureMemory". */
+                if (meta->acid->flags & Acid::AcidFlag_DeprecatedUseSecureMemory) {
+                    flags |= svc::CreateProcessFlag_DeprecatedUseSecureMemory;
+                }
+            }
+
+            /* 11.0.0+/meso Set Disable DAS merge. */
+            if (meta_flags & Npdm::MetaFlag_DisableDeviceAddressSpaceMerge) {
+                flags |= svc::CreateProcessFlag_DisableDeviceAddressSpaceMerge;
+            }
+
+            /* 18.0.0+/meso Set Alias region extra size. */
+            if (meta_flags & Npdm::MetaFlag_EnableAliasRegionExtraSize) {
+                flags |= svc::CreateProcessFlag_EnableAliasRegionExtraSize;
+            }
+
+            *out = flags;
+            R_SUCCEED();
+        }
+
+        Result GetCreateProcessParameter(svc::CreateProcessParameter *out, const Meta *meta, u32 flags, os::NativeHandle resource_limit) {
+            /* Clear output. */
+            std::memset(out, 0, sizeof(*out));
+
+            /* Set name, version, program id, resource limit handle. */
+            std::memcpy(out->name, meta->npdm->program_name, sizeof(out->name) - 1);
+            out->version    = meta->npdm->version;
+            out->program_id = meta->aci->program_id.value;
+            out->reslimit   = resource_limit;
+
+            /* Set flags. */
+            R_TRY(GetCreateProcessFlags(std::addressof(out->flags), meta, flags));
+
+            /* 3.0.0+ System Resource Size. */
+            if (hos::GetVersion() >= hos::Version_3_0_0) {
+                /* Validate size is aligned. */
+                R_UNLESS(util::IsAligned(meta->npdm->system_resource_size, os::MemoryBlockUnitSize), ldr::ResultInvalidSize());
+
+                /* Validate system resource usage. */
+                if (meta->npdm->system_resource_size) {
+                    /* Process must be 64-bit. */
+                    R_UNLESS((out->flags & svc::CreateProcessFlag_AddressSpace64Bit), ldr::ResultInvalidMeta());
+
+                    /* Process must be application or applet. */
+                    R_UNLESS(IsApplication(meta) || IsApplet(meta), ldr::ResultInvalidMeta());
+
+                    /* Size must be less than or equal to max. */
+                    R_UNLESS(meta->npdm->system_resource_size <= SystemResourceSizeMax, ldr::ResultInvalidMeta());
+                }
+                out->system_resource_num_pages = meta->npdm->system_resource_size >> 12;
+            }
+
+            R_SUCCEED();
+        }
+
+        u64 GenerateSecureRandom(u64 max) {
+            /* Generate a cryptographically random number. */
+            u64 rand;
+            crypto::GenerateCryptographicallyRandomBytes(std::addressof(rand), sizeof(rand));
+
+            /* Coerce into range. */
+            return rand % (max + 1);
+        }
+
+        Result DecideAddressSpaceLayout(ProcessInfo *out, svc::CreateProcessParameter *out_param, const AutoLoadModuleContext &ctx, const ArgumentStore::Entry *argument) {
+            /* Clear output. */
+            out->args_address = 0;
+            out->args_size = 0;
+            std::memset(out->nso_address, 0, sizeof(out->nso_address));
+            std::memset(out->nso_size, 0, sizeof(out->nso_size));
+
+            size_t total_size = 0;
+            bool argument_allocated = false;
+
+            /* Calculate base offsets. */
+            for (int i = 0; i < ctx.nso_count; i++) {
+                out->nso_address[i] = total_size;
+                const size_t text_end = static_cast<size_t>(ctx.headers[i].text_dst_offset) + static_cast<size_t>(ctx.headers[i].text_size);
+                const size_t ro_end   = static_cast<size_t>(ctx.headers[i].ro_dst_offset)   + static_cast<size_t>(ctx.headers[i].ro_size);
+                const size_t rw_end   = static_cast<size_t>(ctx.headers[i].rw_dst_offset)   + static_cast<size_t>(ctx.headers[i].rw_size);
+                out->nso_size[i] = text_end;
+                out->nso_size[i] = std::max(out->nso_size[i], ro_end);
+                out->nso_size[i] = std::max(out->nso_size[i], rw_end);
+                out->nso_size[i] += static_cast<size_t>(ctx.headers[i].bss_size);
+
+                /* Reserve hook arena memory past pcv's bss. */
+                if (g_is_pcv && i == ctx.main_nso_idx) {
+                    out->nso_size[i] = util::AlignUp(out->nso_size[i], os::MemoryPageSize) + hoc::pcv::PcvDataArenaSize;
+                }
+
+                const size_t aligned_up_size = util::AlignUp(out->nso_size[i], os::MemoryPageSize) & (AutoLoadModuleSizeMax - 1);
+                R_UNLESS(out->nso_size[i] <= aligned_up_size, ldr::ResultInvalidNso());
+                R_UNLESS(aligned_up_size > 0,                 ldr::ResultInvalidNso());
+
+                out->nso_size[i] = aligned_up_size;
+
+                R_UNLESS(util::CanAddWithoutOverflow(total_size, out->nso_size[i]), ldr::ResultInvalidNso());
+                total_size += out->nso_size[i];
+
+                if (!argument_allocated && argument != nullptr) {
+                    out->args_address = total_size;
+                    out->args_size    = util::AlignUp(2 * sizeof(u32) + argument->argument_size * 2 + ArgumentStore::ArgumentBufferSize, os::MemoryPageSize);
+
+                    R_UNLESS(util::CanAddWithoutOverflow(total_size, out->args_size), ldr::ResultInvalidNso());
+                    total_size += out->args_size;
+
+                    argument_allocated = true;
+                }
+            }
+
+            /* Calculate ASLR. */
+            uintptr_t aslr_start = 0;
+            size_t aslr_size     = 0;
+            if (hos::GetVersion() >= hos::Version_2_0_0) {
+                switch (out_param->flags & svc::CreateProcessFlag_AddressSpaceMask) {
+                    case svc::CreateProcessFlag_AddressSpace32Bit:
+                    case svc::CreateProcessFlag_AddressSpace32BitWithoutAlias:
+                        aslr_start = svc::AddressSmallMap32Start;
+                        aslr_size  = svc::AddressSmallMap32Size;
+                        break;
+                    case svc::CreateProcessFlag_AddressSpace64BitDeprecated:
+                        aslr_start = svc::AddressSmallMap36Start;
+                        aslr_size  = svc::AddressSmallMap36Size;
+                        break;
+                    case svc::CreateProcessFlag_AddressSpace64Bit:
+                        aslr_start = svc::AddressMap39Start;
+                        aslr_size  = svc::AddressMap39Size;
+                        break;
+                    AMS_UNREACHABLE_DEFAULT_CASE();
+                }
+            } else {
+                /* On 1.0.0, only 2 address space types existed. */
+                if (out_param->flags & svc::CreateProcessFlag_AddressSpace64BitDeprecated) {
+                    aslr_start = svc::AddressSmallMap36Start;
+                    aslr_size  = svc::AddressSmallMap36Size;
+                } else {
+                    aslr_start = svc::AddressSmallMap32Start;
+                    aslr_size  = svc::AddressSmallMap32Size;
+                }
+            }
+            R_UNLESS(total_size <= aslr_size, svc::ResultOutOfMemory());
+
+            /* Set Create Process output. */
+            uintptr_t aslr_slide = 0;
+            size_t free_size     = (aslr_size - total_size);
+            if (out_param->flags & svc::CreateProcessFlag_EnableAslr) {
+                aslr_slide = GenerateSecureRandom(free_size / os::MemoryBlockUnitSize) * os::MemoryBlockUnitSize;
+            }
+
+            /* Set out. */
+            aslr_start += aslr_slide;
+            for (int i = 0; i < ctx.nso_count; i++) {
+                R_UNLESS(util::CanAddWithoutOverflow(out->nso_address[i], aslr_start), ldr::ResultInvalidNso());
+                out->nso_address[i] += aslr_start;
+            }
+            if (out->args_address) {
+                R_UNLESS(util::CanAddWithoutOverflow(out->args_address, aslr_start), ldr::ResultInvalidNso());
+                out->args_address += aslr_start;
+            }
+
+            out_param->code_address   = aslr_start;
+            out_param->code_num_pages = total_size >> 12;
+            out->total_size = total_size;
+
+            R_SUCCEED();
+        }
+
+        Result LoadAutoLoadModuleSegment(fs::FileHandle file, size_t file_offset, size_t compressed_size, size_t segment_size, bool is_compressed, bool is_zstd, uintptr_t map_base, uintptr_t map_end) {
+            /* Select read size based on compression. */
+            size_t file_size = is_compressed ? compressed_size : segment_size;
+
+            /* Validate size. */
+            R_UNLESS(file_size <= segment_size,                       ldr::ResultInvalidNso());
+            R_UNLESS(file_size    <= std::numeric_limits<s32>::max(), ldr::ResultInvalidNso());
+            R_UNLESS(segment_size <= std::numeric_limits<s32>::max(), ldr::ResultInvalidNso());
+
+            /* Load data from file. */
+            uintptr_t load_address = is_compressed ? map_end - compressed_size : map_base;
+            size_t read_size;
+            R_TRY(fs::ReadFile(std::addressof(read_size), file, file_offset, reinterpret_cast<void *>(load_address), file_size));
+            R_UNLESS(read_size == file_size, ldr::ResultInvalidNso());
+
+            /* Uncompress if necessary. */
+            R_SUCCEED_IF(!is_compressed);
+
+            auto compressed_data_buf = reinterpret_cast<const void *>(load_address);
+
+            if (is_zstd) {
+                bool decompressed = util::DecompressZstdForLoader(reinterpret_cast<void *>(g_zstd_dctx_workspace), ZstdDctxWorkspaceSize, reinterpret_cast<void *>(map_base), static_cast<size_t>(map_end - map_base), segment_size, compressed_data_buf, file_size);
+                R_UNLESS(decompressed, ldr::ResultInvalidNso());
+            } else {
+                bool decompressed = (util::DecompressLZ4(reinterpret_cast<void *>(map_base), segment_size, compressed_data_buf, file_size) == static_cast<int>(segment_size));
+                R_UNLESS(decompressed, ldr::ResultInvalidNso());
+            }
+
+            R_SUCCEED();
+        }
+
+        Result CheckSegmentHash(const NsoHeader *nso_header, uintptr_t map_address, NsoHeader::Segment segment) {
+            if ((nso_header->flags & (NsoHeader::Flag_CheckHashText << segment)) == 0) {
+                R_SUCCEED();
+            }
+
+            u8 hash[crypto::Sha256Generator::HashSize];
+            crypto::GenerateSha256(hash, sizeof(hash),
+                reinterpret_cast<void *>(map_address + nso_header->segments[segment].dst_offset),
+                nso_header->segments[segment].size);
+            R_UNLESS(std::memcmp(hash, nso_header->segment_hashes[segment], sizeof(hash)) == 0, ldr::ResultInvalidNso());
+            R_SUCCEED();
+        }
+
+        Result LoadAutoLoadModule(os::NativeHandle process_handle, fs::FileHandle file, const NsoHeader *nso_header, uintptr_t nso_address, size_t nso_size, size_t map_size) {
+            const bool is_zstd = (nso_header->flags & NsoHeader::Flag_UseZbicCompression) != 0;
+
+            const size_t module_size = static_cast<size_t>(nso_header->rw_dst_offset) + util::AlignUp(nso_header->rw_size + nso_header->bss_size, os::MemoryPageSize);
+            const size_t arena_size  = (nso_size > module_size) ? (nso_size - module_size) : 0;
+
+            /* Map and read data from file. */
+            {
+                /* Map the process memory. */
+                void *mapped_memory = nullptr;
+                R_TRY(os::MapProcessMemory(std::addressof(mapped_memory), process_handle, nso_address, map_size, GenerateSecureRandom));
+                ON_SCOPE_EXIT { os::UnmapProcessMemory(mapped_memory, process_handle, nso_address, map_size); };
+
+                const uintptr_t map_address = reinterpret_cast<uintptr_t>(mapped_memory);
+                const uintptr_t map_end     = map_address + map_size;
+
+                /* Load NSO segments. */
+                R_TRY(LoadAutoLoadModuleSegment(file, nso_header->segments[NsoHeader::Segment_Text].file_offset, nso_header->text_compressed_size, nso_header->text_size,
+                                                      (nso_header->flags & NsoHeader::Flag_CompressedText) != 0, is_zstd, map_address + nso_header->text_dst_offset, map_end));
+                R_TRY(LoadAutoLoadModuleSegment(file, nso_header->segments[NsoHeader::Segment_Ro].file_offset, nso_header->ro_compressed_size, nso_header->ro_size,
+                                                      (nso_header->flags & NsoHeader::Flag_CompressedRo) != 0, is_zstd, map_address + nso_header->ro_dst_offset, map_end));
+                R_TRY(LoadAutoLoadModuleSegment(file, nso_header->segments[NsoHeader::Segment_Rw].file_offset, nso_header->rw_compressed_size, nso_header->rw_size,
+                                                      (nso_header->flags & NsoHeader::Flag_CompressedRw) != 0, is_zstd, map_address + nso_header->rw_dst_offset, map_end));
+
+                /* Clear unused space to zero. */
+                const size_t text_end = static_cast<size_t>(nso_header->text_dst_offset) + static_cast<size_t>(nso_header->text_size);
+                const size_t ro_end   = static_cast<size_t>(nso_header->ro_dst_offset)   + static_cast<size_t>(nso_header->ro_size);
+                const size_t rw_end   = static_cast<size_t>(nso_header->rw_dst_offset)   + static_cast<size_t>(nso_header->rw_size);
+                std::memset(reinterpret_cast<void *>(map_address + text_end), 0, nso_header->ro_dst_offset - text_end);
+                std::memset(reinterpret_cast<void *>(map_address + ro_end),   0, nso_header->rw_dst_offset - ro_end);
+                std::memset(reinterpret_cast<void *>(map_address + rw_end),   0, nso_size - rw_end);
+
+                /* Check segment hashes. */
+                R_TRY(CheckSegmentHash(nso_header, map_address, NsoHeader::Segment_Text));
+                R_TRY(CheckSegmentHash(nso_header, map_address, NsoHeader::Segment_Ro));
+                R_TRY(CheckSegmentHash(nso_header, map_address, NsoHeader::Segment_Rw));
+
+                /* Apply embedded patches. */
+                ApplyEmbeddedPatchesToModule(nso_header->module_id, map_address, nso_size);
+
+                /* Apply IPS patches. */
+                LocateAndApplyIpsPatchesToModule(nso_header->module_id, map_address, nso_size);
+
+                /* Apply PCV and PTM patches */
+                if (g_is_pcv) {
+                    const size_t text_end  = static_cast<size_t>(nso_header->text_size);
+                    const size_t rx_end    = util::AlignUp(text_end, os::MemoryPageSize);
+                    const size_t ro_start  = static_cast<size_t>(nso_header->ro_dst_offset);
+                    const size_t cave_end  = (rx_end < ro_start) ? rx_end : ro_start;
+                    const uintptr_t cave   = map_address + text_end;
+                    const size_t cave_size = (cave_end > text_end) ? (cave_end - text_end) : 0;
+
+                    /* module_size is used rather than nso_size to exclude the extra data section. */
+                    hoc::pcv::Patch(map_address, module_size, cave, cave_size, nso_address, arena_size ? (map_address + module_size) : 0);
+                }
+
+                if (g_is_ptm) {
+                    hoc::ptm::Patch(map_address, nso_size);
+                }
+
+                // TODO: figure out the cause of crashes with nvsrv patches
+                if (g_is_nvsrv) {
+                    // hoc::nvsrv::Patch(map_address, nso_size, nso_address);
+                }
+            }
+
+            /* Set permissions. */
+            const size_t text_size = util::AlignUp(nso_header->text_size, os::MemoryPageSize);
+            const size_t ro_size   = util::AlignUp(nso_header->ro_size, os::MemoryPageSize);
+            const size_t rw_size   = util::AlignUp(nso_header->rw_size + nso_header->bss_size, os::MemoryPageSize) + arena_size;
+            if (text_size) {
+                const bool prevent_code_reads = (nso_header->flags & NsoHeader::Flag_PreventCodeReads);
+                R_TRY(os::SetProcessMemoryPermission(process_handle, nso_address + nso_header->text_dst_offset, text_size, prevent_code_reads ? os::MemoryPermission_ExecuteOnly : os::MemoryPermission_ReadExecute));
+            }
+            if (ro_size) {
+                R_TRY(os::SetProcessMemoryPermission(process_handle, nso_address + nso_header->ro_dst_offset, ro_size, os::MemoryPermission_ReadOnly));
+            }
+            if (rw_size) {
+                R_TRY(os::SetProcessMemoryPermission(process_handle, nso_address + nso_header->rw_dst_offset, rw_size, os::MemoryPermission_ReadWrite));
+            }
+
+            R_SUCCEED();
+        }
+
+        Result LoadAutoLoadModules(const ProcessInfo *process_info, const AutoLoadModuleContext &ctx, const ArgumentStore::Entry *argument) {
+            /* Load each NSO. */
+            const uintptr_t total_end = process_info->code_address + process_info->total_size;
+
+            for (int i = 0; i < ctx.nso_count; i++) {
+                const NsoIndex nso_idx = static_cast<NsoIndex>(ctx.ali.nso_indices[i]);
+
+                fs::FileHandle file;
+                R_TRY(fs::OpenFile(std::addressof(file), GetNsoPath(nso_idx), fs::OpenMode_Read));
+                ON_SCOPE_EXIT { fs::CloseFile(file); };
+
+                const bool is_zstd    = (ctx.headers[i].flags & NsoHeader::Flag_UseZbicCompression) != 0;
+                const size_t map_size = is_zstd ? (total_end - process_info->nso_address[i]) : process_info->nso_size[i];
+
+                R_TRY(LoadAutoLoadModule(process_info->process_handle, file, ctx.headers + i, process_info->nso_address[i], process_info->nso_size[i], map_size));
+            }
+
+            /* Load arguments, if present. */
+            if (argument != nullptr) {
+                /* Write argument data into memory. */
+                {
+                    void *map_address = nullptr;
+                    R_TRY(os::MapProcessMemory(std::addressof(map_address), process_info->process_handle, process_info->args_address, process_info->args_size, GenerateSecureRandom));
+                    ON_SCOPE_EXIT { os::UnmapProcessMemory(map_address, process_info->process_handle, process_info->args_address, process_info->args_size); };
+
+                    ProgramArguments *args = static_cast<ProgramArguments *>(map_address);
+                    std::memset(args, 0, sizeof(*args));
+                    args->allocated_size = process_info->args_size;
+                    args->arguments_size = argument->argument_size;
+                    std::memcpy(args->arguments, argument->argument, argument->argument_size);
+                }
+
+                /* Set argument region permissions. */
+                /* NOTE: Nintendo uses svc::SetProcessMemoryPermission directly here. */
+                R_TRY(os::SetProcessMemoryPermission(process_info->process_handle, process_info->args_address, process_info->args_size, os::MemoryPermission_ReadWrite));
+            }
+
+            R_SUCCEED();
+        }
+
+        Result CreateProcessAndLoadAutoLoadModules(ProcessInfo *out, const Meta *meta, const AutoLoadModuleContext &ctx, const ArgumentStore::Entry *argument, u32 flags, os::NativeHandle resource_limit) {
+            /* Get CreateProcessParameter. */
+            svc::CreateProcessParameter param;
+            R_TRY(GetCreateProcessParameter(std::addressof(param), meta, flags, resource_limit));
+
+            /* Decide on an NSO layout. */
+            R_TRY(DecideAddressSpaceLayout(out, std::addressof(param), ctx, argument));
+
+            /* Actually create process. */
+            svc::Handle process_handle;
+            R_TRY(svc::CreateProcess(std::addressof(process_handle), std::addressof(param), static_cast<const u32 *>(meta->aci_kac), meta->aci->kac_size / sizeof(u32)));
+
+            /* Set the output handle, and ensure that if we fail after this point we clean it up. */
+            out->process_handle = process_handle;
+            out->code_address   = param.code_address;
+            ON_RESULT_FAILURE { svc::CloseHandle(process_handle); };
+
+            /* Load all auto load modules. */
+            R_RETURN(LoadAutoLoadModules(out, ctx, argument));
+        }
+
+    }
+
+    /* Process Creation API. */
+    Result CreateProcess(os::NativeHandle *out, PinId pin_id, const ncm::ProgramLocation &loc, const cfg::OverrideStatus &override_status, const char *path, const ArgumentStore::Entry *argument, u32 flags, os::NativeHandle resource_limit, const ldr::ProgramAttributes &attrs) {
+        /* Mount code. */
+        AMS_UNUSED(path);
+        ScopedCodeMountForCode mount(loc, override_status, attrs);
+        R_TRY(mount.GetResult());
+
+        /* Load meta, possibly from cache. */
+        Meta meta;
+        R_TRY(LoadMetaFromCache(std::addressof(meta), loc, override_status, attrs.platform));
+
+        /* Validate meta. */
+        R_TRY(ValidateMeta(std::addressof(meta), loc, mount.GetCodeVerificationData()));
+
+        /* If we should, load/validate the browser core dll. */
+        util::optional<ScopedCodeMountForBrowserCoreDll> bdll_mount;
+        if ((meta.acid->flags & Acid::AcidFlag_LoadBrowserCoreDll)) {
+            /* NOTE: I'm unsure whether we should be getting a fresh override status (allowing for different override between main and bdll?) */
+            /* or whether we should be using the main override status. Going to go with main, for sanity's sake. */
+            /* Also noting that Nintendo always passes ProgramAttributes=0 here, but this "should" be different on Ounce? */
+            /* Kind of unclear how to handle this without knowing what exactly is being ifdef'd. */
+            const ncm::ProgramLocation bdll_loc            = ncm::ProgramLocation::Make(ncm::SystemProgramId::BrowserCoreDll, ncm::StorageId::BuiltInSystem);
+            const cfg::OverrideStatus bdll_override_status = override_status;
+            const ldr::ProgramAttributes bdll_attrs        = attrs;
+            bdll_mount.emplace(bdll_loc, bdll_override_status, bdll_attrs);
+            R_TRY(bdll_mount->GetResult());
+
+            /* Load browser dll meta, possibly from cache. */
+            Meta bdll_meta;
+            R_TRY(LoadMetaFromCacheForBrowserCoreDll(std::addressof(bdll_meta), bdll_loc, bdll_override_status, bdll_attrs.platform));
+
+            /* Validate browser dll meta. */
+            R_TRY(ValidateMeta(std::addressof(bdll_meta), loc, mount.GetCodeVerificationData()));
+        }
+
+        /* Load, validate NSO headers. */
+        AutoLoadModuleContext ctx;
+        R_TRY(LoadAutoLoadHeaders(ctx, meta.acid->flags));
+        R_TRY(CheckAutoLoad(ctx, meta.acid->flags));
+
+        /* Actually create the process and load NSOs into process memory. */
+        ProcessInfo info;
+        R_TRY(CreateProcessAndLoadAutoLoadModules(std::addressof(info), std::addressof(meta), ctx, argument, flags, resource_limit));
+
+        /* Register NSOs with the RoManager. */
+        {
+            /* Nintendo doesn't validate this get, but we do. */
+            os::ProcessId process_id = os::GetProcessId(info.process_handle);
+
+            /* Register new process. */
+            const auto as_type = GetAddressSpaceType(std::addressof(meta));
+            RoManager::GetInstance().RegisterProcess(pin_id, process_id, meta.aci->program_id, as_type == Npdm::AddressSpaceType_64Bit || as_type == Npdm::AddressSpaceType_64BitDeprecated);
+
+            /* Register all NSOs. */
+            for (int i = 0; i < ctx.nso_count; i++) {
+                RoManager::GetInstance().AddNso(pin_id, ctx.headers[i].module_id, info.nso_address[i], info.nso_size[i]);
+            }
+        }
+
+        /* If we're overriding for HBL, perform HTML document redirection. */
+        if (override_status.IsHbl()) {
+            /* Don't validate result, failure is okay. */
+            RedirectHtmlDocumentPathForHbl(loc);
+        }
+
+        /* Clear the external code for the program. */
+        fssystem::DestroyExternalCode(loc.program_id);
+
+        /* Note that we've created the program. */
+        SetLaunchedBootProgram(loc.program_id);
+
+        /* Move the process handle to output. */
+        *out = info.process_handle;
+
+        R_SUCCEED();
+    }
+
+    Result GetProgramInfo(ProgramInfo *out, cfg::OverrideStatus *out_status, const ncm::ProgramLocation &loc, const char *path, const ldr::ProgramAttributes &attrs) {
+        Meta meta;
+
+        /* Load Meta. */
+        {
+            AMS_UNUSED(path);
+
+            ScopedCodeMountForCode mount(loc, attrs);
+            R_TRY(mount.GetResult());
+            R_TRY(LoadMeta(std::addressof(meta), loc, mount.GetOverrideStatus(), attrs.platform, false));
+            if (out_status != nullptr) {
+                *out_status = mount.GetOverrideStatus();
+            }
+        }
+
+        return GetProgramInfoFromMeta(out, std::addressof(meta));
+    }
+
+    Result PinProgram(PinId *out_id, const ncm::ProgramLocation &loc, const cfg::OverrideStatus &override_status) {
+        R_UNLESS(RoManager::GetInstance().Allocate(out_id, loc, override_status), ldr::ResultMaxProcess());
+        R_SUCCEED();
+    }
+
+    Result UnpinProgram(PinId id) {
+        R_UNLESS(RoManager::GetInstance().Free(id), ldr::ResultNotPinned());
+        R_SUCCEED();
+    }
+
+    Result GetProcessModuleInfo(u32 *out_count, ldr::ModuleInfo *out, size_t max_out_count, os::ProcessId process_id) {
+        R_UNLESS(RoManager::GetInstance().GetProcessModuleInfo(out_count, out, max_out_count, process_id), ldr::ResultNotPinned());
+        R_SUCCEED();
+    }
+
+    Result GetProgramLocationAndOverrideStatusFromPinId(ncm::ProgramLocation *out, cfg::OverrideStatus *out_status, PinId pin_id) {
+        R_UNLESS(RoManager::GetInstance().GetProgramLocationAndStatus(out, out_status, pin_id), ldr::ResultNotPinned());
+        R_SUCCEED();
+    }
+
+}

Source/hoc-clk/common/include/hocclk/config.h

@@ -387,7 +387,7 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr
         case KipConfigValue_low_t7_tWTR:
             return pretty ? "Low T7 - tWTR" : "low_t7_tWTR";
         case KipConfigValue_low_t8_tREFI:
-            return pretty ? "Low T8 - tREFI" : "low_t7_tREFI";
+            return pretty ? "Low T8 - tREFI" : "low_t8_tREFI";
 
         case KipConfigValue_read_latency_1333:
             return pretty ? "1333 Read Latency" : "read_latency_1333";
@@ -572,6 +572,7 @@ static inline uint64_t hocclkDefaultConfigValue(HocClkConfigValue val)
         case HocClkConfigValue_MemoryFrequencyMeasurementMode:
         case HocClkConfigValue_MarikoMiddleFreqs:
         case HocClkConfigValue_LiveGpuVoltage:
+        case HocClkConfigValue_AutoRAMCPUOverclock:
             return 0ULL;
         case HocClkConfigValue_RamDisplayUnit:
             return (uint64_t)RamDisplayUnit_MHz;
@@ -584,7 +585,6 @@ static inline uint64_t hocclkDefaultConfigValue(HocClkConfigValue val)
         case HocClkConfigValue_ThermalThrottle:
         case HocClkConfigValue_IsFirstLoad:
         case HocClkConfigValue_DVFSMode:
-        case HocClkConfigValue_AutoRAMCPUOverclock:
             return 1ULL;
         case HocClkConfigValue_AutoRamCpuCpuOCFreq:
             return 1683000ULL;

Source/hoc-clk/overlay/Makefile

@@ -39,7 +39,7 @@ include ${TOPDIR}/lib/libultrahand/ultrahand.mk
 # version control constants
 #---------------------------------------------------------------------------------
 #TARGET_VERSION	:= $(shell git describe --dirty --always --tags)
-APP_VERSION		:= 2.5.1 # ensure to set KIP_VERSION and CUST_REV in sysmodule Makefile when updating this
+APP_VERSION		:= 2.6.0 # ensure to set KIP_VERSION and CUST_REV in sysmodule Makefile when updating this
 TARGET_VERSION := $(APP_VERSION)
 
 #---------------------------------------------------------------------------------

Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp

@@ -925,6 +925,78 @@ class ExperimentalSettingsSubMenuGui : public MiscGui {
             addConfigButton(HocClkConfigValue_AulaDisplayColorPreset, "Display Color Preset", ValueRange(0, 1, 1, "", 0), "Display Color Preset",
                             &thresholdsDisabled, {}, displayClrPreset, false, false);
         }
+        std::vector<NamedValue> clkOptionsRamOc = {
+            NamedValue("1122 MHz", 1122000), NamedValue("1224 MHz", 1224000), NamedValue("1326 MHz", 1326000), NamedValue("1428 MHz", 1428000),
+            NamedValue("1581 MHz", 1581000), NamedValue("1683 MHz", 1683000, "Default"), NamedValue("1785 MHz", 1785000), NamedValue("1887 MHz", 1887000),
+            NamedValue("1963 MHz", 1963500), NamedValue("2091 MHz", 2091000), NamedValue("2193 MHz", 2193000), NamedValue("2295 MHz", 2295000),
+            NamedValue("2397 MHz", 2397000), NamedValue("2499 MHz", 2499000), NamedValue("2601 MHz", 2601000), NamedValue("2703 MHz", 2703000),
+            NamedValue("2805 MHz", 2805000),
+        };
+        std::vector<NamedValue> emcMaxClock = {
+                NamedValue("1600 MHz", 1600000),
+                NamedValue("1633 MHz", 1633000),
+                NamedValue("1666 MHz", 1666000),
+                NamedValue("1700 MHz", 1700000),
+                NamedValue("1733 MHz", 1733000),
+                NamedValue("1766 MHz", 1766000),
+                NamedValue("1800 MHz", 1800000),
+                NamedValue("1833 MHz", 1833000),
+                NamedValue("1866 MHz", 1866000, "JEDEC."),
+                NamedValue("1900 MHz", 1900000),
+                NamedValue("1933 MHz", 1933000),
+                NamedValue("1966 MHz", 1966000),
+                NamedValue("1996 MHz", 1996800, "JEDEC."),
+                NamedValue("2000 MHz", 2000000),
+                NamedValue("2033 MHz", 2033000),
+                NamedValue("2066 MHz", 2066000),
+                NamedValue("2100 MHz", 2100000),
+                NamedValue("2133 MHz", 2133000, "JEDEC."),
+                NamedValue("2166 MHz", 2166000),
+                NamedValue("2200 MHz", 2200000),
+                NamedValue("2233 MHz", 2233000),
+                NamedValue("2266 MHz", 2266000),
+                NamedValue("2300 MHz", 2300000),
+                NamedValue("2333 MHz", 2333000),
+                NamedValue("2366 MHz", 2366000),
+                NamedValue("2400 MHz", 2400000, "JEDEC."),
+                NamedValue("2433 MHz", 2433000),
+                NamedValue("2466 MHz", 2466000),
+                NamedValue("2500 MHz", 2500000),
+                NamedValue("2533 MHz", 2533000),
+                NamedValue("2566 MHz", 2566000),
+                NamedValue("2600 MHz", 2600000),
+                NamedValue("2633 MHz", 2633000),
+                NamedValue("2666 MHz", 2666000, "JEDEC."),
+                NamedValue("2700 MHz", 2700000),
+                NamedValue("2733 MHz", 2733000),
+                NamedValue("2766 MHz", 2766000),
+                NamedValue("2800 MHz", 2800000),
+                NamedValue("2833 MHz", 2833000),
+                NamedValue("2866 MHz", 2866000),
+                NamedValue("2900 MHz", 2900000),
+                NamedValue("2933 MHz", 2933000, "JEDEC."),
+                NamedValue("2966 MHz", 2966000),
+                NamedValue("3000 MHz", 3000000),
+                NamedValue("3033 MHz", 3033000),
+                NamedValue("3066 MHz", 3066000),
+                NamedValue("3100 MHz", 3100000),
+                NamedValue("3133 MHz", 3133000),
+                NamedValue("3166 MHz", 3166000),
+                NamedValue("3200 MHz", 3200000, "JEDEC."),
+                NamedValue("3233 MHz", 3233000, "±1720 speedo"),
+                NamedValue("3266 MHz", 3266000, "±1740 speedo"),
+                NamedValue("3300 MHz", 3300000, "±1760 speedo"),
+                NamedValue("3333 MHz", 3333000, "±1780 speedo"),
+                NamedValue("3366 MHz", 3366000, "±1800 speedo"),
+                NamedValue("3400 MHz", 3400000, "±1820 speedo")
+            };
+
+        addConfigToggle(HocClkConfigValue_AutoRAMCPUOverclock, "Auto CPU RAM OC");
+        addConfigButton(HocClkConfigValue_AutoRamCpuCpuOCFreq, "Auto CPU RAM OC CPU clock", ValueRange(0, 0, 1, "", 1), "CPU Clock",
+                        &thresholdsDisabled, {}, clkOptionsRamOc, false, false);
+        addConfigButton(HocClkConfigValue_AutoRamCpuRamOCThreshold, "Auto CPU RAM OC Threshold", ValueRange(0, 0, 1, "", 1), "RAM Clock",
+                        &thresholdsDisabled, {}, emcMaxClock, false, false);
+
     }
 };
 
@@ -2123,21 +2195,14 @@ class CpuSubmenuGui : public MiscGui {
 
             std::vector<NamedValue> maxClkOptions = {
                 NamedValue("1963 MHz", 1963500, "Rating"), NamedValue("2091 MHz", 2091000), NamedValue("2193 MHz", 2193000), NamedValue("2295 MHz", 2295000),
-                NamedValue("2397 MHz", 2397000, "Safe Max"), NamedValue("2499 MHz", 2499000, "Unsafe Max"), NamedValue("2601 MHz", 2601000), NamedValue("2703 MHz", 2703000, "Absolute Max"),
+                NamedValue("2397 MHz", 2397000, "Safe Max"), NamedValue("2499 MHz", 2499000, "Unsafe Max"), NamedValue("2601 MHz", 2601000), NamedValue("2703 MHz", 2703000),
+                NamedValue("2805 MHz", 2805000, "Absolute Max"),
             };
 
             addConfigButton(KipConfigValue_marikoCpuMaxClock, "CPU Max Clock", ValueRange(0, 0, 1, "", 1), "CPU Max Clock",
                             this->configList->values[KipConfigValue_marikoCpuUVHigh] ? &mCpuClockThresholdsUV : &mCpuClockThresholds, {},
                             maxClkOptions, false, true);
 
-            std::vector<NamedValue> clkOptionsRamOc = {
-                NamedValue("1122 MHz", 1122000), NamedValue("1224 MHz", 1224000), NamedValue("1326 MHz", 1326000), NamedValue("1428 MHz", 1428000),
-                NamedValue("1581 MHz", 1581000), NamedValue("1683 MHz", 1683000, "Default"), NamedValue("1785 MHz", 1785000), NamedValue("1887 MHz", 1887000),
-                NamedValue("1963 MHz", 1963500), NamedValue("2091 MHz", 2091000), NamedValue("2193 MHz", 2193000), NamedValue("2295 MHz", 2295000),
-                NamedValue("2397 MHz", 2397000), NamedValue("2499 MHz", 2499000), NamedValue("2601 MHz", 2601000), NamedValue("2703 MHz", 2703000),
-                NamedValue("2805 MHz", 2805000),
-            };
-
             addConfigButton(KipConfigValue_marikoCpuBoostClock, "CPU Boost Clock", ValueRange(0, 0, 1, "", 1), "CPU Boost Clock",
                             this->configList->values[KipConfigValue_marikoCpuUVHigh] ? &mCpuClockThresholdsUV : &mCpuClockThresholds, {}, maxClkOptions,
                             false, true);
@@ -2200,11 +2265,6 @@ class CpuSubmenuGui : public MiscGui {
                 NamedValue("3366 MHz", 3366000, "±1800 speedo"),
                 NamedValue("3400 MHz", 3400000, "±1820 speedo"),
             };
-            addConfigToggle(HocClkConfigValue_AutoRAMCPUOverclock, "Auto CPU RAM OC");
-            addConfigButton(HocClkConfigValue_AutoRamCpuCpuOCFreq, "Auto CPU RAM OC CPU clock", ValueRange(0, 0, 1, "", 1), "CPU Clock",
-                            &thresholdsDisabled, {}, clkOptionsRamOc, false, false);
-            addConfigButton(HocClkConfigValue_AutoRamCpuRamOCThreshold, "Auto CPU RAM OC Threshold", ValueRange(0, 0, 1, "", 1), "RAM Clock",
-                            &thresholdsDisabled, {}, emcMaxClock, false, false);
         } else {
             addConfigTrackbar(KipConfigValue_eristaCpuUV, "CPU UV", ValueRange(0, 5, 1));
 

build.sh

@@ -76,20 +76,14 @@ if [ "$NO_EXO" -eq 0 ]; then
     EXO_DEST="build/atmosphere/exosphere/program/source/smc"
     LIBEXO_DEST="build/atmosphere/libraries/libexosphere/include/exosphere/secmon"
 
-    cp -v "$EXO_SRC/secmon_setup.cpp"                                  "$EXO_PROGRAM_DEST/"
     cp -v "$EXO_SRC/secmon_define_emc_access_table.inc"               "$EXO_DEST/"
     cp -v "$EXO_SRC/secmon_emc_access_table_data.inc"                 "$EXO_DEST/"
     cp -v "$EXO_SRC/secmon_define_emc01_access_table.inc"             "$EXO_DEST/"
     cp -v "$EXO_SRC/secmon_emc01_access_table_data.inc"               "$EXO_DEST/"
     cp -v "$EXO_SRC/secmon_define_rtc_pmc_access_table.inc"           "$EXO_DEST/"
     cp -v "$EXO_SRC/secmon_rtc_pmc_access_table_data.inc"             "$EXO_DEST/"
-    cp -v "$EXO_SRC/secmon_define_flow_controller_access_table.inc"   "$EXO_DEST/"
-    cp -v "$EXO_SRC/secmon_flow_controller_access_table_data.inc"     "$EXO_DEST/"
-    cp -v "$EXO_SRC/secmon_define_exception_vectors_access_table.inc" "$EXO_DEST/"
-    cp -v "$EXO_SRC/secmon_exception_vectors_access_table_data.inc"   "$EXO_DEST/"
     cp -v "$EXO_SRC/secmon_smc_register_access.cpp"                   "$EXO_DEST/"
     cp -v "$EXO_SRC/secmon_smc_handler.cpp"                           "$EXO_DEST/"
-    cp -v "$EXO_SRC/secmon_smc_power_management.cpp"                  "$EXO_DEST/"
     cp -v "$EXO_SRC/secmon_memory_layout.hpp"                         "$LIBEXO_DEST/"
 fi