docs: 1.5.4 changelog, zelda why the fuck

I cannot wait to figure out all the ways this is wrong.

docs/changelog.md

@@ -1,4 +1,28 @@
 # Changelog
+## 1.5.4
++ Experimental new functionality was implemented to prevent crashing when building romfs for certain games with obscene file counts.
+  + This includes both Fire Emblem: Engage (~190000 files), and The Legend of Zelda: Tears of the Kingdom (~300000) files.
+  + The solution involved adding functionality to ams.mitm/pm to dynamically steal memory from the application (and system) pool as needed when the games have romfs mods.
+    + No memory is taken, and there is no cost to this functionality when playing without mods (or with overrides disabled).
+  + The Legend of Zelda: Tears of the Kingdom is currently the absolute worst case game, requiring ~48 MB of memory to build a romfs image to play with mods.
+    + Right now, the memory is sourced as follows: 32 MB (base ams.mitm heap), 10 MB (stolen from application pool), 8 MB (dynamically stolen from system pool).
+    + This is 50 MB, which allows a little overhead in the worst case (prevents crashing due to exhausting the heap for other allocations in ams.mitm).
+    + Zelda is remarkably sensitive to memory being stolen from the application pool, tolerating no more than 16 MB on 1.0.0 and 12 MB on 1.1.0. I have chosen to steal 10 MB, to be safe, for now.
+      + This may break on a future game update, but I will fix it if and when that happens. There is no perfect solution; the game simply requires too much memory to support mods flawlessly, and I am forced to compromise.
+  + As usual, if you encounter a game that exhausts ams.mitm's memory (crashing it) when loading layeredfs mods, please contact `SciresM#0524`.
+    "I am jinxing myself by saying this, but it's really hard to imagine any game being worse than The Legend of Zelda: Tears of the Kingdom, but if it happens again I will drop everything to fix it as usual".
++ General system stability improvements to enhance the user's experience.
+## 1.5.3
++ Support was added for 16.0.3.
++ Atmosphère was updated to use GCC 13/newlib (latest devkitA64/devkitARM releases).
+  + **Please note**: This introduces a known issue, which is currently being worked on.
+    + As you may recall from the 1.4.1 changelog, Fire Emblem: Engage requires enormous amounts of memory to support using layeredfs mods with the game.
+    + Latest GCC/newlib slightly increases malloc overhead size, which makes the previous memory increase insufficient.
+    + A general-case solution to this is in the works, which should hopefully fix the problem in a way that doesn't jinx me for the future.
++ A number of minor issues were fixed and improvements were made, including:
+  + An issue was fixed that caused system font replacement to not work on 16.0.0+.
+  + An minor accuracy issue was addressed in mesosphere's management of certain memory ranges; this issue would have had zero visible impact to the end-user.
++ General system stability improvements to enhance the user's experience.
 ## 1.5.2
 + A homebrew application (`haze`) was added for performing USB file transfer (with thanks to @liamwhite for both design and implementation).
   + `haze` is included with atmosphère, and provides access to the SD card via the PTP/MTP protocol.

emummc/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/m4xw/emummc
 	branch = develop
-	commit = bba1f1fb65f75721caf6d023a35d75d3c9aafd0f
-	parent = 1ab8b234447864503e21c600681219a96962e6c1
+	commit = 30205111ee375bef96f0f76cb6a3130a2f0fc85c
+	parent = 81e9154a52a976f85317bddd0131426599d26a62
 	method = merge
 	cmdver = 0.4.1

emummc/README.md

@@ -2,7 +2,7 @@
 *A SDMMC driver replacement for Nintendo's Filesystem Services, by **m4xw***  
 
 ### Supported Horizon Versions
-**1.0.0 - 16.0.0**
+**1.0.0 - 16.0.3**
 
 ## Features
 * Arbitrary SDMMC backend selection  

emummc/source/FS/FS_offsets.c

@@ -65,6 +65,8 @@
 #include "offsets/1500_exfat.h"
 #include "offsets/1600.h"
 #include "offsets/1600_exfat.h"
+#include "offsets/1603.h"
+#include "offsets/1603_exfat.h"
 #include "../utils/fatal.h"
 
 #define GET_OFFSET_STRUCT_NAME(vers) g_offsets##vers
@@ -141,6 +143,8 @@ DEFINE_OFFSET_STRUCT(_1500);
 DEFINE_OFFSET_STRUCT(_1500_EXFAT);
 DEFINE_OFFSET_STRUCT(_1600);
 DEFINE_OFFSET_STRUCT(_1600_EXFAT);
+DEFINE_OFFSET_STRUCT(_1603);
+DEFINE_OFFSET_STRUCT(_1603_EXFAT);
 
 const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
     switch (version) {
@@ -242,6 +246,10 @@ const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
             return &(GET_OFFSET_STRUCT_NAME(_1600));
         case FS_VER_16_0_0_EXFAT:
             return &(GET_OFFSET_STRUCT_NAME(_1600_EXFAT));
+        case FS_VER_16_0_3:
+            return &(GET_OFFSET_STRUCT_NAME(_1603));
+        case FS_VER_16_0_3_EXFAT:
+            return &(GET_OFFSET_STRUCT_NAME(_1603_EXFAT));
         default:
             fatal_abort(Fatal_UnknownVersion);
     }

emummc/source/FS/FS_versions.h

@@ -95,6 +95,9 @@ enum FS_VER
     FS_VER_16_0_0,
     FS_VER_16_0_0_EXFAT,
 
+    FS_VER_16_0_3,
+    FS_VER_16_0_3_EXFAT,
+
     FS_VER_MAX,
 };
 

emummc/source/FS/offsets/1603.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019 m4xw <m4x@m4xw.net>
+ * Copyright (c) 2019 Atmosphere-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/>.
+ */
+#ifndef __FS_1603_H__
+#define __FS_1603_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_1603_SDMMC_ACCESSOR_GC   0x1862F0
+#define FS_OFFSET_1603_SDMMC_ACCESSOR_SD   0x187F70
+#define FS_OFFSET_1603_SDMMC_ACCESSOR_NAND 0x1867B0
+
+// Hooks
+#define FS_OFFSET_1603_SDMMC_WRAPPER_READ  0x182240
+#define FS_OFFSET_1603_SDMMC_WRAPPER_WRITE 0x1822A0
+#define FS_OFFSET_1603_RTLD                0x269B0
+#define FS_OFFSET_1603_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x3C)))
+
+#define FS_OFFSET_1603_CLKRST_SET_MIN_V_CLK_RATE 0x1A2D80
+
+// Misc funcs
+#define FS_OFFSET_1603_LOCK_MUTEX          0x17B780
+#define FS_OFFSET_1603_UNLOCK_MUTEX        0x17B7D0
+
+#define FS_OFFSET_1603_SDMMC_WRAPPER_CONTROLLER_OPEN  0x182200
+#define FS_OFFSET_1603_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x182220
+
+// Misc Data
+#define FS_OFFSET_1603_SD_MUTEX            0xFFB3F0
+#define FS_OFFSET_1603_NAND_MUTEX          0xFF6B58
+#define FS_OFFSET_1603_ACTIVE_PARTITION    0xFF6B98
+#define FS_OFFSET_1603_SDMMC_DAS_HANDLE    0xFDC8B0
+
+// NOPs
+#define FS_OFFSET_1603_SD_DAS_INIT         0x258D4
+
+// Nintendo Paths
+#define FS_OFFSET_1603_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x00063B98, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x00070DBC, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0007795C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0008A7A4, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_1603_H__

emummc/source/FS/offsets/1603_exfat.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019 m4xw <m4x@m4xw.net>
+ * Copyright (c) 2019 Atmosphere-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/>.
+ */
+#ifndef __FS_1603_EXFAT_H__
+#define __FS_1603_EXFAT_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_1603_EXFAT_SDMMC_ACCESSOR_GC   0x190FD0
+#define FS_OFFSET_1603_EXFAT_SDMMC_ACCESSOR_SD   0x192C50
+#define FS_OFFSET_1603_EXFAT_SDMMC_ACCESSOR_NAND 0x191490
+
+// Hooks
+#define FS_OFFSET_1603_EXFAT_SDMMC_WRAPPER_READ  0x18CF20
+#define FS_OFFSET_1603_EXFAT_SDMMC_WRAPPER_WRITE 0x18CF80
+#define FS_OFFSET_1603_EXFAT_RTLD                0x269B0
+#define FS_OFFSET_1603_EXFAT_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x3C)))
+
+#define FS_OFFSET_1603_EXFAT_CLKRST_SET_MIN_V_CLK_RATE 0x1ADA60
+
+// Misc funcs
+#define FS_OFFSET_1603_EXFAT_LOCK_MUTEX          0x186460
+#define FS_OFFSET_1603_EXFAT_UNLOCK_MUTEX        0x1864B0
+
+#define FS_OFFSET_1603_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0x18CEE0
+#define FS_OFFSET_1603_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x18CF00
+
+// Misc Data
+#define FS_OFFSET_1603_EXFAT_SD_MUTEX            0x100D3F0
+#define FS_OFFSET_1603_EXFAT_NAND_MUTEX          0x1008B58
+#define FS_OFFSET_1603_EXFAT_ACTIVE_PARTITION    0x1008B98
+#define FS_OFFSET_1603_EXFAT_SDMMC_DAS_HANDLE    0xFE98B0
+
+// NOPs
+#define FS_OFFSET_1603_EXFAT_SD_DAS_INIT         0x258D4
+
+// Nintendo Paths
+#define FS_OFFSET_1603_EXFAT_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x00063B98, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x00070DBC, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0007795C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0008A7A4, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_1603_EXFAT_H__

fusee/program/source/fusee_stratosphere.cpp

@@ -162,6 +162,9 @@ namespace ams::nxboot {
             FsVersion_16_0_0,
             FsVersion_16_0_0_Exfat,
 
+            FsVersion_16_0_3,
+            FsVersion_16_0_3_Exfat,
+
             FsVersion_Count,
         };
 
@@ -239,6 +242,9 @@ namespace ams::nxboot {
 
             { 0x56, 0xE8, 0x56, 0x56, 0x6C, 0x38, 0xD8, 0xBE }, /* FsVersion_16_0_0 */
             { 0xCF, 0xAB, 0x45, 0x0C, 0x2C, 0x53, 0x9D, 0xA9 }, /* FsVersion_16_0_0_Exfat */
+
+            { 0x39, 0xEE, 0x1F, 0x1E, 0x0E, 0xA7, 0x32, 0x5D }, /* FsVersion_16_0_3 */
+            { 0x62, 0xC6, 0x5E, 0xFD, 0x9A, 0xBF, 0x7C, 0x43 }, /* FsVersion_16_0_3_Exfat */
         };
 
         const InitialProcessBinaryHeader *FindInitialProcessBinary(const pkg2::Package2Header *header, const u8 *data, ams::TargetFirmware target_firmware) {
@@ -656,6 +662,14 @@ namespace ams::nxboot {
                     AddPatch(fs_meta, 0x1913B9, NogcPatch0, sizeof(NogcPatch0));
                     AddPatch(fs_meta, 0x16B950, NogcPatch1, sizeof(NogcPatch1));
                     break;
+                case FsVersion_16_0_3:
+                    AddPatch(fs_meta, 0x186729, NogcPatch0, sizeof(NogcPatch0));
+                    AddPatch(fs_meta, 0x160CC0, NogcPatch1, sizeof(NogcPatch1));
+                    break;
+                case FsVersion_16_0_3_Exfat:
+                    AddPatch(fs_meta, 0x191409, NogcPatch0, sizeof(NogcPatch0));
+                    AddPatch(fs_meta, 0x16B9A0, NogcPatch1, sizeof(NogcPatch1));
+                    break;
                 default:
                     break;
             }

libraries/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/Atmosphere-NX/Atmosphere-libs
 	branch = master
-	commit = ecc8b18111730acef0a353f6f61c45c1f143a793
-	parent = d8aed7de6d39dd29b75e34f24d376decfb77a5b4
+	commit = cd0fc2c1d5728ec45414aaaa6efa28c269695992
+	parent = 8ec7c096d04e6f9586be2cb785840cd482d4b900
 	method = merge
 	cmdver = 0.4.1

libraries/libmesosphere/include/mesosphere/kern_k_auto_object.hpp

@@ -257,7 +257,7 @@ namespace ams::kern {
     class KScopedAutoObject {
         NON_COPYABLE(KScopedAutoObject);
         private:
-            template<typename U>
+            template<typename U> requires std::derived_from<U, KAutoObject>
             friend class KScopedAutoObject;
         private:
             T *m_obj;

libraries/libmesosphere/include/mesosphere/kern_k_page_table_base.hpp

@@ -57,11 +57,26 @@ namespace ams::kern {
             using TraversalEntry   = KPageTableImpl::TraversalEntry;
             using TraversalContext = KPageTableImpl::TraversalContext;
 
-            struct MemoryRange {
-                KPhysicalAddress address;
-                size_t size;
+            class MemoryRange {
+                private:
+                    KPhysicalAddress m_address;
+                    size_t m_size;
+                    bool m_heap;
+                public:
+                    constexpr MemoryRange() : m_address(Null<KPhysicalAddress>), m_size(0), m_heap(false) { /* ... */ }
 
-                void Close();
+                    void Set(KPhysicalAddress address, size_t size, bool heap) {
+                        m_address = address;
+                        m_size    = size;
+                        m_heap    = heap;
+                    }
+
+                    constexpr KPhysicalAddress GetAddress() const { return m_address; }
+                    constexpr size_t GetSize() const { return m_size; }
+                    constexpr bool IsHeap() const { return m_heap; }
+
+                    void Open();
+                    void Close();
             };
         protected:
             enum MemoryFillValue {

libraries/libmesosphere/include/mesosphere/kern_k_typed_address.hpp

@@ -120,10 +120,6 @@ namespace ams::kern {
                 return m_address == rhs;
             }
 
-            constexpr ALWAYS_INLINE bool operator!=(uintptr_t rhs) const {
-                return m_address != rhs;
-            }
-
             /* Allow getting the address explicitly, for use in accessors. */
             constexpr ALWAYS_INLINE uintptr_t GetValue() const {
                 return m_address;

libraries/libmesosphere/include/mesosphere/kern_slab_helpers.hpp

@@ -164,8 +164,9 @@ namespace ams::kern {
     };
 
 
-    template<typename Derived, typename Base, bool SupportDynamicExpansion = false> requires std::derived_from<Base, KAutoObjectWithList>
+    template<typename Derived, typename Base, bool SupportDynamicExpansion = false>
     class KAutoObjectWithSlabHeapAndContainer : public KAutoObjectWithSlabHeapBase<Derived, Base, SupportDynamicExpansion> {
+        static_assert(std::derived_from<Base, KAutoObjectWithList>);
         private:
             static constinit inline KAutoObjectWithListContainer<Derived> s_container;
         public:

libraries/libmesosphere/source/board/nintendo/nx/kern_k_device_page_table.cpp

@@ -1133,17 +1133,17 @@ namespace ams::kern::board::nintendo::nx {
             size_t cur_size;
             {
                 /* Get the current contiguous range. */
-                KPageTableBase::MemoryRange contig_range = { .address = Null<KPhysicalAddress>, .size = 0 };
+                KPageTableBase::MemoryRange contig_range;
                 R_TRY(page_table->OpenMemoryRangeForMapDeviceAddressSpace(std::addressof(contig_range), process_address + mapped_size, size - mapped_size, ConvertToKMemoryPermission(device_perm), is_aligned));
 
                 /* Ensure we close the range when we're done. */
                 ON_SCOPE_EXIT { contig_range.Close(); };
 
                 /* Get the current size. */
-                cur_size = contig_range.size;
+                cur_size = contig_range.GetSize();
 
                 /* Map the device page. */
-                R_TRY(this->MapDevicePage(contig_range.address, contig_range.size, cur_addr, device_perm));
+                R_TRY(this->MapDevicePage(contig_range.GetAddress(), cur_size, cur_addr, device_perm));
             }
 
             /* Advance. */
@@ -1288,7 +1288,7 @@ namespace ams::kern::board::nintendo::nx {
         MESOSPHERE_ASSERT(((device_address + size - 1) & ~DeviceVirtualAddressMask) == 0);
 
         /* We need to traverse the ranges that make up our mapping, to make sure they're all good. Start by getting a contiguous range. */
-        KPageTableBase::MemoryRange contig_range = { .address = Null<KPhysicalAddress>, .size = 0 };
+        KPageTableBase::MemoryRange contig_range;
         if (R_FAILED(page_table->OpenMemoryRangeForUnmapDeviceAddressSpace(std::addressof(contig_range), process_address, size))) {
             return false;
         }
@@ -1300,8 +1300,8 @@ namespace ams::kern::board::nintendo::nx {
         /* Walk the directory. */
         KProcessAddress cur_process_address = process_address;
         size_t remaining_size               = size;
-        KPhysicalAddress cur_phys_address   = contig_range.address;
-        size_t remaining_in_range           = contig_range.size;
+        KPhysicalAddress cur_phys_address   = contig_range.GetAddress();
+        size_t remaining_in_range           = contig_range.GetSize();
         bool first                          = true;
         u32  first_attr                     = 0;
         while (remaining_size > 0) {
@@ -1347,8 +1347,8 @@ namespace ams::kern::board::nintendo::nx {
                         }
                         range_open = true;
 
-                        cur_phys_address   = contig_range.address;
-                        remaining_in_range = contig_range.size;
+                        cur_phys_address   = contig_range.GetAddress();
+                        remaining_in_range = contig_range.GetSize();
                     }
 
                     /* Check that the physical address is expected. */
@@ -1390,8 +1390,8 @@ namespace ams::kern::board::nintendo::nx {
                     }
                     range_open = true;
 
-                    cur_phys_address   = contig_range.address;
-                    remaining_in_range = contig_range.size;
+                    cur_phys_address   = contig_range.GetAddress();
+                    remaining_in_range = contig_range.GetSize();
                 }
 
                 /* Check that the physical address is expected, and there's enough in the range. */

libraries/libmesosphere/source/kern_k_page_table_base.cpp

@@ -74,8 +74,18 @@ namespace ams::kern {
 
     }
 
+    void KPageTableBase::MemoryRange::Open() {
+        /* If the range contains heap pages, open them. */
+        if (this->IsHeap()) {
+            Kernel::GetMemoryManager().Open(this->GetAddress(), this->GetSize() / PageSize);
+        }
+    }
+
     void KPageTableBase::MemoryRange::Close() {
-        Kernel::GetMemoryManager().Close(address, size / PageSize);
+        /* If the range contains heap pages, close them. */
+        if (this->IsHeap()) {
+            Kernel::GetMemoryManager().Close(this->GetAddress(), this->GetSize() / PageSize);
+        }
     }
 
     Result KPageTableBase::InitializeForKernel(bool is_64_bit, void *table, KVirtualAddress start, KVirtualAddress end) {
@@ -1504,16 +1514,13 @@ namespace ams::kern {
 
         /* Check that the memory is contiguous (modulo the reference count bit). */
         const u32 test_state_mask = state_mask | KMemoryState_FlagReferenceCounted;
-        if (R_FAILED(this->CheckMemoryStateContiguous(address, size, test_state_mask, state | KMemoryState_FlagReferenceCounted, perm_mask, perm, attr_mask, attr))) {
+        const bool is_heap = R_SUCCEEDED(this->CheckMemoryStateContiguous(address, size, test_state_mask, state | KMemoryState_FlagReferenceCounted, perm_mask, perm, attr_mask, attr));
+        if (!is_heap) {
             R_TRY(this->CheckMemoryStateContiguous(address, size, test_state_mask, state, perm_mask, perm, attr_mask, attr));
         }
 
         /* The memory is contiguous, so set the output range. */
-        *out = {
-            .address = phys_address,
-            .size    = size,
-        };
-
+        out->Set(phys_address, size, is_heap);
         R_SUCCEED();
     }
 
@@ -2932,7 +2939,7 @@ namespace ams::kern {
                                                       KMemoryAttribute_IpcLocked | KMemoryAttribute_Locked, KMemoryAttribute_None));
 
         /* We got the range, so open it. */
-        Kernel::GetMemoryManager().Open(out->address, out->size / PageSize);
+        out->Open();
 
         R_SUCCEED();
     }
@@ -2949,7 +2956,7 @@ namespace ams::kern {
                                                       KMemoryAttribute_DeviceShared | KMemoryAttribute_Locked, KMemoryAttribute_DeviceShared));
 
         /* We got the range, so open it. */
-        Kernel::GetMemoryManager().Open(out->address, out->size / PageSize);
+        out->Open();
 
         R_SUCCEED();
     }
@@ -3020,7 +3027,7 @@ namespace ams::kern {
                                                       KMemoryAttribute_Uncached, KMemoryAttribute_None));
 
         /* We got the range, so open it. */
-        Kernel::GetMemoryManager().Open(out->address, out->size / PageSize);
+        out->Open();
 
         R_SUCCEED();
     }

libraries/libmesosphere/source/svc/kern_svc_cache.cpp

@@ -36,15 +36,15 @@ namespace ams::kern::svc {
             size_t remaining = size;
             while (remaining > 0) {
                 /* Get a contiguous range to operate on. */
-                KPageTableBase::MemoryRange contig_range = { .address = Null<KPhysicalAddress>, .size = 0 };
+                KPageTableBase::MemoryRange contig_range;
                 R_TRY(page_table.OpenMemoryRangeForProcessCacheOperation(std::addressof(contig_range), cur_address, aligned_end - cur_address));
 
                 /* Close the range when we're done operating on it. */
                 ON_SCOPE_EXIT { contig_range.Close(); };
 
                 /* Adjust to remain within range. */
-                KVirtualAddress operate_address = KMemoryLayout::GetLinearVirtualAddress(contig_range.address);
-                size_t operate_size             = contig_range.size;
+                KVirtualAddress operate_address = KMemoryLayout::GetLinearVirtualAddress(contig_range.GetAddress());
+                size_t operate_size             = contig_range.GetSize();
                 if (cur_address < address) {
                     operate_address += (address - cur_address);
                     operate_size    -= (address - cur_address);
@@ -57,7 +57,7 @@ namespace ams::kern::svc {
                 operation.Operate(GetVoidPointer(operate_address), operate_size);
 
                 /* Advance. */
-                cur_address += contig_range.size;
+                cur_address += contig_range.GetSize();
                 remaining   -= operate_size;
             }
             MESOSPHERE_ASSERT(remaining == 0);

libraries/libmesosphere/source/svc/kern_svc_physical_memory.cpp

@@ -27,7 +27,7 @@ namespace ams::kern::svc {
             R_UNLESS(size < ams::kern::MainMemorySizeMax,                svc::ResultInvalidSize());
 
             /* Set the heap size. */
-            KProcessAddress address;
+            KProcessAddress address = Null<KProcessAddress>;
             R_TRY(GetCurrentProcess().GetPageTable().SetHeapSize(std::addressof(address), size));
 
             /* Set the output. */

libraries/libstratosphere/include/stratosphere.hpp

@@ -73,6 +73,7 @@
 #include <stratosphere/ldr.hpp>
 #include <stratosphere/lr.hpp>
 #include <stratosphere/lm.hpp>
+#include <stratosphere/mitm.hpp>
 #include <stratosphere/ncm.hpp>
 #include <stratosphere/nim.hpp>
 #include <stratosphere/ns.hpp>

libraries/libstratosphere/include/stratosphere/hos/hos_types.hpp

@@ -78,6 +78,7 @@ namespace ams::hos {
         Version_16_0_0  = ::ams::TargetFirmware_16_0_0,
         Version_16_0_1  = ::ams::TargetFirmware_16_0_1,
         Version_16_0_2  = ::ams::TargetFirmware_16_0_2,
+        Version_16_0_3  = ::ams::TargetFirmware_16_0_3,
 
         Version_Current = ::ams::TargetFirmware_Current,
 

libraries/libstratosphere/include/stratosphere/mitm.hpp

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stratosphere/mitm/impl/mitm_pm_interface.hpp>
+#include <stratosphere/mitm/mitm_pm_api.hpp>

libraries/libstratosphere/include/stratosphere/mitm/impl/mitm_pm_interface.hpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/ncm/ncm_program_id.hpp>
+#include <stratosphere/cfg/cfg_types.hpp>
+#include <stratosphere/sf.hpp>
+
+#define AMS_MITM_PM_IMPL_I_PM_INTERFACE_INFO(C, H) \
+    AMS_SF_METHOD_INFO(C, H, 65000, Result, PrepareLaunchProgram, (sf::Out<u64> out_boost_size, ncm::ProgramId program_id, const cfg::OverrideStatus &override_status, bool is_application), (out_boost_size, program_id, override_status, is_application))
+
+AMS_SF_DEFINE_INTERFACE(ams::mitm::pm::impl, IPmInterface, AMS_MITM_PM_IMPL_I_PM_INTERFACE_INFO, 0xEA88789C)
+

libraries/libstratosphere/include/stratosphere/mitm/mitm_pm_api.hpp

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/ncm/ncm_program_id.hpp>
+
+namespace ams::mitm::pm {
+
+    /* PM API. */
+    void Initialize();
+    void Finalize();
+
+    Result PrepareLaunchProgram(u64 *out, ncm::ProgramId program_id, const cfg::OverrideStatus &status, bool is_application);
+
+}

libraries/libstratosphere/include/stratosphere/pm/impl/pm_shell_interface.hpp

@@ -19,31 +19,32 @@
 #include <stratosphere/pm/pm_types.hpp>
 #include <stratosphere/sf.hpp>
 
-#define AMS_PM_I_SHELL_INTERFACE_INTERFACE_INFO(C, H)                                                                                                                                                                \
-    AMS_SF_METHOD_INFO(C, H,  0, Result, LaunchProgram,                       (sf::Out<os::ProcessId> out_process_id, const ncm::ProgramLocation &loc, u32 flags), (out_process_id, loc, flags))                     \
-    AMS_SF_METHOD_INFO(C, H,  1, Result, TerminateProcess,                    (os::ProcessId process_id),                                                          (process_id))                                     \
-    AMS_SF_METHOD_INFO(C, H,  2, Result, TerminateProgram,                    (ncm::ProgramId program_id),                                                         (program_id))                                     \
-    AMS_SF_METHOD_INFO(C, H,  3, void,   GetProcessEventHandle,               (sf::OutCopyHandle out),                                                             (out))                                            \
-    AMS_SF_METHOD_INFO(C, H,  4, void,   GetProcessEventInfo,                 (sf::Out<pm::ProcessEventInfo> out),                                                 (out))                                            \
-    AMS_SF_METHOD_INFO(C, H,  5, void,   NotifyBootFinished,                  (),                                                                                  ())                                               \
-    AMS_SF_METHOD_INFO(C, H,  6, Result, GetApplicationProcessIdForShell,     (sf::Out<os::ProcessId> out),                                                        (out))                                            \
-    AMS_SF_METHOD_INFO(C, H,  7, Result, BoostSystemMemoryResourceLimit,      (u64 boost_size),                                                                    (boost_size))                                     \
-    AMS_SF_METHOD_INFO(C, H,  8, Result, BoostApplicationThreadResourceLimit, (),                                                                                  ())                                               \
-    AMS_SF_METHOD_INFO(C, H,  9, void,   GetBootFinishedEventHandle,          (sf::OutCopyHandle out),                                                             (out),                        hos::Version_8_0_0) \
-    AMS_SF_METHOD_INFO(C, H, 10, Result, BoostSystemThreadResourceLimit,      (),                                                                                  ())
+#define AMS_PM_I_SHELL_INTERFACE_INTERFACE_INFO(C, H)                                                                                                                                                                               \
+    AMS_SF_METHOD_INFO(C, H,  0,    Result, LaunchProgram,                                   (sf::Out<os::ProcessId> out_process_id, const ncm::ProgramLocation &loc, u32 flags), (out_process_id, loc, flags))                     \
+    AMS_SF_METHOD_INFO(C, H,  1,    Result, TerminateProcess,                                (os::ProcessId process_id),                                                          (process_id))                                     \
+    AMS_SF_METHOD_INFO(C, H,  2,    Result, TerminateProgram,                                (ncm::ProgramId program_id),                                                         (program_id))                                     \
+    AMS_SF_METHOD_INFO(C, H,  3,    void,   GetProcessEventHandle,                           (sf::OutCopyHandle out),                                                             (out))                                            \
+    AMS_SF_METHOD_INFO(C, H,  4,    void,   GetProcessEventInfo,                             (sf::Out<pm::ProcessEventInfo> out),                                                 (out))                                            \
+    AMS_SF_METHOD_INFO(C, H,  5,    void,   NotifyBootFinished,                              (),                                                                                  ())                                               \
+    AMS_SF_METHOD_INFO(C, H,  6,    Result, GetApplicationProcessIdForShell,                 (sf::Out<os::ProcessId> out),                                                        (out))                                            \
+    AMS_SF_METHOD_INFO(C, H,  7,    Result, BoostSystemMemoryResourceLimit,                  (u64 boost_size),                                                                    (boost_size))                                     \
+    AMS_SF_METHOD_INFO(C, H,  8,    Result, BoostApplicationThreadResourceLimit,             (),                                                                                  ())                                               \
+    AMS_SF_METHOD_INFO(C, H,  9,    void,   GetBootFinishedEventHandle,                      (sf::OutCopyHandle out),                                                             (out),                        hos::Version_8_0_0) \
+    AMS_SF_METHOD_INFO(C, H, 10,    Result, BoostSystemThreadResourceLimit,                  (),                                                                                  ())
 
 AMS_SF_DEFINE_INTERFACE(ams::pm::impl, IShellInterface, AMS_PM_I_SHELL_INTERFACE_INTERFACE_INFO, 0x387D60C0)
 
-#define AMS_PM_I_DEPRECATED_SHELL_INTERFACE_INTERFACE_INFO(C, H)                                                                                                                                                \
-    AMS_SF_METHOD_INFO(C, H, 0, Result, LaunchProgram,                   (sf::Out<os::ProcessId> out_process_id, const ncm::ProgramLocation &loc, u32 flags), (out_process_id, loc, flags))                     \
-    AMS_SF_METHOD_INFO(C, H, 1, Result, TerminateProcess,                (os::ProcessId process_id),                                                          (process_id))                                     \
-    AMS_SF_METHOD_INFO(C, H, 2, Result, TerminateProgram,                (ncm::ProgramId program_id),                                                         (program_id))                                     \
-    AMS_SF_METHOD_INFO(C, H, 3, void,   GetProcessEventHandle,           (sf::OutCopyHandle out),                                                             (out))                                            \
-    AMS_SF_METHOD_INFO(C, H, 4, void,   GetProcessEventInfo,             (sf::Out<pm::ProcessEventInfo> out),                                                 (out))                                            \
-    AMS_SF_METHOD_INFO(C, H, 5, Result, CleanupProcess,                  (os::ProcessId process_id),                                                          (process_id))                                     \
-    AMS_SF_METHOD_INFO(C, H, 6, Result, ClearExceptionOccurred,          (os::ProcessId process_id),                                                          (process_id))                                     \
-    AMS_SF_METHOD_INFO(C, H, 7, void,   NotifyBootFinished,              (),                                                                                  ())                                               \
-    AMS_SF_METHOD_INFO(C, H, 8, Result, GetApplicationProcessIdForShell, (sf::Out<os::ProcessId> out),                                                        (out))                                            \
-    AMS_SF_METHOD_INFO(C, H, 9, Result, BoostSystemMemoryResourceLimit,  (u64 boost_size),                                                                    (boost_size),                 hos::Version_4_0_0)
+#define AMS_PM_I_DEPRECATED_SHELL_INTERFACE_INTERFACE_INFO(C, H)                                                                                                                                                                    \
+    AMS_SF_METHOD_INFO(C, H, 0,     Result, LaunchProgram,                                   (sf::Out<os::ProcessId> out_process_id, const ncm::ProgramLocation &loc, u32 flags), (out_process_id, loc, flags))                     \
+    AMS_SF_METHOD_INFO(C, H, 1,     Result, TerminateProcess,                                (os::ProcessId process_id),                                                          (process_id))                                     \
+    AMS_SF_METHOD_INFO(C, H, 2,     Result, TerminateProgram,                                (ncm::ProgramId program_id),                                                         (program_id))                                     \
+    AMS_SF_METHOD_INFO(C, H, 3,     void,   GetProcessEventHandle,                           (sf::OutCopyHandle out),                                                             (out))                                            \
+    AMS_SF_METHOD_INFO(C, H, 4,     void,   GetProcessEventInfo,                             (sf::Out<pm::ProcessEventInfo> out),                                                 (out))                                            \
+    AMS_SF_METHOD_INFO(C, H, 5,     Result, CleanupProcess,                                  (os::ProcessId process_id),                                                          (process_id))                                     \
+    AMS_SF_METHOD_INFO(C, H, 6,     Result, ClearExceptionOccurred,                          (os::ProcessId process_id),                                                          (process_id))                                     \
+    AMS_SF_METHOD_INFO(C, H, 7,     void,   NotifyBootFinished,                              (),                                                                                  ())                                               \
+    AMS_SF_METHOD_INFO(C, H, 8,     Result, GetApplicationProcessIdForShell,                 (sf::Out<os::ProcessId> out),                                                        (out))                                            \
+    AMS_SF_METHOD_INFO(C, H, 9,     Result, BoostSystemMemoryResourceLimit,                  (u64 boost_size),                                                                    (boost_size),                 hos::Version_4_0_0) \
+    AMS_SF_METHOD_INFO(C, H, 10,    Result, BoostSystemThreadResourceLimit,                  (),                                                                                  ())
 
 AMS_SF_DEFINE_INTERFACE(ams::pm::impl, IDeprecatedShellInterface, AMS_PM_I_DEPRECATED_SHELL_INTERFACE_INTERFACE_INFO, 0x387D60C0)

libraries/libstratosphere/source/mitm/mitm_pm.os.horizon.c

@@ -0,0 +1,44 @@
+/*
+ * 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 NX_SERVICE_ASSUME_NON_DOMAIN
+#include "../service_guard.h"
+#include "mitm_pm.os.horizon.h"
+
+static Service g_amsMitmPmSrv;
+
+NX_GENERATE_SERVICE_GUARD(amsMitmPm);
+
+Result _amsMitmPmInitialize(void) {
+    return smGetService(&g_amsMitmPmSrv, "mitm:pm");
+}
+
+void _amsMitmPmCleanup(void) {
+    serviceClose(&g_amsMitmPmSrv);
+}
+
+Service *amsMitmPmGetServiceSession(void) {
+    return &g_amsMitmPmSrv;
+}
+
+Result amsMitmPmPrepareLaunchProgram(u64 *out, u64 program_id, const CfgOverrideStatus *status, bool is_application) {
+    const struct {
+        u8 is_application;
+        u64 program_id;
+        CfgOverrideStatus status;
+    } in = { is_application ? 1 : 0, program_id, *status };
+
+    return serviceDispatchInOut(&g_amsMitmPmSrv, 65000, in, *out);
+}

libraries/libstratosphere/source/mitm/mitm_pm.os.horizon.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <switch.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    u64 keys_down;
+    u64 flags;
+} CfgOverrideStatus;
+
+Result amsMitmPmInitialize(void);
+void amsMitmPmExit(void);
+Service *amsMitmPmGetServiceSession(void);
+
+Result amsMitmPmPrepareLaunchProgram(u64 *out, u64 program_id, const CfgOverrideStatus *status, bool is_application);
+
+#ifdef __cplusplus
+}
+#endif

libraries/libstratosphere/source/mitm/mitm_pm_api.cpp

@@ -0,0 +1,37 @@
+/*
+ * 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 "mitm_pm.os.horizon.h"
+
+namespace ams::mitm::pm {
+
+    /* PM API. */
+    #if defined(ATMOSPHERE_OS_HORIZON)
+    void Initialize() {
+        R_ABORT_UNLESS(amsMitmPmInitialize());
+    }
+
+    void Finalize() {
+        amsMitmPmExit();
+    }
+
+    Result PrepareLaunchProgram(u64 *out, ncm::ProgramId program_id, const cfg::OverrideStatus &status, bool is_application) {
+        static_assert(sizeof(status) == sizeof(CfgOverrideStatus), "CfgOverrideStatus definition!");
+        R_RETURN(amsMitmPmPrepareLaunchProgram(out, program_id.value, reinterpret_cast<const CfgOverrideStatus *>(std::addressof(status)), is_application));
+    }
+    #endif
+
+}

libraries/libstratosphere/source/pm/pm_shell_api.cpp

@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <stratosphere.hpp>
+#include "pm_ams.os.horizon.h"
 
 namespace ams::pm::shell {
 

libraries/libstratosphere/source/sf/hipc/sf_hipc_server_domain_session_manager.cpp

@@ -48,7 +48,7 @@ namespace ams::sf::hipc {
                         AMS_ABORT_UNLESS(ServerManagerBase::CanAnyManageMitmServers());
 
                         /* Clone the forward service. */
-                        std::shared_ptr<::Service> new_forward_service = std::move(ServerSession::CreateForwardService());
+                        std::shared_ptr<::Service> new_forward_service = ServerSession::CreateForwardService();
                         R_ABORT_UNLESS(serviceClone(util::GetReference(m_session->m_forward_service).get(), new_forward_service.get()));
                         R_ABORT_UNLESS(tagged_manager->RegisterMitmSession(server_handle, std::move(clone), std::move(new_forward_service)));
                     }
@@ -168,7 +168,7 @@ namespace ams::sf::hipc {
                         R_ABORT_UNLESS(hipc::CreateSession(std::addressof(server_handle), std::addressof(client_handle)));
 
                         /* Register. */
-                        std::shared_ptr<::Service> new_forward_service = std::move(ServerSession::CreateForwardService());
+                        std::shared_ptr<::Service> new_forward_service = ServerSession::CreateForwardService();
                         serviceCreate(new_forward_service.get(), new_forward_target);
                         R_ABORT_UNLESS(m_manager->RegisterMitmSession(server_handle, std::move(object), std::move(new_forward_service)));
 

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

@@ -17,10 +17,10 @@
 
 #define ATMOSPHERE_RELEASE_VERSION_MAJOR    1
 #define ATMOSPHERE_RELEASE_VERSION_MINOR    5
-#define ATMOSPHERE_RELEASE_VERSION_MICRO    2
+#define ATMOSPHERE_RELEASE_VERSION_MICRO    3
 
 #define ATMOSPHERE_RELEASE_VERSION ATMOSPHERE_RELEASE_VERSION_MAJOR, ATMOSPHERE_RELEASE_VERSION_MINOR, ATMOSPHERE_RELEASE_VERSION_MICRO
 
 #define ATMOSPHERE_SUPPORTED_HOS_VERSION_MAJOR 16
 #define ATMOSPHERE_SUPPORTED_HOS_VERSION_MINOR 0
-#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MICRO 1
+#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MICRO 3

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

@@ -76,8 +76,9 @@
 #define ATMOSPHERE_TARGET_FIRMWARE_16_0_0 ATMOSPHERE_TARGET_FIRMWARE(16,  0,  0)
 #define ATMOSPHERE_TARGET_FIRMWARE_16_0_1 ATMOSPHERE_TARGET_FIRMWARE(16,  0,  1)
 #define ATMOSPHERE_TARGET_FIRMWARE_16_0_2 ATMOSPHERE_TARGET_FIRMWARE(16,  0,  2)
+#define ATMOSPHERE_TARGET_FIRMWARE_16_0_3 ATMOSPHERE_TARGET_FIRMWARE(16,  0,  3)
 
-#define ATMOSPHERE_TARGET_FIRMWARE_CURRENT ATMOSPHERE_TARGET_FIRMWARE_16_0_2
+#define ATMOSPHERE_TARGET_FIRMWARE_CURRENT ATMOSPHERE_TARGET_FIRMWARE_16_0_3
 
 #define ATMOSPHERE_TARGET_FIRMWARE_MIN ATMOSPHERE_TARGET_FIRMWARE(0, 0, 0)
 #define ATMOSPHERE_TARGET_FIRMWARE_MAX ATMOSPHERE_TARGET_FIRMWARE_CURRENT
@@ -146,6 +147,7 @@ namespace ams {
         TargetFirmware_16_0_0  = ATMOSPHERE_TARGET_FIRMWARE_16_0_0,
         TargetFirmware_16_0_1  = ATMOSPHERE_TARGET_FIRMWARE_16_0_1,
         TargetFirmware_16_0_2  = ATMOSPHERE_TARGET_FIRMWARE_16_0_2,
+        TargetFirmware_16_0_3  = ATMOSPHERE_TARGET_FIRMWARE_16_0_3,
 
         TargetFirmware_Current = ATMOSPHERE_TARGET_FIRMWARE_CURRENT,
 

libraries/libvapours/include/vapours/results/fs_results.hpp

@@ -41,8 +41,9 @@ namespace ams::fs {
         R_DEFINE_ERROR_RESULT(MountNameAlreadyExists, 60);
 
     R_DEFINE_ERROR_RANGE(HandledBySystemProcess, 1000, 2999);
-        R_DEFINE_ERROR_RESULT(PartitionNotFound,    1001);
-        R_DEFINE_ERROR_RESULT(TargetNotFound,       1002);
+        R_DEFINE_ERROR_RESULT(PartitionNotFound,      1001);
+        R_DEFINE_ERROR_RESULT(TargetNotFound,         1002);
+        R_DEFINE_ERROR_RESULT(NcaExternalKeyNotFound, 1004);
 
         R_DEFINE_ERROR_RANGE(SdCardAccessFailed, 2000, 2499);
             R_DEFINE_ERROR_RESULT(SdCardNotPresent, 2001);

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

@@ -144,10 +144,6 @@ namespace ams::util {
                             return m_node == rhs.m_node;
                         }
 
-                        constexpr ALWAYS_INLINE bool operator!=(const Iterator &rhs) const {
-                            return !(*this == rhs);
-                        }
-
                         constexpr ALWAYS_INLINE pointer operator->() const {
                             return m_node;
                         }
@@ -355,10 +351,6 @@ namespace ams::util {
                         return m_iterator == rhs.m_iterator;
                     }
 
-                    constexpr ALWAYS_INLINE bool operator!=(const Iterator &rhs) const {
-                        return !(*this == rhs);
-                    }
-
                     constexpr ALWAYS_INLINE pointer operator->() const {
                         return std::addressof(Traits::GetParent(*m_iterator));
                     }

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

@@ -94,10 +94,6 @@ namespace ams::util {
                             return m_node == rhs.m_node;
                         }
 
-                        constexpr ALWAYS_INLINE bool operator!=(const Iterator &rhs) const {
-                            return !(*this == rhs);
-                        }
-
                         constexpr ALWAYS_INLINE pointer operator->() const {
                             return m_node;
                         }
@@ -304,10 +300,6 @@ namespace ams::util {
                         return m_impl == rhs.m_impl;
                     }
 
-                    constexpr ALWAYS_INLINE bool operator!=(const Iterator &rhs) const {
-                        return !(*this == rhs);
-                    }
-
                     constexpr ALWAYS_INLINE pointer operator->() const {
                         return Traits::GetParent(std::addressof(*m_impl));
                     }

stratosphere/ams_mitm/ams_mitm.json

@@ -65,6 +65,8 @@
                 "svcReplyAndReceive":	"0x43",
                 "svcReplyAndReceiveWithUserBuffer":	"0x44",
                 "svcCreateEvent":	"0x45",
+				"svcMapPhysicalMemoryUnsafe":	"0x48",
+				"svcUnmapPhysicalMemoryUnsafe":	"0x49",
                 "svcMapTransferMemory":	"0x51",
                 "svcUnmapTransferMemory":	"0x52",
                 "svcCreateInterruptEvent":	"0x53",

stratosphere/ams_mitm/source/amsmitm_module_management.cpp

@@ -24,6 +24,7 @@
 #include "ns_mitm/nsmitm_module.hpp"
 #include "dns_mitm/dnsmitm_module.hpp"
 #include "sysupdater/sysupdater_module.hpp"
+#include "mitm_pm/mitm_pm_module.hpp"
 
 namespace ams::mitm {
 
@@ -37,6 +38,7 @@ namespace ams::mitm {
             ModuleId_NsMitm,
             ModuleId_DnsMitm,
             ModuleId_Sysupdater,
+            ModuleId_PmService,
 
             ModuleId_Count,
         };
@@ -70,6 +72,7 @@ namespace ams::mitm {
             GetModuleDefinition<ns::MitmModule>(),
             GetModuleDefinition<socket::resolver::MitmModule>(),
             GetModuleDefinition<sysupdater::MitmModule>(),
+            GetModuleDefinition<pm::MitmModule>(),
         };
 
     }

stratosphere/ams_mitm/source/fs_mitm/fs_mitm_service.cpp

@@ -71,7 +71,7 @@ namespace ams::mitm::fs {
         Result OpenHblWebContentFileSystem(sf::Out<sf::SharedPointer<ams::fssrv::sf::IFileSystem>> &out, ncm::ProgramId program_id) {
             /* Verify eligibility. */
             bool is_hbl;
-            R_UNLESS(R_SUCCEEDED(pm::info::IsHblProgramId(std::addressof(is_hbl), program_id)), sm::mitm::ResultShouldForwardToSession());
+            R_UNLESS(R_SUCCEEDED(ams::pm::info::IsHblProgramId(std::addressof(is_hbl), program_id)), sm::mitm::ResultShouldForwardToSession());
             R_UNLESS(is_hbl,                                                     sm::mitm::ResultShouldForwardToSession());
 
             /* Hbl html directory must exist. */

stratosphere/ams_mitm/source/fs_mitm/fs_mitm_service.hpp

@@ -54,7 +54,8 @@ namespace ams::mitm::fs {
                 }
 
                 /* We want to mitm sdb, to support sd-romfs redirection of common system archives (like system font, etc). */
-                if (program_id == ncm::SystemProgramId::Sdb) {
+                /* NOTE: In 16.0.0+, this was moved to glue. */
+                if (program_id == ncm::SystemProgramId::Sdb || program_id == ncm::SystemProgramId::Glue) {
                     return true;
                 }
 

stratosphere/ams_mitm/source/fs_mitm/fsmitm_layered_romfs_storage.cpp

@@ -78,6 +78,7 @@ namespace ams::mitm::fs {
 
         constinit os::SdkRecursiveMutex g_storage_set_mutex;
         constinit LayeredRomfsStorageSet g_storage_set;
+        constinit os::SdkMutex g_initialization_mutex;
 
         void OpenReference(LayeredRomfsStorageImpl *impl) {
             std::scoped_lock lk(g_storage_set_mutex);
@@ -106,6 +107,8 @@ namespace ams::mitm::fs {
                 auto *impl = reinterpret_cast<LayeredRomfsStorageImpl *>(storage_uptr);
                 g_ack_mq.Send(storage_uptr);
 
+                std::scoped_lock lk(g_initialization_mutex);
+
                 impl->InitializeImpl();
 
                 /* Close the initial reference. */
@@ -255,6 +258,21 @@ namespace ams::mitm::fs {
         return std::make_shared<LayeredRomfsStorage>(impl);
     }
 
+    void FinalizeLayeredRomfsStorage(ncm::ProgramId program_id) {
+        std::scoped_lock lk(g_initialization_mutex);
+        std::scoped_lock lk2(g_storage_set_mutex);
+
+        /* Find an existing storage. */
+        if (auto it = g_storage_set.find_key(program_id.value); it != g_storage_set.end()) {
+            /* We need to delete the process romfs. Require invariant that it is unreferenced, by this point. */
+            AMS_ABORT_UNLESS(it->GetReferenceCount() == 0);
+
+            auto *holder = std::addressof(*it);
+            it = g_storage_set.erase(it);
+            delete holder;
+        }
+    }
+
     LayeredRomfsStorageImpl::LayeredRomfsStorageImpl(std::unique_ptr<IStorage> s_r, std::unique_ptr<IStorage> f_r, ncm::ProgramId pr_id) : m_storage_romfs(std::move(s_r)), m_file_romfs(std::move(f_r)), m_initialize_event(os::EventClearMode_ManualClear), m_program_id(std::move(pr_id)), m_is_initialized(false), m_started_initialize(false) {
         /* ... */
     }

stratosphere/ams_mitm/source/fs_mitm/fsmitm_layered_romfs_storage.hpp

@@ -22,7 +22,7 @@ namespace ams::mitm::fs {
 
     class LayeredRomfsStorageImpl {
         private:
-            std::vector<romfs::SourceInfo> m_source_infos;
+            romfs::Builder::SourceInfoVector m_source_infos;
             std::unique_ptr<ams::fs::IStorage> m_storage_romfs;
             std::unique_ptr<ams::fs::IStorage> m_file_romfs;
             os::Event m_initialize_event;
@@ -51,4 +51,6 @@ namespace ams::mitm::fs {
 
     std::shared_ptr<ams::fs::IStorage> GetLayeredRomfsStorage(ncm::ProgramId program_id, ::FsStorage &data_storage, bool is_process_romfs);
 
+    void FinalizeLayeredRomfsStorage(ncm::ProgramId program_id);
+
 }

stratosphere/ams_mitm/source/fs_mitm/fsmitm_romfs.cpp

@@ -16,6 +16,7 @@
 #include <stratosphere.hpp>
 #include "../amsmitm_fs_utils.hpp"
 #include "fsmitm_romfs.hpp"
+#include "fsmitm_layered_romfs_storage.hpp"
 
 namespace ams::mitm::fs {
 
@@ -23,6 +24,206 @@ namespace ams::mitm::fs {
 
     namespace romfs {
 
+        namespace {
+
+            struct ApplicationWithDynamicHeapInfo {
+                ncm::ProgramId program_id;
+                size_t dynamic_app_heap_size;
+                size_t dynamic_system_heap_size;
+            };
+
+            constexpr const ApplicationWithDynamicHeapInfo ApplicationsWithDynamicHeap[] = {
+                /* Animal Crossing: New Horizons. */
+                /* Requirement ~24 MB. */
+                /* No particular heap sensitivity. */
+                { 0x01006F8002326000,  16_MB, 0_MB },
+
+                /* Fire Emblem: Engage. */
+                /* Requirement ~32+ MB. */
+                /* No particular heap sensitivity. */
+                { 0x0100A6301214E000,  16_MB, 0_MB },
+
+                /* The Legend of Zelda: Tears of the Kingdom. */
+                /* Requirement ~48 MB. */
+                /* Game is highly sensitive to memory stolen from application heap. */
+                /* 1.0.0 tolerates no more than 16 MB stolen. 1.1.0 no more than 12 MB. */
+                { 0x0100F2C0115B6000,  10_MB, 8_MB },
+            };
+
+            constexpr size_t GetDynamicAppHeapSize(ncm::ProgramId program_id) {
+                for (const auto &info : ApplicationsWithDynamicHeap) {
+                    if (info.program_id == program_id) {
+                        return info.dynamic_app_heap_size;
+                    }
+                }
+
+                return 0;
+            }
+
+            constexpr size_t GetDynamicSysHeapSize(ncm::ProgramId program_id) {
+                for (const auto &info : ApplicationsWithDynamicHeap) {
+                    if (info.program_id == program_id) {
+                        return info.dynamic_system_heap_size;
+                    }
+                }
+
+                return 0;
+            }
+
+            template<auto MapImpl, auto UnmapImpl>
+            struct DynamicHeap {
+                uintptr_t heap_address{};
+                size_t heap_size{};
+                size_t outstanding_allocations{};
+                util::TypedStorage<mem::StandardAllocator> heap{};
+                os::SdkMutex release_heap_lock{};
+
+                constexpr DynamicHeap() = default;
+
+                void Map() {
+                    if (this->heap_address == 0) {
+                        /* NOTE: Lock not necessary, because this is the only location which do 0 -> non-zero. */
+
+                        R_ABORT_UNLESS(MapImpl(std::addressof(this->heap_address), this->heap_size));
+                        AMS_ABORT_UNLESS(this->heap_address != 0);
+
+                        /* Create heap. */
+                        util::ConstructAt(this->heap, reinterpret_cast<void *>(this->heap_address), this->heap_size);
+                    }
+                }
+
+                void TryRelease() {
+                    if (this->outstanding_allocations == 0) {
+                        std::scoped_lock lk(this->release_heap_lock);
+
+                        if (this->heap_address != 0) {
+                            util::DestroyAt(this->heap);
+                            this->heap = {};
+
+                            R_ABORT_UNLESS(UnmapImpl(this->heap_address, this->heap_size));
+
+                            this->heap_address = 0;
+                        }
+                    }
+                }
+
+                void *Allocate(size_t size) {
+                    void * const ret = util::GetReference(this->heap).Allocate(size);
+                    if (AMS_LIKELY(ret != nullptr)) {
+                        ++this->outstanding_allocations;
+                    }
+                    return ret;
+                }
+
+                bool TryFree(void *p) {
+                    if (this->IsAllocated(p)) {
+                        --this->outstanding_allocations;
+
+                        util::GetReference(this->heap).Free(p);
+
+                        return true;
+                    } else {
+                        return false;
+                    }
+                }
+
+                bool IsAllocated(void *p) const {
+                    const uintptr_t address = reinterpret_cast<uintptr_t>(p);
+
+                    return this->heap_address != 0 && (this->heap_address <= address && address < this->heap_address + this->heap_size);
+                }
+
+                void Reset() {
+                    /* This should require no remaining allocations. */
+                    AMS_ABORT_UNLESS(this->outstanding_allocations == 0);
+
+                    /* Free the heap. */
+                    this->TryRelease();
+                    AMS_ABORT_UNLESS(this->heap_address == 0);
+
+                    /* Clear the heap size. */
+                    this->heap_size = 0;
+                }
+            };
+
+            Result MapByHeap(uintptr_t *out, size_t size) {
+                R_TRY(os::SetMemoryHeapSize(size));
+                R_RETURN(os::AllocateMemoryBlock(out, size));
+            }
+
+            Result UnmapByHeap(uintptr_t address, size_t size) {
+                os::FreeMemoryBlock(address, size);
+                R_RETURN(os::SetMemoryHeapSize(0));
+            }
+
+            /* Dynamic allocation globals. */
+            constinit os::SdkMutex g_romfs_build_lock;
+            constinit ncm::ProgramId g_dynamic_heap_program_id{};
+
+            constinit bool g_building_from_dynamic_heap = false;
+
+            constinit DynamicHeap<os::AllocateUnsafeMemory, os::FreeUnsafeMemory> g_dynamic_app_heap;
+            constinit DynamicHeap<MapByHeap, UnmapByHeap> g_dynamic_sys_heap;
+
+            void InitializeDynamicHeapForBuildRomfs(ncm::ProgramId program_id) {
+                if (program_id == g_dynamic_heap_program_id && g_dynamic_app_heap.heap_size > 0) {
+                    /* This romfs will build out of dynamic heap. */
+                    g_building_from_dynamic_heap = true;
+
+                    g_dynamic_app_heap.Map();
+
+                    if (g_dynamic_sys_heap.heap_size > 0) {
+                        g_dynamic_sys_heap.Map();
+                    }
+                }
+            }
+
+            void FinalizeDynamicHeapForBuildRomfs() {
+                /* We are definitely no longer building out of dynamic heap. */
+                g_building_from_dynamic_heap = false;
+
+                g_dynamic_app_heap.TryRelease();
+            }
+
+        }
+
+        void *AllocateTracked(AllocationType type, size_t size) {
+            AMS_UNUSED(type);
+
+            if (g_building_from_dynamic_heap) {
+                void *ret = g_dynamic_app_heap.Allocate(size);
+
+                if (ret == nullptr && g_dynamic_sys_heap.heap_address != 0) {
+                    ret = g_dynamic_sys_heap.Allocate(size);
+                }
+
+                if (ret == nullptr) {
+                    ret = std::malloc(size);
+                }
+
+                return ret;
+            } else {
+                return std::malloc(size);
+            }
+        }
+
+        void FreeTracked(AllocationType type, void *p, size_t size) {
+            AMS_UNUSED(type);
+            AMS_UNUSED(size);
+
+            if (g_dynamic_app_heap.TryFree(p)) {
+                if (!g_building_from_dynamic_heap) {
+                    g_dynamic_app_heap.TryRelease();
+                }
+            } else if (g_dynamic_sys_heap.TryFree(p)) {
+                if (!g_building_from_dynamic_heap) {
+                    g_dynamic_sys_heap.TryRelease();
+                }
+            } else {
+                std::free(p);
+            }
+        }
+
         namespace {
 
             constexpr u32 EmptyEntry = 0xFFFFFFFF;
@@ -71,22 +272,23 @@ namespace ams::mitm::fs {
                     static constexpr size_t MaxCachedSize = (1_MB / 4);
                 private:
                     size_t m_cache_bitsize;
+                    size_t m_cache_size;
                 protected:
                     void *m_cache;
                 protected:
                     DynamicTableCache(size_t sz) {
-                        size_t cache_size = util::CeilingPowerOfTwo(std::min(sz, MaxCachedSize));
-                        m_cache = std::malloc(cache_size);
+                        m_cache_size = util::CeilingPowerOfTwo(std::min(sz, MaxCachedSize));
+                        m_cache = AllocateTracked(AllocationType_TableCache, m_cache_size);
                         while (m_cache == nullptr) {
-                            cache_size >>= 1;
-                            AMS_ABORT_UNLESS(cache_size >= 16_KB);
-                            m_cache = std::malloc(cache_size);
+                            m_cache_size  >>= 1;
+                            AMS_ABORT_UNLESS(m_cache_size  >= 16_KB);
+                            m_cache = AllocateTracked(AllocationType_TableCache, m_cache_size);
                         }
-                        m_cache_bitsize = util::CountTrailingZeros(cache_size);
+                        m_cache_bitsize = util::CountTrailingZeros(m_cache_size);
                     }
 
                     ~DynamicTableCache() {
-                        std::free(m_cache);
+                        FreeTracked(AllocationType_TableCache, m_cache, m_cache_size);
                     }
 
                     ALWAYS_INLINE size_t GetCacheSize() const { return static_cast<size_t>(1) << m_cache_bitsize; }
@@ -113,21 +315,33 @@ namespace ams::mitm::fs {
                     size_t m_cache_idx;
                     u8 m_fallback_cache[FallbackCacheSize];
                 private:
-                    ALWAYS_INLINE void Read(size_t ofs, void *dst, size_t size) {
-                        R_ABORT_UNLESS(m_storage->Read(m_offset + ofs, dst, size));
+                    ALWAYS_INLINE bool Read(size_t ofs, void *dst, size_t size) {
+                        R_TRY_CATCH(m_storage->Read(m_offset + ofs, dst, size)) {
+                            R_CATCH(fs::ResultNcaExternalKeyNotFound) { return false; }
+                        } R_END_TRY_CATCH_WITH_ABORT_UNLESS;
+
+                        return true;
                     }
-                    ALWAYS_INLINE void ReloadCacheImpl(size_t idx) {
+                    ALWAYS_INLINE bool ReloadCacheImpl(size_t idx) {
                         const size_t rel_ofs = idx * this->GetCacheSize();
                         AMS_ABORT_UNLESS(rel_ofs < m_size);
                         const size_t new_cache_size = std::min(m_size - rel_ofs, this->GetCacheSize());
-                        this->Read(rel_ofs, m_cache, new_cache_size);
+                        if (!this->Read(rel_ofs, m_cache, new_cache_size)) {
+                            return false;
+                        }
+
                         m_cache_idx = idx;
+                        return true;
                     }
 
-                    ALWAYS_INLINE void ReloadCache(size_t idx) {
+                    ALWAYS_INLINE bool ReloadCache(size_t idx) {
                         if (m_cache_idx != idx) {
-                            this->ReloadCacheImpl(idx);
+                            if (!this->ReloadCacheImpl(idx)) {
+                                return false;
+                            }
                         }
+
+                        return true;
                     }
 
                     ALWAYS_INLINE size_t GetCacheIndex(u32 ofs) {
@@ -140,13 +354,18 @@ namespace ams::mitm::fs {
                     }
 
                     const Entry *GetEntry(u32 entry_offset) {
-                        this->ReloadCache(this->GetCacheIndex(entry_offset));
+                        if (!this->ReloadCache(this->GetCacheIndex(entry_offset))) {
+                            return nullptr;
+                        }
 
                         const size_t ofs = entry_offset % this->GetCacheSize();
 
                         const Entry *entry = reinterpret_cast<const Entry *>(reinterpret_cast<uintptr_t>(m_cache) + ofs);
                         if (AMS_UNLIKELY(this->GetCacheIndex(entry_offset) != this->GetCacheIndex(entry_offset + sizeof(Entry) + entry->name_size + sizeof(u32)))) {
-                            this->Read(entry_offset, m_fallback_cache, std::min(m_size - entry_offset, FallbackCacheSize));
+                            if (!this->Read(entry_offset, m_fallback_cache, std::min(m_size - entry_offset, FallbackCacheSize))) {
+                                return nullptr;
+                            }
+
                             entry = reinterpret_cast<const Entry *>(m_fallback_cache);
                         }
                         return entry;
@@ -251,12 +470,11 @@ namespace ams::mitm::fs {
             using DirectoryTableWriter = TableWriter<DirectoryEntry>;
             using FileTableWriter      = TableWriter<FileEntry>;
 
-            constexpr inline u32 CalculatePathHash(u32 parent, const char *_path, u32 start, size_t path_len) {
-                const unsigned char *path = reinterpret_cast<const unsigned char *>(_path);
+            constexpr inline u32 CalculatePathHash(u32 parent, const char *path, u32 start, size_t path_len) {
                 u32 hash = parent ^ 123456789;
                 for (size_t i = 0; i < path_len; i++) {
                     hash = (hash >> 5) | (hash << 27);
-                    hash ^= path[start + i];
+                    hash ^= static_cast<unsigned char>(path[start + i]);
                 }
                 return hash;
             }
@@ -294,13 +512,28 @@ namespace ams::mitm::fs {
         }
 
         Builder::Builder(ncm::ProgramId pr_id) : m_program_id(pr_id), m_num_dirs(0), m_num_files(0), m_dir_table_size(0), m_file_table_size(0), m_dir_hash_table_size(0), m_file_hash_table_size(0), m_file_partition_size(0) {
-            auto res = m_directories.emplace(std::make_unique<BuildDirectoryContext>(BuildDirectoryContext::RootTag{}));
+            /* Ensure only one romfs is built at any time. */
+            g_romfs_build_lock.Lock();
+
+            /* If we should be using dynamic heap, turn it on. */
+            InitializeDynamicHeapForBuildRomfs(m_program_id);
+
+            auto res = m_directories.emplace(std::unique_ptr<BuildDirectoryContext>(AllocateTyped<BuildDirectoryContext>(AllocationType_BuildDirContext, BuildDirectoryContext::RootTag{})));
             AMS_ABORT_UNLESS(res.second);
             m_root = res.first->get();
             m_num_dirs = 1;
             m_dir_table_size = 0x18;
         }
 
+        Builder::~Builder() {
+            /* If we have nothing remaining in dynamic heap, release it. */
+            FinalizeDynamicHeapForBuildRomfs();
+
+            /* Release the romfs build lock. */
+            g_romfs_build_lock.Unlock();
+        }
+
+
         void Builder::AddDirectory(BuildDirectoryContext **out, BuildDirectoryContext *parent_ctx, std::unique_ptr<BuildDirectoryContext> child_ctx) {
             /* Set parent context member. */
             child_ctx->parent = parent_ctx;
@@ -348,9 +581,9 @@ namespace ams::mitm::fs {
             AMS_ABORT_UNLESS(num_child_dirs >= 0);
 
             {
-                BuildDirectoryContext **child_dirs = num_child_dirs != 0 ? reinterpret_cast<BuildDirectoryContext **>(std::malloc(sizeof(BuildDirectoryContext *) * num_child_dirs)) : nullptr;
+                BuildDirectoryContext **child_dirs = num_child_dirs != 0 ? reinterpret_cast<BuildDirectoryContext **>(AllocateTracked(AllocationType_DirPointerArray, sizeof(BuildDirectoryContext *) * num_child_dirs)) : nullptr;
                 AMS_ABORT_UNLESS(num_child_dirs == 0 || child_dirs != nullptr);
-                ON_SCOPE_EXIT { std::free(child_dirs); };
+                ON_SCOPE_EXIT { if (child_dirs != nullptr) { FreeTracked(AllocationType_DirPointerArray, child_dirs, sizeof(BuildDirectoryContext *) * num_child_dirs); } };
 
                 s64 cur_child_dir_ind = 0;
                 {
@@ -369,12 +602,12 @@ namespace ams::mitm::fs {
                             AMS_ABORT_UNLESS(child_dirs != nullptr);
 
                             BuildDirectoryContext *real_child = nullptr;
-                            this->AddDirectory(std::addressof(real_child), parent, std::make_unique<BuildDirectoryContext>(m_dir_entry.name, strlen(m_dir_entry.name)));
+                            this->AddDirectory(std::addressof(real_child), parent, std::unique_ptr<BuildDirectoryContext>(AllocateTyped<BuildDirectoryContext>(AllocationType_BuildDirContext, m_dir_entry.name, strlen(m_dir_entry.name))));
                             AMS_ABORT_UNLESS(real_child != nullptr);
                             child_dirs[cur_child_dir_ind++] = real_child;
                             AMS_ABORT_UNLESS(cur_child_dir_ind <= num_child_dirs);
                         } else /* if (m_dir_entry.type == FsDirEntryType_File) */ {
-                            this->AddFile(parent, std::make_unique<BuildFileContext>(m_dir_entry.name, strlen(m_dir_entry.name), m_dir_entry.file_size, 0, m_cur_source_type));
+                            this->AddFile(parent, std::unique_ptr<BuildFileContext>(AllocateTyped<BuildFileContext>(AllocationType_BuildFileContext, m_dir_entry.name, strlen(m_dir_entry.name), m_dir_entry.file_size, 0, m_cur_source_type)));
                         }
                     }
                 }
@@ -399,12 +632,18 @@ namespace ams::mitm::fs {
 
         void Builder::VisitDirectory(BuildDirectoryContext *parent, u32 parent_offset, DirectoryTableReader &dir_table, FileTableReader &file_table) {
             const DirectoryEntry *parent_entry = dir_table.GetEntry(parent_offset);
+            if (AMS_UNLIKELY(parent_entry == nullptr)) {
+                return;
+            }
 
             u32 cur_file_offset = parent_entry->file;
             while (cur_file_offset != EmptyEntry) {
                 const FileEntry *cur_file = file_table.GetEntry(cur_file_offset);
+                if (AMS_UNLIKELY(cur_file == nullptr)) {
+                    return;
+                }
 
-                this->AddFile(parent, std::make_unique<BuildFileContext>(cur_file->name, cur_file->name_size, cur_file->size, cur_file->offset, m_cur_source_type));
+                this->AddFile(parent, std::unique_ptr<BuildFileContext>(AllocateTyped<BuildFileContext>(AllocationType_BuildFileContext, cur_file->name, cur_file->name_size, cur_file->size, cur_file->offset, m_cur_source_type)));
 
                 cur_file_offset = cur_file->sibling;
             }
@@ -415,8 +654,11 @@ namespace ams::mitm::fs {
                 u32 next_child_offset = 0;
                 {
                     const DirectoryEntry *cur_child = dir_table.GetEntry(cur_child_offset);
+                    if (AMS_UNLIKELY(cur_child == nullptr)) {
+                        return;
+                    }
 
-                    this->AddDirectory(std::addressof(real_child), parent, std::make_unique<BuildDirectoryContext>(cur_child->name, cur_child->name_size));
+                    this->AddDirectory(std::addressof(real_child), parent, std::unique_ptr<BuildDirectoryContext>(AllocateTyped<BuildDirectoryContext>(AllocationType_BuildDirContext, cur_child->name, cur_child->name_size)));
                     AMS_ABORT_UNLESS(real_child != nullptr);
 
                     next_child_offset = cur_child->sibling;
@@ -439,7 +681,7 @@ namespace ams::mitm::fs {
             /* If there is no romfs folder on the SD, don't bother continuing. */
             {
                 FsDir dir;
-                if (R_FAILED(mitm::fs::OpenAtmosphereRomfsDirectory(std::addressof(dir), m_program_id, m_root->path.get(), OpenDirectoryMode_Directory, std::addressof(sd_filesystem)))) {
+                if (R_FAILED(mitm::fs::OpenAtmosphereRomfsDirectory(std::addressof(dir), m_program_id, m_root->path, OpenDirectoryMode_Directory, std::addressof(sd_filesystem)))) {
                     return;
                 }
                 fsDirClose(std::addressof(dir));
@@ -462,7 +704,7 @@ namespace ams::mitm::fs {
             this->VisitDirectory(m_root, 0x0, dir_table, file_table);
         }
 
-        void Builder::Build(std::vector<SourceInfo> *out_infos) {
+        void Builder::Build(SourceInfoVector *out_infos) {
             /* Clear output. */
             out_infos->clear();
 
@@ -478,7 +720,7 @@ namespace ams::mitm::fs {
             m_file_hash_table_size = sizeof(u32) * num_file_hash_table_entries;
 
             /* Allocate metadata, make pointers. */
-            Header *header = reinterpret_cast<Header *>(std::malloc(sizeof(Header)));
+            Header *header = reinterpret_cast<Header *>(AllocateTracked(AllocationType_Memory, sizeof(Header)));
             std::memset(header, 0x00, sizeof(*header));
 
             /* Open metadata file. */
@@ -553,13 +795,13 @@ namespace ams::mitm::fs {
             /* Set all files' hash value = hash index. */
             for (const auto &it : m_files) {
                 BuildFileContext *cur_file = it.get();
-                cur_file->hash_value = CalculatePathHash(cur_file->parent->entry_offset, cur_file->path.get(), 0, cur_file->path_len) % num_file_hash_table_entries;
+                cur_file->hash_value = CalculatePathHash(cur_file->parent->entry_offset, cur_file->path, 0, cur_file->path_len) % num_file_hash_table_entries;
             }
 
             /* Set all directories' hash value = hash index. */
             for (const auto &it : m_directories) {
                 BuildDirectoryContext *cur_dir = it.get();
-                cur_dir->hash_value = CalculatePathHash(cur_dir == m_root ? 0 : cur_dir->parent->entry_offset, cur_dir->path.get(), 0, cur_dir->path_len) % num_dir_hash_table_entries;
+                cur_dir->hash_value = CalculatePathHash(cur_dir == m_root ? 0 : cur_dir->parent->entry_offset, cur_dir->path, 0, cur_dir->path_len) % num_dir_hash_table_entries;
             }
 
             /* Write hash tables. */
@@ -662,7 +904,7 @@ namespace ams::mitm::fs {
                     const u32 name_size = cur_file->path_len;
                     cur_entry->name_size = name_size;
                     if (name_size) {
-                        std::memcpy(cur_entry->name, cur_file->path.get(), name_size);
+                        std::memcpy(cur_entry->name, cur_file->path, name_size);
                         for (size_t i = name_size; i < util::AlignUp(name_size, 4); i++) {
                             cur_entry->name[i] = 0;
                         }
@@ -689,9 +931,10 @@ namespace ams::mitm::fs {
                                 AMS_ABORT_UNLESS(path_needed_size <= sizeof(full_path));
                                 cur_file->GetPath(full_path);
 
-                                cur_file->path.reset();
+                                FreeTracked(AllocationType_FileName, cur_file->path, cur_file->path_len + 1);
+                                cur_file->path = nullptr;
 
-                                char *new_path = new char[path_needed_size];
+                                char *new_path = static_cast<char *>(AllocateTracked(AllocationType_FullPath, path_needed_size));
                                 std::memcpy(new_path, full_path, path_needed_size);
                                 out_infos->emplace_back(cur_file->offset + FilePartitionOffset, cur_file->size, cur_file->source_type, new_path);
                             }
@@ -720,7 +963,7 @@ namespace ams::mitm::fs {
                     const u32 name_size = cur_dir->path_len;
                     cur_entry->name_size = name_size;
                     if (name_size) {
-                        std::memcpy(cur_entry->name, cur_dir->path.get(), name_size);
+                        std::memcpy(cur_entry->name, cur_dir->path, name_size);
                         for (size_t i = name_size; i < util::AlignUp(name_size, 4); i++) {
                             cur_entry->name[i] = 0;
                         }
@@ -752,6 +995,39 @@ namespace ams::mitm::fs {
             }
         }
 
+        Result ConfigureDynamicHeap(u64 *out_size, ncm::ProgramId program_id, const cfg::OverrideStatus &status, bool is_application) {
+            /* Baseline: use no dynamic heap. */
+            *out_size = 0;
+
+            /* If the process is not an application, we do not care about dynamic heap. */
+            R_SUCCEED_IF(!is_application);
+
+            /* First, we need to ensure that, if the game used dynamic heap, we clear it. */
+            if (g_dynamic_app_heap.heap_size > 0) {
+                mitm::fs::FinalizeLayeredRomfsStorage(g_dynamic_heap_program_id);
+
+                /* Free the heap. */
+                g_dynamic_app_heap.Reset();
+                g_dynamic_sys_heap.Reset();
+            }
+
+            /* Next, if we aren't going to end up building a romfs, we can ignore dynamic heap. */
+            R_SUCCEED_IF(!status.IsProgramSpecific());
+
+            /* Only mitm if there is actually an override romfs. */
+            R_SUCCEED_IF(!mitm::fs::HasSdRomfsContent(program_id));
+
+            /* Next, set the new program id for dynamic heap. */
+            g_dynamic_heap_program_id    = program_id;
+            g_dynamic_app_heap.heap_size = GetDynamicAppHeapSize(g_dynamic_heap_program_id);
+            g_dynamic_sys_heap.heap_size = GetDynamicSysHeapSize(g_dynamic_heap_program_id);
+
+            /* Set output. */
+            *out_size = g_dynamic_app_heap.heap_size;
+
+            R_SUCCEED();
+        }
+
     }
 
 }

stratosphere/ams_mitm/source/fs_mitm/fsmitm_romfs.hpp

@@ -27,6 +27,52 @@ namespace ams::mitm::fs::romfs {
         Memory,
     };
 
+    enum AllocationType {
+        AllocationType_FileName,
+        AllocationType_DirName,
+        AllocationType_FullPath,
+        AllocationType_SourceInfo,
+        AllocationType_BuildFileContext,
+        AllocationType_BuildDirContext,
+        AllocationType_TableCache,
+        AllocationType_DirPointerArray,
+        AllocationType_DirContextSet,
+        AllocationType_FileContextSet,
+        AllocationType_Memory,
+
+        AllocationType_Count,
+    };
+
+    void *AllocateTracked(AllocationType type, size_t size);
+    void FreeTracked(AllocationType type, void *p, size_t size);
+
+    template<typename T, typename... Args>
+    T *AllocateTyped(AllocationType type, Args &&... args) {
+        void *mem = AllocateTracked(type, sizeof(T));
+        return std::construct_at(static_cast<T *>(mem), std::forward<Args>(args)...);
+    }
+
+    template<AllocationType AllocType, typename T>
+    class TrackedAllocator {
+        public:
+            using value_type = T;
+
+            template<typename U>
+            struct rebind {
+                using other = TrackedAllocator<AllocType, U>;
+            };
+        public:
+            TrackedAllocator() = default;
+
+            T *allocate(size_t n) {
+                return static_cast<T *>(AllocateTracked(AllocType, sizeof(T) * n));
+            }
+
+            void deallocate(T *p, size_t n) {
+                FreeTracked(AllocType, p, sizeof(T) * n);
+            }
+    };
+
     struct SourceInfo {
         s64 virtual_offset;
         s64 size;
@@ -89,10 +135,10 @@ namespace ams::mitm::fs::romfs {
                     delete this->metadata_source_info.file;
                     break;
                 case DataSourceType::LooseSdFile:
-                    delete[] this->loose_source_info.path;
+                    FreeTracked(AllocationType_FullPath, this->loose_source_info.path, std::strlen(this->loose_source_info.path) + 1);
                     break;
                 case DataSourceType::Memory:
-                    std::free(static_cast<void *>(this->memory_source_info.data));
+                    FreeTracked(AllocationType_Memory, this->memory_source_info.data, this->size);
                     break;
                 AMS_UNREACHABLE_DEFAULT_CASE();
             }
@@ -113,7 +159,7 @@ namespace ams::mitm::fs::romfs {
         NON_COPYABLE(BuildDirectoryContext);
         NON_MOVEABLE(BuildDirectoryContext);
 
-        std::unique_ptr<char[]> path;
+        char *path;
         union {
             BuildDirectoryContext *parent;
         };
@@ -139,16 +185,28 @@ namespace ams::mitm::fs::romfs {
         struct RootTag{};
 
         BuildDirectoryContext(RootTag) : parent(nullptr), child(nullptr), sibling(nullptr), file(nullptr), path_len(0), entry_offset(0), hash_value(0xFFFFFFFF) {
-            this->path = std::make_unique<char[]>(1);
+            this->path = static_cast<char *>(AllocateTracked(AllocationType_DirName, 1));
+            this->path[0] = '\x00';
         }
 
         BuildDirectoryContext(const char *entry_name, size_t entry_name_len) : parent(nullptr), child(nullptr), sibling(nullptr), file(nullptr), entry_offset(0) {
             this->path_len = entry_name_len;
-            this->path = std::unique_ptr<char[]>(new char[this->path_len + 1]);
-            std::memcpy(this->path.get(), entry_name, entry_name_len);
+            this->path = static_cast<char *>(AllocateTracked(AllocationType_DirName, this->path_len + 1));
+            std::memcpy(this->path, entry_name, entry_name_len);
             this->path[this->path_len] = '\x00';
         }
 
+        ~BuildDirectoryContext() {
+            if (this->path != nullptr) {
+                FreeTracked(AllocationType_DirName, this->path, this->path_len + 1);
+                this->path = nullptr;
+            }
+        }
+
+        void operator delete(void *p) {
+            FreeTracked(AllocationType_BuildDirContext, p, sizeof(BuildDirectoryContext));
+        }
+
         size_t GetPathLength() const {
             if (this->parent == nullptr) {
                 return 0;
@@ -165,7 +223,7 @@ namespace ams::mitm::fs::romfs {
 
             const size_t parent_len = this->parent->GetPath(dst);
             dst[parent_len] = '/';
-            std::memcpy(dst + parent_len + 1, this->path.get(), this->path_len);
+            std::memcpy(dst + parent_len + 1, this->path, this->path_len);
             dst[parent_len + 1 + this->path_len] = '\x00';
             return parent_len + 1 + this->path_len;
         }
@@ -187,7 +245,7 @@ namespace ams::mitm::fs::romfs {
         NON_COPYABLE(BuildFileContext);
         NON_MOVEABLE(BuildFileContext);
 
-        std::unique_ptr<char[]> path;
+        char *path;
         BuildDirectoryContext *parent;
         union {
             BuildFileContext *sibling;
@@ -203,11 +261,22 @@ namespace ams::mitm::fs::romfs {
 
         BuildFileContext(const char *entry_name, size_t entry_name_len, s64 sz, s64 o_o, DataSourceType type) : parent(nullptr), sibling(nullptr), offset(0), size(sz), orig_offset(o_o), entry_offset(0), hash_value(0xFFFFFFFF), source_type(type) {
             this->path_len = entry_name_len;
-            this->path = std::unique_ptr<char[]>(new char[this->path_len + 1]);
-            std::memcpy(this->path.get(), entry_name, entry_name_len);
+            this->path = static_cast<char *>(AllocateTracked(AllocationType_FileName, this->path_len + 1));
+            std::memcpy(this->path, entry_name, entry_name_len);
             this->path[this->path_len] = 0;
         }
 
+        ~BuildFileContext() {
+            if (this->path != nullptr) {
+                FreeTracked(AllocationType_FileName, this->path, this->path_len + 1);
+                this->path = nullptr;
+            }
+        }
+
+        void operator delete(void *p) {
+            FreeTracked(AllocationType_BuildFileContext, p, sizeof(BuildFileContext));
+        }
+
         size_t GetPathLength() const {
             if (this->parent == nullptr) {
                 return 0;
@@ -224,7 +293,7 @@ namespace ams::mitm::fs::romfs {
 
             const size_t parent_len = this->parent->GetPath(dst);
             dst[parent_len] = '/';
-            std::memcpy(dst + parent_len + 1, this->path.get(), this->path_len);
+            std::memcpy(dst + parent_len + 1, this->path, this->path_len);
             dst[parent_len + 1 + this->path_len] = '\x00';
             return parent_len + 1 + this->path_len;
         }
@@ -248,6 +317,8 @@ namespace ams::mitm::fs::romfs {
     class Builder {
         NON_COPYABLE(Builder);
         NON_MOVEABLE(Builder);
+        public:
+            using SourceInfoVector = std::vector<SourceInfo, TrackedAllocator<AllocationType_SourceInfo, SourceInfo>>;
         private:
             template<typename T>
             struct Comparator {
@@ -270,13 +341,13 @@ namespace ams::mitm::fs::romfs {
                 }
             };
 
-            template<typename T>
-            using ContextSet = std::set<std::unique_ptr<T>, Comparator<T>>;
+            template<AllocationType AllocType, typename T>
+            using ContextSet = std::set<std::unique_ptr<T>, Comparator<T>, TrackedAllocator<AllocType, std::unique_ptr<T>>>;
         private:
             ncm::ProgramId m_program_id;
             BuildDirectoryContext *m_root;
-            ContextSet<BuildDirectoryContext> m_directories;
-            ContextSet<BuildFileContext> m_files;
+            ContextSet<AllocationType_DirContextSet, BuildDirectoryContext> m_directories;
+            ContextSet<AllocationType_FileContextSet, BuildFileContext> m_files;
             size_t m_num_dirs;
             size_t m_num_files;
             size_t m_dir_table_size;
@@ -295,11 +366,14 @@ namespace ams::mitm::fs::romfs {
             void AddFile(BuildDirectoryContext *parent_ctx, std::unique_ptr<BuildFileContext> file_ctx);
         public:
             Builder(ncm::ProgramId pr_id);
+            ~Builder();
 
             void AddSdFiles();
             void AddStorageFiles(ams::fs::IStorage *storage, DataSourceType source_type);
 
-            void Build(std::vector<SourceInfo> *out_infos);
+            void Build(SourceInfoVector *out_infos);
     };
 
+    Result ConfigureDynamicHeap(u64 *out_size, ncm::ProgramId program_id, const cfg::OverrideStatus &status, bool is_application);
+
 }

stratosphere/ams_mitm/source/mitm_pm/mitm_pm_module.cpp

@@ -0,0 +1,45 @@
+/*
+ * 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 "../amsmitm_initialization.hpp"
+#include "mitm_pm_module.hpp"
+#include "mitm_pm_service.hpp"
+
+namespace ams::mitm::pm {
+
+    namespace {
+
+        constexpr sm::ServiceName PmServiceName = sm::ServiceName::Encode("mitm:pm");
+        constexpr size_t          PmMaxSessions = 1;
+
+        constexpr size_t MaxServers = 1;
+        constexpr size_t MaxSessions = PmMaxSessions;
+        using ServerOptions = sf::hipc::DefaultServerManagerOptions;
+        sf::hipc::ServerManager<MaxServers, ServerOptions, MaxSessions> g_server_manager;
+
+        constinit sf::UnmanagedServiceObject<mitm::pm::impl::IPmInterface, mitm::pm::PmService> g_pm_service_object;
+
+    }
+
+    void MitmModule::ThreadFunction(void *) {
+        /* Create bpc:ams. */
+        R_ABORT_UNLESS(g_server_manager.RegisterObjectForServer(g_pm_service_object.GetShared(), PmServiceName, PmMaxSessions));
+
+        /* Loop forever, servicing our services. */
+        g_server_manager.LoopProcess();
+    }
+
+}

stratosphere/ams_mitm/source/mitm_pm/mitm_pm_module.hpp

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <stratosphere.hpp>
+#include "../amsmitm_module.hpp"
+
+namespace ams::mitm::pm {
+
+    DEFINE_MITM_MODULE_CLASS(0x1000, AMS_GET_SYSTEM_THREAD_PRIORITY(fs, WorkerThreadPool) - 2);
+
+}

stratosphere/ams_mitm/source/mitm_pm/mitm_pm_service.cpp

@@ -0,0 +1,35 @@
+/*
+ * 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 "../amsmitm_initialization.hpp"
+#include "mitm_pm_service.hpp"
+#include "mitm_pm_service.hpp"
+#include "../fs_mitm/fsmitm_romfs.hpp"
+
+namespace ams::mitm::pm {
+
+    Result PmService::PrepareLaunchProgram(sf::Out<u64> out, ncm::ProgramId program_id, const cfg::OverrideStatus &status, bool is_application) {
+        /* Default to zero heap. */
+        *out = 0;
+
+        /* Actually configure the required boost size for romfs. */
+        R_TRY(mitm::fs::romfs::ConfigureDynamicHeap(out.GetPointer(), program_id, status, is_application));
+
+        /* TODO: Is there anything else we should do, while we have the opportunity? */
+        R_SUCCEED();
+    }
+
+}

stratosphere/ams_mitm/source/mitm_pm/mitm_pm_service.hpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <stratosphere.hpp>
+
+namespace ams::mitm::pm {
+
+    class PmService {
+        public:
+            Result PrepareLaunchProgram(sf::Out<u64> out, ncm::ProgramId program_id, const cfg::OverrideStatus &status, bool is_application);
+    };
+    static_assert(impl::IsIPmInterface<PmService>);
+
+}

stratosphere/ams_mitm/source/ns_mitm/ns_am_mitm_service.cpp

@@ -27,7 +27,7 @@ namespace ams::mitm::ns {
     Result NsAmMitmService::ResolveApplicationContentPath(ncm::ProgramId application_id, u8 content_type) {
         /* Always succeed for web applets asking about HBL to enable hbl_html, and applications with manual_html to allow custom manual data. */
         bool is_hbl = false;
-        if ((R_SUCCEEDED(pm::info::IsHblProgramId(std::addressof(is_hbl), application_id)) && is_hbl) || (static_cast<ncm::ContentType>(content_type) == ncm::ContentType::HtmlDocument && mitm::fs::HasSdManualHtmlContent(application_id))) {
+        if ((R_SUCCEEDED(ams::pm::info::IsHblProgramId(std::addressof(is_hbl), application_id)) && is_hbl) || (static_cast<ncm::ContentType>(content_type) == ncm::ContentType::HtmlDocument && mitm::fs::HasSdManualHtmlContent(application_id))) {
             nsamResolveApplicationContentPathFwd(m_forward_service.get(), static_cast<u64>(application_id), static_cast<NcmContentType>(content_type));
             R_SUCCEED();
         }

stratosphere/ams_mitm/source/ns_mitm/ns_web_mitm_service.cpp

@@ -27,7 +27,7 @@ namespace ams::mitm::ns {
     Result NsDocumentService::ResolveApplicationContentPath(ncm::ProgramId application_id, u8 content_type) {
         /* Always succeed for web applets asking about HBL to enable hbl_html, and applications with manual_html to allow custom manual data. */
         bool is_hbl = false;
-        if ((R_SUCCEEDED(pm::info::IsHblProgramId(std::addressof(is_hbl), application_id)) && is_hbl) || (static_cast<ncm::ContentType>(content_type) == ncm::ContentType::HtmlDocument && mitm::fs::HasSdManualHtmlContent(application_id))) {
+        if ((R_SUCCEEDED(ams::pm::info::IsHblProgramId(std::addressof(is_hbl), application_id)) && is_hbl) || (static_cast<ncm::ContentType>(content_type) == ncm::ContentType::HtmlDocument && mitm::fs::HasSdManualHtmlContent(application_id))) {
             nswebResolveApplicationContentPath(m_srv.get(), static_cast<u64>(application_id), static_cast<NcmContentType>(content_type));
             R_SUCCEED();
         }

stratosphere/ams_mitm/source/set_mitm/set_mitm_service.cpp

@@ -32,7 +32,7 @@ namespace ams::mitm::settings {
     SetMitmService::SetMitmService(std::shared_ptr<::Service> &&s, const sm::MitmProcessInfo &c) : sf::MitmServiceImplBase(std::forward<std::shared_ptr<::Service>>(s), c) {
         if (m_client_info.program_id == ncm::SystemProgramId::Ns) {
             os::ProcessId application_process_id;
-            if (R_SUCCEEDED(pm::dmnt::GetApplicationProcessId(std::addressof(application_process_id))) && g_application_process_id == application_process_id) {
+            if (R_SUCCEEDED(ams::pm::dmnt::GetApplicationProcessId(std::addressof(application_process_id))) && g_application_process_id == application_process_id) {
                 m_locale = g_application_locale;
                 m_is_valid_language = g_valid_language;
                 m_is_valid_region   = g_valid_region;
@@ -61,8 +61,8 @@ namespace ams::mitm::settings {
 
             if (is_ns) {
                 /* When NS asks for a locale, refresh to get the current application locale. */
-                R_TRY(pm::dmnt::GetApplicationProcessId(std::addressof(application_process_id)));
-                R_TRY(pm::info::GetProgramId(std::addressof(program_id), application_process_id));
+                R_TRY(ams::pm::dmnt::GetApplicationProcessId(std::addressof(application_process_id)));
+                R_TRY(ams::pm::info::GetProgramId(std::addressof(program_id), application_process_id));
             }
             m_locale            = cfg::GetOverrideLocale(program_id);
             m_is_valid_language = settings::IsValidLanguageCode(m_locale.language_code);

stratosphere/ams_mitm/source/set_mitm/setmitm_module.cpp

@@ -29,7 +29,7 @@ namespace ams::mitm::settings {
             PortIndex_Count,
         };
 
-        constexpr sm::ServiceName SetMitmServiceName = sm::ServiceName::Encode("set");
+        constexpr sm::ServiceName SetMitmServiceName    = sm::ServiceName::Encode("set");
         constexpr sm::ServiceName SetSysMitmServiceName = sm::ServiceName::Encode("set:sys");
 
         struct ServerOptions {

stratosphere/fatal/fatal.json

@@ -79,7 +79,7 @@
 				"svcReplyAndReceiveWithUserBuffer":	"0x44",
 				"svcCreateEvent":	"0x45",
 				"svcMapPhysicalMemoryUnsafe":	"0x48",
-				"svcUnmapPhysicalMemoryUnsafe":	"0x48",
+				"svcUnmapPhysicalMemoryUnsafe":	"0x49",
 				"svcSetUnsafeLimit":	"0x4A",
 				"svcReadWriteRegister":	"0x4E",
                 "svcDebugActiveProcess": "0x60",

stratosphere/fatal/source/fatal_task_screen.cpp

@@ -69,7 +69,7 @@ namespace ams::fatal::srv {
             /* Neither heap nor insecure is available, so we're going to have to try to raid the unsafe pool. */
             {
                 /* First, increase the limit to an extremely high value. */
-                size_t large_size = std::max(64_MB, FrameBufferRequiredSizeHeapAligned);
+                size_t large_size = std::max(128_MB, FrameBufferRequiredSizeHeapAligned);
                 while (svc::ResultLimitReached::Includes(svc::SetUnsafeLimit(large_size))) {
                     large_size *= 2;
                 }

stratosphere/pm/source/impl/pm_process_manager.cpp

@@ -244,6 +244,24 @@ namespace ams::pm::impl {
                 /* If we fail after now, unpin. */
                 ON_RESULT_FAILURE { ldr::pm::UnpinProgram(pin_id); };
 
+                /* Ensure we can talk to mitm services. */
+                {
+                    AMS_FUNCTION_LOCAL_STATIC_CONSTINIT(bool, s_initialized_mitm, false);
+                    if (!s_initialized_mitm) {
+                        mitm::pm::Initialize();
+                        s_initialized_mitm = true;
+                    }
+                }
+
+                /* Determine boost size for mitm. */
+                u64 mitm_boost_size = 0;
+                R_TRY(mitm::pm::PrepareLaunchProgram(std::addressof(mitm_boost_size), program_info.program_id, override_status, is_application));
+
+                if (mitm_boost_size > 0 || is_application) {
+                    R_ABORT_UNLESS(BoostSystemMemoryResourceLimitForMitm(mitm_boost_size));
+                }
+                ON_RESULT_FAILURE_2 { if (mitm_boost_size > 0 || is_application) { R_ABORT_UNLESS(BoostSystemMemoryResourceLimitForMitm(0)); } };
+
                 /* Ensure resources are available. */
                 resource::WaitResourceAvailable(std::addressof(program_info));
 
@@ -713,4 +731,8 @@ namespace ams::pm::impl {
         R_RETURN(resource::GetResourceLimitValues(out_cur_val, out_lim_val, static_cast<ResourceLimitGroup>(group), static_cast<svc::LimitableResource>(resource)));
     }
 
+    Result BoostSystemMemoryResourceLimitForMitm(u64 boost_size) {
+        R_RETURN(resource::BoostSystemMemoryResourceLimitForMitm(boost_size));
+    }
+
 }

stratosphere/pm/source/impl/pm_process_manager.hpp

@@ -55,5 +55,6 @@ namespace ams::pm::impl {
     Result GetAppletCurrentResourceLimitValues(pm::ResourceLimitValues *out);
     Result GetAppletPeakResourceLimitValues(pm::ResourceLimitValues *out);
     Result AtmosphereGetCurrentLimitInfo(s64 *out_cur_val, s64 *out_lim_val, u32 group, u32 resource);
+    Result BoostSystemMemoryResourceLimitForMitm(u64 boost_size);
 
 }

stratosphere/pm/source/impl/pm_resource_manager.cpp

@@ -52,9 +52,16 @@ namespace ams::pm::resource {
         constinit os::SdkMutex g_resource_limit_lock;
         constinit os::NativeHandle g_resource_limit_handles[ResourceLimitGroup_Count];
         constinit spl::MemoryArrangement g_memory_arrangement = spl::MemoryArrangement_Standard;
-        constinit u64 g_system_memory_boost_size = 0;
         constinit u64 g_extra_threads_available[ResourceLimitGroup_Count];
 
+        constinit os::SdkMutex g_system_memory_boost_lock;
+        constinit u64 g_system_memory_boost_size          = 0;
+        constinit u64 g_system_memory_boost_size_for_mitm = 0;
+
+        ALWAYS_INLINE u64 GetCurrentSystemMemoryBoostSize() {
+            return g_system_memory_boost_size + g_system_memory_boost_size_for_mitm;
+        }
+
         constinit u64 g_resource_limits[ResourceLimitGroup_Count][svc::LimitableResource_Count] = {
             [ResourceLimitGroup_System] = {
                 [svc::LimitableResource_PhysicalMemoryMax]      = 0,   /* Initialized dynamically later. */
@@ -220,6 +227,47 @@ namespace ams::pm::resource {
             R_SUCCEED();
         }
 
+        Result BoostSystemMemoryResourceLimitLocked(u64 normal_boost, u64 mitm_boost) {
+            /* Check pre-conditions. */
+            AMS_ASSERT(g_system_memory_boost_lock.IsLockedByCurrentThread());
+
+            /* Determine total boost. */
+            const u64 boost_size = normal_boost + mitm_boost;
+
+            /* Don't allow all application memory to be taken away. */
+            R_UNLESS(boost_size <= g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application], pm::ResultInvalidSize());
+
+            const u64 new_app_size = g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application] - boost_size;
+            {
+                std::scoped_lock lk(g_resource_limit_lock);
+
+                if (hos::GetVersion() >= hos::Version_5_0_0) {
+                    /* Starting in 5.0.0, PM does not allow for only one of the sets to fail. */
+                    if (boost_size < GetCurrentSystemMemoryBoostSize()) {
+                        R_TRY(svc::SetUnsafeLimit(boost_size));
+                        R_ABORT_UNLESS(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
+                    } else {
+                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
+                        R_ABORT_UNLESS(svc::SetUnsafeLimit(boost_size));
+                    }
+                } else {
+                    const u64 new_sys_size = g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_System] + boost_size;
+                    if (boost_size < GetCurrentSystemMemoryBoostSize()) {
+                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
+                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
+                    } else {
+                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
+                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
+                    }
+                }
+
+                g_system_memory_boost_size         = normal_boost;
+                g_system_memory_boost_size_for_mitm = mitm_boost;
+            }
+
+            R_SUCCEED();
+        }
+
     }
 
     /* Resource API. */
@@ -352,37 +400,19 @@ namespace ams::pm::resource {
     }
 
     Result BoostSystemMemoryResourceLimit(u64 boost_size) {
-        /* Don't allow all application memory to be taken away. */
-        R_UNLESS(boost_size <= g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application], pm::ResultInvalidSize());
+        /* Ensure only one boost change happens at a time. */
+        std::scoped_lock lk(g_system_memory_boost_lock);
 
-        const u64 new_app_size = g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application] - boost_size;
-        {
-            std::scoped_lock lk(g_resource_limit_lock);
+        /* Boost to the appropriate total amount. */
+        R_RETURN(BoostSystemMemoryResourceLimitLocked(boost_size, g_system_memory_boost_size_for_mitm));
+    }
 
-            if (hos::GetVersion() >= hos::Version_5_0_0) {
-                /* Starting in 5.0.0, PM does not allow for only one of the sets to fail. */
-                if (boost_size < g_system_memory_boost_size) {
-                    R_TRY(svc::SetUnsafeLimit(boost_size));
-                    R_ABORT_UNLESS(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
-                } else {
-                    R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
-                    R_ABORT_UNLESS(svc::SetUnsafeLimit(boost_size));
-                }
-            } else {
-                const u64 new_sys_size = g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_System] + boost_size;
-                if (boost_size < g_system_memory_boost_size) {
-                    R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
-                    R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
-                } else {
-                    R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
-                    R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
-                }
-            }
+    Result BoostSystemMemoryResourceLimitForMitm(u64 boost_size) {
+        /* Ensure only one boost change happens at a time. */
+        std::scoped_lock lk(g_system_memory_boost_lock);
 
-            g_system_memory_boost_size = boost_size;
-        }
-
-        R_SUCCEED();
+        /* Boost to the appropriate total amount. */
+        R_RETURN(BoostSystemMemoryResourceLimitLocked(g_system_memory_boost_size, boost_size));
     }
 
     Result BoostApplicationThreadResourceLimit() {

stratosphere/pm/source/impl/pm_resource_manager.hpp

@@ -24,6 +24,8 @@ namespace ams::pm::resource {
     Result BoostApplicationThreadResourceLimit();
     Result BoostSystemThreadResourceLimit();
 
+    Result BoostSystemMemoryResourceLimitForMitm(u64 boost_size);
+
     os::NativeHandle GetResourceLimitHandle(ResourceLimitGroup group);
     os::NativeHandle GetResourceLimitHandle(const ldr::ProgramInfo *info);
 

troposphere/haze/include/haze.hpp

@@ -17,6 +17,7 @@
 
 #include <haze/async_usb_server.hpp>
 #include <haze/common.hpp>
+#include <haze/device_properties.hpp>
 #include <haze/event_reactor.hpp>
 #include <haze/file_system_proxy.hpp>
 #include <haze/ptp.hpp>

troposphere/haze/include/haze/device_properties.hpp

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+namespace haze {
+
+    Result LoadDeviceProperties();
+
+    const char *GetSerialNumber();
+
+    const char *GetFirmwareVersion();
+
+}

troposphere/haze/source/device_properties.cpp

@@ -0,0 +1,50 @@
+/*
+ * 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 <haze.hpp>
+
+namespace haze {
+
+    namespace {
+
+        constinit SetSysSerialNumber g_serial_number = {};
+        constinit SetSysFirmwareVersion g_firmware_version = {};
+
+    }
+
+    Result LoadDeviceProperties() {
+        /* Initialize set:sys. */
+        R_TRY(setsysInitialize());
+
+        /* Ensure we maintain a clean state on exit. */
+        ON_SCOPE_EXIT { setsysExit(); };
+
+        /* Get the serial number and firmware version. */
+        R_TRY(setsysGetSerialNumber(std::addressof(g_serial_number)));
+        R_TRY(setsysGetFirmwareVersion(std::addressof(g_firmware_version)));
+
+        /* We succeeded. */
+        R_SUCCEED();
+    }
+
+    const char *GetSerialNumber() {
+        return g_serial_number.number;
+    }
+
+    const char *GetFirmwareVersion() {
+        return g_firmware_version.display_version;
+    }
+
+}

troposphere/haze/source/main.cpp

@@ -17,6 +17,9 @@
 #include <haze/console_main_loop.hpp>
 
 int main(int argc, char **argv) {
+    /* Load device firmware version and serial number. */
+    HAZE_R_ABORT_UNLESS(haze::LoadDeviceProperties());
+
     /* Run the application. */
     haze::ConsoleMainLoop::RunApplication();
 

troposphere/haze/source/ptp_responder.cpp

@@ -304,16 +304,6 @@ namespace haze {
     Result PtpResponder::GetDeviceInfo(PtpDataParser &dp) {
         PtpDataBuilder db(g_bulk_write_buffer, std::addressof(m_usb_server));
 
-        /* Initialize set:sys, ensuring we clean up on exit. */
-        R_TRY(setsysInitialize());
-        ON_SCOPE_EXIT { setsysExit(); };
-
-        /* Get the device version and serial number. */
-        SetSysFirmwareVersion version;
-        SetSysSerialNumber serial;
-        R_TRY(setsysGetFirmwareVersion(std::addressof(version)));
-        R_TRY(setsysGetSerialNumber(std::addressof(serial)));
-
         /* Write the device info data. */
         R_TRY(db.WriteVariableLengthData(m_request_header, [&] () {
             R_TRY(db.Add(MtpStandardVersion));
@@ -328,8 +318,8 @@ namespace haze {
             R_TRY(db.AddArray(SupportedPlaybackFormats, util::size(SupportedPlaybackFormats)));
             R_TRY(db.AddString(MtpDeviceManufacturer));
             R_TRY(db.AddString(MtpDeviceModel));
-            R_TRY(db.AddString(version.display_version));
-            R_TRY(db.AddString(serial.number));
+            R_TRY(db.AddString(GetFirmwareVersion()));
+            R_TRY(db.AddString(GetSerialNumber()));
 
             R_SUCCEED();
         }));
@@ -732,7 +722,9 @@ namespace haze {
         R_TRY(m_fs.SetFileSize(std::addressof(file), 0));
 
         /* Expand to the needed size. */
-        R_TRY(m_fs.SetFileSize(std::addressof(file), data_header.length));
+        if (data_header.length > sizeof(PtpUsbBulkContainer)) {
+            R_TRY(m_fs.SetFileSize(std::addressof(file), data_header.length - sizeof(PtpUsbBulkContainer)));
+        }
 
         /* Begin writing to the filesystem. */
         while (true) {
@@ -753,6 +745,9 @@ namespace haze {
             R_TRY(read_res);
         }
 
+        /* Truncate the file to the received size. */
+        R_TRY(m_fs.SetFileSize(std::addressof(file), offset));
+
         /* Write the success response. */
         R_RETURN(this->WriteResponse(PtpResponseCode_Ok));
     }

troposphere/haze/source/usb_session.cpp

@@ -165,19 +165,11 @@ namespace haze {
             static const u16 supported_langs[1] = { 0x0409 };
             R_TRY(usbDsAddUsbLanguageStringDescriptor(nullptr, supported_langs, util::size(supported_langs)));
 
-            /* Initialize set:sys, ensuring we clean up on exit. */
-            R_TRY(setsysInitialize());
-            ON_SCOPE_EXIT { setsysExit(); };
-
-            /* Get the device serial number. */
-            SetSysSerialNumber serial;
-            R_TRY(setsysGetSerialNumber(std::addressof(serial)));
-
             /* Report strings. */
             u8 iManufacturer, iProduct, iSerialNumber;
             R_TRY(usbDsAddUsbStringDescriptor(std::addressof(iManufacturer), "Nintendo"));
             R_TRY(usbDsAddUsbStringDescriptor(std::addressof(iProduct), "Nintendo Switch"));
-            R_TRY(usbDsAddUsbStringDescriptor(std::addressof(iSerialNumber), serial.number));
+            R_TRY(usbDsAddUsbStringDescriptor(std::addressof(iSerialNumber), GetSerialNumber()));
 
             /* Send device descriptors */
             struct usb_device_descriptor device_descriptor = {