git subrepo push libraries

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

README.md

@@ -4,6 +4,7 @@
 
 ![License](https://img.shields.io/badge/License-GPLv2-blue.svg)
 [![Chat on Discord](https://img.shields.io/badge/Discord-5865f2?logo=discord&logoColor=white)](https://discordapp.com/invite/ZdqEhed)
+![Made with Notepad++](img/np++.png?raw=true)
 
 Atmosphère is a work-in-progress customized firmware for the Nintendo Switch.
 
@@ -13,7 +14,6 @@ Components
 Atmosphère consists of multiple components, each of which replaces/modifies a different component of the system:
 
 * Fusée: First-stage Loader, responsible for loading and validating stage 2 (custom TrustZone) plus package2 (Kernel/FIRM sysmodules), and patching them as needed. This replaces all functionality normally in Package1loader/NX Bootloader.
-    * Sept: Payload used to enable support for runtime key derivation on 7.0.0.
 * Exosphère: Customized TrustZone, to run a customized Secure Monitor
 * Thermosphère: EL2 EmuNAND support, i.e. backing up and using virtualized/redirected NAND images
 * Stratosphère: Custom Sysmodule(s), both Rosalina style to extend the kernel/provide new features, and of the loader reimplementation style to hook important system actions

atmosphere.mk

@@ -50,6 +50,7 @@ dist: dist-no-debug
 	cp $(CURRENT_DIRECTORY)/stratosphere/sm/$(ATMOSPHERE_OUT_DIR)/sm.elf $(DIST_DIR)/sm.elf
 	cp $(CURRENT_DIRECTORY)/stratosphere/spl/$(ATMOSPHERE_OUT_DIR)/spl.elf $(DIST_DIR)/spl.elf
 	cp $(CURRENT_DIRECTORY)/stratosphere/TioServer/$(ATMOSPHERE_OUT_DIR)/TioServer.elf $(DIST_DIR)/TioServer.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/memlet/$(ATMOSPHERE_OUT_DIR)/memlet.elf $(DIST_DIR)/memlet.elf
 	cp $(CURRENT_DIRECTORY)/troposphere/daybreak/daybreak.elf $(DIST_DIR)/daybreak.elf
 	cp $(CURRENT_DIRECTORY)/troposphere/haze/haze.elf $(DIST_DIR)/haze.elf
 	cp $(CURRENT_DIRECTORY)/troposphere/reboot_to_payload/reboot_to_payload.elf $(DIST_DIR)/reboot_to_payload.elf
@@ -87,6 +88,7 @@ dist-no-debug: package3 $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
 	#mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000003c
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000042
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000420
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000421
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000b240
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000d609
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000d623
@@ -104,6 +106,7 @@ dist-no-debug: package3 $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
 	cp stratosphere/htc/$(ATMOSPHERE_OUT_DIR)/htc.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000b240/exefs.nsp
 	cp stratosphere/dmnt.gen2/$(ATMOSPHERE_OUT_DIR)/dmnt.gen2.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000d609/exefs.nsp
 	cp stratosphere/TioServer/$(ATMOSPHERE_OUT_DIR)/TioServer.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000d623/exefs.nsp
+	cp stratosphere/memlet/$(ATMOSPHERE_OUT_DIR)/memlet.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000421/exefs.nsp
 	@build_romfs $(DIST_DIR)/stratosphere_romfs $(DIST_DIR)/atmosphere/stratosphere.romfs
 	rm -r $(DIST_DIR)/stratosphere_romfs
 	cp troposphere/reboot_to_payload/reboot_to_payload.nro $(DIST_DIR)/switch/reboot_to_payload.nro

docs/changelog.md

@@ -1,4 +1,40 @@
 # Changelog
+## 1.9.3
++ Basic support was added for 20.3.0.
++ Compatibility was fixed for loading mods with KOTOR 2 (star wars).
++ General system stability improvements to enhance the user's experience.
+## 1.9.2
++ Basic support was added for 20.2.0.
++ USB 3.0 support force-enable was fixed for 20.1.0+.
++ General system stability improvements to enhance the user's experience.
+## 1.9.1
++ Basic support was added for 20.1.0.
++ General system stability improvements to enhance the user's experience.
+## 1.9.0
++ Basic support was added for 20.0.0.
+  + The console should boot and atmosphère should be fully functional. However, not all modules have been fully updated to reflect the latest changes.
+    + There shouldn't be anything user visible resulting from this, but it will be addressed in a future atmosphère update.
+    + The same action item from 18.0.0 remains, and I believe in my heart of hearts that it will be addressed eventually. Someone has told me they're working on it.
+    + There aren't (to my knowledge) outstanding 19.0.0 items any more.
+  + **Please note**: As a result of changes made to nintendo's software in 20.0.0, there is roughly 10MB less memory available for custom system modules.
+    + We can only steal a maximum of 14MB from the applet pool, down from 40MB.
+    + To compensate for this, `ams.mitm`'s heap usage has been reduced by 20MB.
+      + To facilitate this, a new helper module (`memlet`) was added, so that memory may be temporarily stolen during the romfs building process.
+      + Hopefully, this results in relatively little breakage, however it is possible that user mods which replace extremely large numbers of files in The Legend of Zelda: Tears of the Kingdom may no longer function.
+        + If you are affected by this, you will see "Data abort (0x101)" when trying to launch the game with mods.
+        + Please reach out to `sciresm` on discord if this occurs to share your error report binary. However, some issues may be impossible to fix.
+        + I apologize sincerely if the issue is impossible to resolve, but I have been forced unavoidably to make compromises here, and I think this is the best balance to be struck.
+  + `exosphère` was updated to reflect the latest official secure monitor behavior.
+  + `mesosphère` was updated to reflect the latest official kernel behavior.
+  + `loader` was updated to reflect the latest official behavior.
+  + `pm` was updated to reflect the latest official behavior.
+  + `ncm` was partially updated to reflect the latest official behavior.
+  + `erpt` was updated to reflect the latest official behavior.
++ Atmosphère was updated to use GCC 15/newlib (latest devkitA64/devkitARM releases).
++ A number of improvements were made to the dmnt cheat engine.
+  + New instructions were added, and instructions were updated for improved/new functionality.
+  + Please see the documents for details -- thanks @tomvita!
++ General system stability improvements to enhance the user's experience.
 ## 1.8.0
 + Basic support was added for 19.0.0.
   + The console should boot and atmosphère should be fully functional. However, not all modules have been fully updated to reflect the latest changes.

docs/features/cheats.md

@@ -423,41 +423,41 @@ Note that for multiple button combinations, the bitmasks should be OR'd together
 #### Keypad Values
 Note: This is the direct output of `hidKeysDown()`.
 
-+ 000000001: A
-+ 000000002: B
-+ 000000004: X
-+ 000000008: Y
-+ 000000010: Left Stick Pressed
-+ 000000020: Right Stick Pressed
-+ 000000040: L
-+ 000000080: R
-+ 000000100: ZL
-+ 000000200: ZR
-+ 000000400: Plus
-+ 000000800: Minus
-+ 000001000: Left
-+ 000002000: Up
-+ 000004000: Right
-+ 000008000: Down
-+ 000010000: Left Stick Left
-+ 000020000: Left Stick Up
-+ 000040000: Left Stick Right
-+ 000080000: Left Stick Down
-+ 000100000: Right Stick Left
-+ 000200000: Right Stick Up
-+ 000400000: Right Stick Right
-+ 000800000: Right Stick Down
-+ 001000000: SL Left Joy-Con
-+ 002000000: SR Left Joy-Con
-+ 004000000: SL Right Joy-Con
-+ 008000000: SR Right Joy-Con
-+ 010000000: Top button on Poké Ball Plus (Palma) controller
-+ 020000000: Verification
-+ 040000000: B button on Left NES/HVC controller in Handheld mode
-+ 080000000: Left C button in N64 controller
-+ 100000000: Up C button in N64 controller
-+ 200000000: Right C button in N64 controller
-+ 400000000: Down C button in N64 controller
++ 00000000 00000001: A
++ 00000000 00000002: B
++ 00000000 00000004: X
++ 00000000 00000008: Y
++ 00000000 00000010: Left Stick Pressed
++ 00000000 00000020: Right Stick Pressed
++ 00000000 00000040: L
++ 00000000 00000080: R
++ 00000000 00000100: ZL
++ 00000000 00000200: ZR
++ 00000000 00000400: Plus
++ 00000000 00000800: Minus
++ 00000000 00001000: Left
++ 00000000 00002000: Up
++ 00000000 00004000: Right
++ 00000000 00008000: Down
++ 00000000 00010000: Left Stick Left
++ 00000000 00020000: Left Stick Up
++ 00000000 00040000: Left Stick Right
++ 00000000 00080000: Left Stick Down
++ 00000000 00100000: Right Stick Left
++ 00000000 00200000: Right Stick Up
++ 00000000 00400000: Right Stick Right
++ 00000000 00800000: Right Stick Down
++ 00000000 01000000: SL Left Joy-Con
++ 00000000 02000000: SR Left Joy-Con
++ 00000000 04000000: SL Right Joy-Con
++ 00000000 08000000: SR Right Joy-Con
++ 00000000 10000000: Top button on Poké Ball Plus (Palma) controller
++ 00000000 20000000: Verification
++ 00000000 40000000: B button on Left NES/HVC controller in Handheld mode
++ 00000000 80000000: Left C button in N64 controller
++ 00000001 00000000: Up C button in N64 controller
++ 00000002 00000000: Right C button in N64 controller
++ 00000004 00000000: Down C button in N64 controller
 
 ### Code Type 0xF0: Double Extended-Width Instruction
 Code Type 0xF0 signals to the VM to treat the upper three nybbles of the first dword as instruction type, instead of just the upper nybble.

emummc/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/m4xw/emummc
 	branch = develop
-	commit = d248ea6f700c3e6987549e30a1e2eeb609ce9f8c
-	parent = 9112461620330ba73a74926edd4c08b3cc0310f0
+	commit = a8e5f1a184aeb8ba884166a1e4f386088d4a6cf1
+	parent = 409c3cf9e190dbb65fe76570954939cbe8a5eca0
 	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 - 19.0.0**
+**1.0.0 - 20.1.0**
 
 ## Features
 * Arbitrary SDMMC backend selection  

emummc/source/FS/FS_offsets.c

@@ -75,6 +75,10 @@
 #include "offsets/1810_exfat.h"
 #include "offsets/1900.h"
 #include "offsets/1900_exfat.h"
+#include "offsets/2000.h"
+#include "offsets/2000_exfat.h"
+#include "offsets/2010.h"
+#include "offsets/2010_exfat.h"
 #include "../utils/fatal.h"
 
 #define GET_OFFSET_STRUCT_NAME(vers) g_offsets##vers
@@ -161,6 +165,10 @@ DEFINE_OFFSET_STRUCT(_1810);
 DEFINE_OFFSET_STRUCT(_1810_EXFAT);
 DEFINE_OFFSET_STRUCT(_1900);
 DEFINE_OFFSET_STRUCT(_1900_EXFAT);
+DEFINE_OFFSET_STRUCT(_2000);
+DEFINE_OFFSET_STRUCT(_2000_EXFAT);
+DEFINE_OFFSET_STRUCT(_2010);
+DEFINE_OFFSET_STRUCT(_2010_EXFAT);
 
 const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
     switch (version) {
@@ -282,6 +290,14 @@ const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
             return &(GET_OFFSET_STRUCT_NAME(_1900));
         case FS_VER_19_0_0_EXFAT:
             return &(GET_OFFSET_STRUCT_NAME(_1900_EXFAT));
+        case FS_VER_20_0_0:
+            return &(GET_OFFSET_STRUCT_NAME(_2000));
+        case FS_VER_20_0_0_EXFAT:
+            return &(GET_OFFSET_STRUCT_NAME(_2000_EXFAT));
+        case FS_VER_20_1_0:
+            return &(GET_OFFSET_STRUCT_NAME(_2010));
+        case FS_VER_20_1_0_EXFAT:
+            return &(GET_OFFSET_STRUCT_NAME(_2010_EXFAT));
         default:
             fatal_abort(Fatal_UnknownVersion);
     }

emummc/source/FS/FS_versions.h

@@ -110,6 +110,12 @@ enum FS_VER
     FS_VER_19_0_0,
     FS_VER_19_0_0_EXFAT,
 
+    FS_VER_20_0_0,
+    FS_VER_20_0_0_EXFAT,
+
+    FS_VER_20_1_0,
+    FS_VER_20_1_0_EXFAT,
+
     FS_VER_MAX,
 };
 

emummc/source/FS/offsets/2000.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_2000_H__
+#define __FS_2000_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_2000_SDMMC_ACCESSOR_GC   0x1A7DB0
+#define FS_OFFSET_2000_SDMMC_ACCESSOR_SD   0x1AA130
+#define FS_OFFSET_2000_SDMMC_ACCESSOR_NAND 0x1A8560
+
+// Hooks
+#define FS_OFFSET_2000_SDMMC_WRAPPER_READ  0x1A3C20
+#define FS_OFFSET_2000_SDMMC_WRAPPER_WRITE 0x1A3C80
+#define FS_OFFSET_2000_RTLD                0x2B594
+#define FS_OFFSET_2000_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
+
+#define FS_OFFSET_2000_CLKRST_SET_MIN_V_CLK_RATE 0x1C6150
+
+// Misc funcs
+#define FS_OFFSET_2000_LOCK_MUTEX          0x19CD80
+#define FS_OFFSET_2000_UNLOCK_MUTEX        0x19CDD0
+
+#define FS_OFFSET_2000_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1A3BE0
+#define FS_OFFSET_2000_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1A3C00
+
+// Misc Data
+#define FS_OFFSET_2000_SD_MUTEX            0xFF5408
+#define FS_OFFSET_2000_NAND_MUTEX          0xFF0CF0
+#define FS_OFFSET_2000_ACTIVE_PARTITION    0xFF0D30
+#define FS_OFFSET_2000_SDMMC_DAS_HANDLE    0xFD2B08
+
+// NOPs
+#define FS_OFFSET_2000_SD_DAS_INIT         0x289F4
+
+// Nintendo Paths
+#define FS_OFFSET_2000_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x0006DB14, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x0007CE1C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x00084A08, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0009AE48, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_2000_H__

emummc/source/FS/offsets/2000_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_2000_EXFAT_H__
+#define __FS_2000_EXFAT_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_2000_EXFAT_SDMMC_ACCESSOR_GC   0x1B36D0
+#define FS_OFFSET_2000_EXFAT_SDMMC_ACCESSOR_SD   0x1B5A50
+#define FS_OFFSET_2000_EXFAT_SDMMC_ACCESSOR_NAND 0x1B3E80
+
+// Hooks
+#define FS_OFFSET_2000_EXFAT_SDMMC_WRAPPER_READ  0x1AF540
+#define FS_OFFSET_2000_EXFAT_SDMMC_WRAPPER_WRITE 0x1AF5A0
+#define FS_OFFSET_2000_EXFAT_RTLD                0x2B594
+#define FS_OFFSET_2000_EXFAT_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
+
+#define FS_OFFSET_2000_EXFAT_CLKRST_SET_MIN_V_CLK_RATE 0x1D1A70
+
+// Misc funcs
+#define FS_OFFSET_2000_EXFAT_LOCK_MUTEX          0x1A86A0
+#define FS_OFFSET_2000_EXFAT_UNLOCK_MUTEX        0x1A86F0
+
+#define FS_OFFSET_2000_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1AF500
+#define FS_OFFSET_2000_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1AF520
+
+// Misc Data
+#define FS_OFFSET_2000_EXFAT_SD_MUTEX            0x1006408
+#define FS_OFFSET_2000_EXFAT_NAND_MUTEX          0x1001CF0
+#define FS_OFFSET_2000_EXFAT_ACTIVE_PARTITION    0x1001D30
+#define FS_OFFSET_2000_EXFAT_SDMMC_DAS_HANDLE    0xFDFB08
+
+// NOPs
+#define FS_OFFSET_2000_EXFAT_SD_DAS_INIT         0x289F4
+
+// Nintendo Paths
+#define FS_OFFSET_2000_EXFAT_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x0006DB14, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x0007CE1C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x00084A08, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0009AE48, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_2000_EXFAT_H__

emummc/source/FS/offsets/2010.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_2010_H__
+#define __FS_2010_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_2010_SDMMC_ACCESSOR_GC   0x1A7DB0
+#define FS_OFFSET_2010_SDMMC_ACCESSOR_SD   0x1AA130
+#define FS_OFFSET_2010_SDMMC_ACCESSOR_NAND 0x1A8560
+
+// Hooks
+#define FS_OFFSET_2010_SDMMC_WRAPPER_READ  0x1A3C20
+#define FS_OFFSET_2010_SDMMC_WRAPPER_WRITE 0x1A3C80
+#define FS_OFFSET_2010_RTLD                0x2B594
+#define FS_OFFSET_2010_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
+
+#define FS_OFFSET_2010_CLKRST_SET_MIN_V_CLK_RATE 0x1C6150
+
+// Misc funcs
+#define FS_OFFSET_2010_LOCK_MUTEX          0x19CD80
+#define FS_OFFSET_2010_UNLOCK_MUTEX        0x19CDD0
+
+#define FS_OFFSET_2010_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1A3BE0
+#define FS_OFFSET_2010_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1A3C00
+
+// Misc Data
+#define FS_OFFSET_2010_SD_MUTEX            0xFF5408
+#define FS_OFFSET_2010_NAND_MUTEX          0xFF0CF0
+#define FS_OFFSET_2010_ACTIVE_PARTITION    0xFF0D30
+#define FS_OFFSET_2010_SDMMC_DAS_HANDLE    0xFD2B08
+
+// NOPs
+#define FS_OFFSET_2010_SD_DAS_INIT         0x289F4
+
+// Nintendo Paths
+#define FS_OFFSET_2010_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x0006DB14, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x0007CE1C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x00084A08, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0009AE48, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_2010_H__

emummc/source/FS/offsets/2010_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_2010_EXFAT_H__
+#define __FS_2010_EXFAT_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_2010_EXFAT_SDMMC_ACCESSOR_GC   0x1B36D0
+#define FS_OFFSET_2010_EXFAT_SDMMC_ACCESSOR_SD   0x1B5A50
+#define FS_OFFSET_2010_EXFAT_SDMMC_ACCESSOR_NAND 0x1B3E80
+
+// Hooks
+#define FS_OFFSET_2010_EXFAT_SDMMC_WRAPPER_READ  0x1AF540
+#define FS_OFFSET_2010_EXFAT_SDMMC_WRAPPER_WRITE 0x1AF5A0
+#define FS_OFFSET_2010_EXFAT_RTLD                0x2B594
+#define FS_OFFSET_2010_EXFAT_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
+
+#define FS_OFFSET_2010_EXFAT_CLKRST_SET_MIN_V_CLK_RATE 0x1D1A70
+
+// Misc funcs
+#define FS_OFFSET_2010_EXFAT_LOCK_MUTEX          0x1A86A0
+#define FS_OFFSET_2010_EXFAT_UNLOCK_MUTEX        0x1A86F0
+
+#define FS_OFFSET_2010_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1AF500
+#define FS_OFFSET_2010_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1AF520
+
+// Misc Data
+#define FS_OFFSET_2010_EXFAT_SD_MUTEX            0x1006408
+#define FS_OFFSET_2010_EXFAT_NAND_MUTEX          0x1001CF0
+#define FS_OFFSET_2010_EXFAT_ACTIVE_PARTITION    0x1001D30
+#define FS_OFFSET_2010_EXFAT_SDMMC_DAS_HANDLE    0xFDFB08
+
+// NOPs
+#define FS_OFFSET_2010_EXFAT_SD_DAS_INIT         0x289F4
+
+// Nintendo Paths
+#define FS_OFFSET_2010_EXFAT_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x0006DB14, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x0007CE1C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x00084A08, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0009AE48, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_2010_EXFAT_H__

exosphere/program/source/boot/secmon_boot_key_data.s

@@ -85,10 +85,10 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 /* We can get away with only including latest because exosphere supports newer-than-expected master key in engine. */
 /* TODO: Update on next change of keys. */
 /* Mariko Development Master Kek Source. */
-.byte 0x65, 0x7B, 0x11, 0x46, 0x0E, 0xC2, 0x22, 0x5D, 0xB9, 0xF1, 0xF5, 0x00, 0xF9, 0x3E, 0x1F, 0x70
+.byte 0x8C, 0x2E, 0xC1, 0x1C, 0xA0, 0x28, 0x35, 0xFC, 0x9A, 0x9F, 0x1D, 0x9B, 0x4E, 0xDF, 0x1E, 0x03
 
 /* Mariko Production Master Kek Source. */
-.byte 0x31, 0xBE, 0x25, 0xFB, 0xDB, 0xB4, 0xEE, 0x49, 0x5C, 0x77, 0x05, 0xC2, 0x36, 0x9F, 0x34, 0x80
+.byte 0x1A, 0x31, 0x62, 0x87, 0xA8, 0x09, 0xCA, 0xF8, 0x69, 0x15, 0x45, 0xC2, 0x6B, 0xAA, 0x5A, 0x8A
 
 /* Development Master Key Vectors. */
 .byte 0x46, 0x22, 0xB4, 0x51, 0x9A, 0x7E, 0xA7, 0x7F, 0x62, 0xA1, 0x1F, 0x8F, 0xC5, 0x3A, 0xDB, 0xFE /* Zeroes encrypted with Master Key 00. */
@@ -110,6 +110,7 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0x39, 0x1E, 0x7E, 0xF8, 0x7E, 0x73, 0xEA, 0x6F, 0xAF, 0x00, 0x3A, 0xB4, 0xAA, 0xB8, 0xB7, 0x59 /* Master key 0F encrypted with Master key 10. */
 .byte 0x0C, 0x75, 0x39, 0x15, 0x53, 0xEA, 0x81, 0x11, 0xA3, 0xE0, 0xDC, 0x3D, 0x0E, 0x76, 0xC6, 0xB8 /* Master key 10 encrypted with Master key 11. */
 .byte 0x90, 0x64, 0xF9, 0x08, 0x29, 0x88, 0xD4, 0xDC, 0x73, 0xA4, 0xA1, 0x13, 0x9E, 0x59, 0x85, 0xA0 /* Master key 11 encrypted with Master key 12. */
+.byte 0x94, 0x46, 0x3B, 0xFA, 0x7D, 0xB9, 0xE2, 0x94, 0xC2, 0x9D, 0xB9, 0xA4, 0xB2, 0x56, 0xCA, 0xFE /* Master key 12 encrypted with Master key 13. */
 
 /* Production Master Key Vectors. */
 .byte 0x0C, 0xF0, 0x59, 0xAC, 0x85, 0xF6, 0x26, 0x65, 0xE1, 0xE9, 0x19, 0x55, 0xE6, 0xF2, 0x67, 0x3D /* Zeroes encrypted with Master Key 00. */
@@ -131,6 +132,7 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0x25, 0x12, 0x8B, 0xCB, 0xB5, 0x46, 0xA1, 0xF8, 0xE0, 0x52, 0x15, 0xB7, 0x0B, 0x57, 0x00, 0xBD /* Master key 0F encrypted with Master key 10. */
 .byte 0x58, 0x15, 0xD2, 0xF6, 0x8A, 0xE8, 0x19, 0xAB, 0xFB, 0x2D, 0x52, 0x9D, 0xE7, 0x55, 0xF3, 0x93 /* Master key 10 encrypted with Master key 11. */
 .byte 0x4A, 0x01, 0x3B, 0xC7, 0x44, 0x6E, 0x45, 0xBD, 0xE6, 0x5E, 0x2B, 0xEC, 0x07, 0x37, 0x52, 0x86 /* Master key 11 encrypted with Master key 12. */
+.byte 0x97, 0xE4, 0x11, 0xAB, 0x22, 0x72, 0x1A, 0x1F, 0x70, 0x5C, 0x00, 0xB3, 0x96, 0x30, 0x05, 0x28 /* Master key 12 encrypted with Master key 13. */
 
 /* Device Master Key Source Sources. */
 .byte 0x8B, 0x4E, 0x1C, 0x22, 0x42, 0x07, 0xC8, 0x73, 0x56, 0x94, 0x08, 0x8B, 0xCC, 0x47, 0x0F, 0x5D /* 4.0.0  Device Master Key Source Source. */
@@ -149,6 +151,7 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0xDA, 0xB9, 0xD6, 0x77, 0x52, 0x2D, 0x1F, 0x78, 0x73, 0xC9, 0x98, 0x5B, 0x06, 0xFE, 0xA0, 0x52 /* 17.0.0 Device Master Key Source Source. */
 .byte 0x14, 0xF5, 0xA5, 0xD0, 0x73, 0x6D, 0x44, 0x80, 0x5F, 0x31, 0x5A, 0x8F, 0x1E, 0xD4, 0x0D, 0x63 /* 18.0.0 Device Master Key Source Source. */
 .byte 0x07, 0x38, 0x9A, 0xEC, 0x9C, 0xBD, 0x50, 0x4A, 0x4C, 0x1F, 0x04, 0xDA, 0x40, 0x68, 0x29, 0xE3 /* 19.0.0 Device Master Key Source Source. */
+.byte 0xA3, 0x6B, 0x0A, 0xB5, 0x6F, 0x57, 0x4C, 0x5E, 0x00, 0xFD, 0x56, 0x21, 0xF5, 0x06, 0x6B, 0xD1 /* 20.0.0 Device Master Key Source Source. */
 
 /* Development Device Master Kek Sources. */
 .byte 0xD6, 0xBD, 0x9F, 0xC6, 0x18, 0x09, 0xE1, 0x96, 0x20, 0x39, 0x60, 0xD2, 0x89, 0x83, 0x31, 0x34 /* 4.0.0  Device Master Kek Source. */
@@ -167,6 +170,7 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0x4E, 0xCE, 0x7B, 0x2A, 0xEA, 0x2E, 0x3D, 0x16, 0xD5, 0x2A, 0xDE, 0xF6, 0xF8, 0x6A, 0x7D, 0x43 /* 17.0.0 Device Master Kek Source. */
 .byte 0x3B, 0x00, 0x89, 0xD7, 0xA9, 0x9E, 0xB7, 0x70, 0x86, 0x00, 0xC3, 0x49, 0x52, 0x8C, 0xA4, 0xAF /* 18.0.0 Device Master Kek Source. */
 .byte 0xAE, 0x78, 0x36, 0xB6, 0x91, 0xEB, 0xAF, 0x9C, 0x18, 0xF1, 0xC0, 0xD5, 0x8A, 0x0C, 0x7C, 0xA1 /* 19.0.0 Device Master Kek Source. */
+.byte 0x09, 0x12, 0x4F, 0x26, 0x90, 0xB9, 0xA6, 0xF5, 0xA5, 0x18, 0x74, 0xB6, 0x8D, 0x80, 0x59, 0x3D /* 20.0.0 Device Master Kek Source. */
 
 /* Production Device Master Kek Sources. */
 .byte 0x88, 0x62, 0x34, 0x6E, 0xFA, 0xF7, 0xD8, 0x3F, 0xE1, 0x30, 0x39, 0x50, 0xF0, 0xB7, 0x5D, 0x5D /* 4.0.0  Device Master Kek Source. */
@@ -185,3 +189,4 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0x21, 0xD6, 0x35, 0xF1, 0x0F, 0x7A, 0xF0, 0x5D, 0xDF, 0x79, 0x1C, 0x7A, 0xE4, 0x32, 0x82, 0x9E /* 17.0.0 Device Master Kek Source. */
 .byte 0xE7, 0x85, 0x8C, 0xA2, 0xF4, 0x49, 0xCB, 0x07, 0xD1, 0x8E, 0x48, 0x1B, 0xE8, 0x1E, 0x28, 0x3B /* 18.0.0 Device Master Kek Source. */
 .byte 0x9B, 0xA5, 0xFD, 0x74, 0x7F, 0xCD, 0x23, 0xD1, 0xD9, 0xBD, 0x6C, 0x51, 0x72, 0x5F, 0x3D, 0x1F /* 19.0.0 Device Master Kek Source. */
+.byte 0xDA, 0xFB, 0x61, 0x39, 0x48, 0x2D, 0xC2, 0x7E, 0x0D, 0x8E, 0x8F, 0x98, 0x57, 0x20, 0xB8, 0x15 /* 20.0.0 Device Master Kek Source. */

exosphere/program/source/boot/secmon_package2.cpp

@@ -94,7 +94,7 @@ namespace ams::secmon::boot {
         }
 
         /* Check that the key generation is one that we can use. */
-        static_assert(pkg1::KeyGeneration_Count == 19);
+        static_assert(pkg1::KeyGeneration_Count == 20);
         if (key_generation >= pkg1::KeyGeneration_Count) {
             return false;
         }

fusee/program/source/fusee_key_derivation.cpp

@@ -23,17 +23,17 @@ namespace ams::nxboot {
 
         alignas(se::AesBlockSize) constexpr inline const u8 MarikoMasterKekSource[se::AesBlockSize] = {
             /* TODO: Update on next change of keys. */
-            0x31, 0xBE, 0x25, 0xFB, 0xDB, 0xB4, 0xEE, 0x49, 0x5C, 0x77, 0x05, 0xC2, 0x36, 0x9F, 0x34, 0x80
+            0x1A, 0x31, 0x62, 0x87, 0xA8, 0x09, 0xCA, 0xF8, 0x69, 0x15, 0x45, 0xC2, 0x6B, 0xAA, 0x5A, 0x8A
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 MarikoMasterKekSourceDev[se::AesBlockSize] = {
             /* TODO: Update on next change of keys. */
-            0x65, 0x7B, 0x11, 0x46, 0x0E, 0xC2, 0x22, 0x5D, 0xB9, 0xF1, 0xF5, 0x00, 0xF9, 0x3E, 0x1F, 0x70
+            0x8C, 0x2E, 0xC1, 0x1C, 0xA0, 0x28, 0x35, 0xFC, 0x9A, 0x9F, 0x1D, 0x9B, 0x4E, 0xDF, 0x1E, 0x03
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 EristaMasterKekSource[se::AesBlockSize] = {
             /* TODO: Update on next change of keys. */
-            0xD7, 0x63, 0x74, 0x46, 0x4E, 0xBA, 0x78, 0x0A, 0x7C, 0x9D, 0xB3, 0xE8, 0x7A, 0x3D, 0x71, 0xE3
+            0xA1, 0x7D, 0x34, 0xDB, 0x2D, 0x9D, 0xDA, 0xE5, 0xF8, 0x15, 0x63, 0x4C, 0x8F, 0xE7, 0x6C, 0xD8
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 KeyblobKeySource[se::AesBlockSize] = {
@@ -73,6 +73,7 @@ namespace ams::nxboot {
             { 0xDA, 0xB9, 0xD6, 0x77, 0x52, 0x2D, 0x1F, 0x78, 0x73, 0xC9, 0x98, 0x5B, 0x06, 0xFE, 0xA0, 0x52 }, /* 17.0.0 Device Master Key Source Source. */
             { 0x14, 0xF5, 0xA5, 0xD0, 0x73, 0x6D, 0x44, 0x80, 0x5F, 0x31, 0x5A, 0x8F, 0x1E, 0xD4, 0x0D, 0x63 }, /* 18.0.0 Device Master Key Source Source. */
             { 0x07, 0x38, 0x9A, 0xEC, 0x9C, 0xBD, 0x50, 0x4A, 0x4C, 0x1F, 0x04, 0xDA, 0x40, 0x68, 0x29, 0xE3 }, /* 19.0.0 Device Master Key Source Source. */
+            { 0xA3, 0x6B, 0x0A, 0xB5, 0x6F, 0x57, 0x4C, 0x5E, 0x00, 0xFD, 0x56, 0x21, 0xF5, 0x06, 0x6B, 0xD1 }, /* 20.0.0 Device Master Key Source Source. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 DeviceMasterKekSources[pkg1::OldDeviceMasterKeyCount][se::AesBlockSize] = {
@@ -92,6 +93,7 @@ namespace ams::nxboot {
             { 0x21, 0xD6, 0x35, 0xF1, 0x0F, 0x7A, 0xF0, 0x5D, 0xDF, 0x79, 0x1C, 0x7A, 0xE4, 0x32, 0x82, 0x9E }, /* 17.0.0 Device Master Kek Source. */
             { 0xE7, 0x85, 0x8C, 0xA2, 0xF4, 0x49, 0xCB, 0x07, 0xD1, 0x8E, 0x48, 0x1B, 0xE8, 0x1E, 0x28, 0x3B }, /* 18.0.0 Device Master Kek Source. */
             { 0x9B, 0xA5, 0xFD, 0x74, 0x7F, 0xCD, 0x23, 0xD1, 0xD9, 0xBD, 0x6C, 0x51, 0x72, 0x5F, 0x3D, 0x1F }, /* 19.0.0 Device Master Kek Source. */
+            { 0xDA, 0xFB, 0x61, 0x39, 0x48, 0x2D, 0xC2, 0x7E, 0x0D, 0x8E, 0x8F, 0x98, 0x57, 0x20, 0xB8, 0x15 }, /* 20.0.0 Device Master Kek Source. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 DeviceMasterKekSourcesDev[pkg1::OldDeviceMasterKeyCount][se::AesBlockSize] = {
@@ -111,6 +113,7 @@ namespace ams::nxboot {
             { 0x4E, 0xCE, 0x7B, 0x2A, 0xEA, 0x2E, 0x3D, 0x16, 0xD5, 0x2A, 0xDE, 0xF6, 0xF8, 0x6A, 0x7D, 0x43 }, /* 17.0.0 Device Master Kek Source. */
             { 0x3B, 0x00, 0x89, 0xD7, 0xA9, 0x9E, 0xB7, 0x70, 0x86, 0x00, 0xC3, 0x49, 0x52, 0x8C, 0xA4, 0xAF }, /* 18.0.0 Device Master Kek Source. */
             { 0xAE, 0x78, 0x36, 0xB6, 0x91, 0xEB, 0xAF, 0x9C, 0x18, 0xF1, 0xC0, 0xD5, 0x8A, 0x0C, 0x7C, 0xA1 }, /* 19.0.0 Device Master Kek Source. */
+            { 0x09, 0x12, 0x4F, 0x26, 0x90, 0xB9, 0xA6, 0xF5, 0xA5, 0x18, 0x74, 0xB6, 0x8D, 0x80, 0x59, 0x3D }, /* 20.0.0 Device Master Kek Source. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 MasterKeySources[pkg1::KeyGeneration_Count][se::AesBlockSize] = {
@@ -133,6 +136,7 @@ namespace ams::nxboot {
             { 0x25, 0x12, 0x8B, 0xCB, 0xB5, 0x46, 0xA1, 0xF8, 0xE0, 0x52, 0x15, 0xB7, 0x0B, 0x57, 0x00, 0xBD }, /* Master key 0F encrypted with Master key 10. */
             { 0x58, 0x15, 0xD2, 0xF6, 0x8A, 0xE8, 0x19, 0xAB, 0xFB, 0x2D, 0x52, 0x9D, 0xE7, 0x55, 0xF3, 0x93 }, /* Master key 10 encrypted with Master key 11. */
             { 0x4A, 0x01, 0x3B, 0xC7, 0x44, 0x6E, 0x45, 0xBD, 0xE6, 0x5E, 0x2B, 0xEC, 0x07, 0x37, 0x52, 0x86 }, /* Master key 11 encrypted with Master key 12. */
+            { 0x97, 0xE4, 0x11, 0xAB, 0x22, 0x72, 0x1A, 0x1F, 0x70, 0x5C, 0x00, 0xB3, 0x96, 0x30, 0x05, 0x28 }, /* Master key 12 encrypted with Master key 13. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 MasterKeySourcesDev[pkg1::KeyGeneration_Count][se::AesBlockSize] = {
@@ -155,6 +159,7 @@ namespace ams::nxboot {
             { 0x39, 0x1E, 0x7E, 0xF8, 0x7E, 0x73, 0xEA, 0x6F, 0xAF, 0x00, 0x3A, 0xB4, 0xAA, 0xB8, 0xB7, 0x59 }, /* Master key 0F encrypted with Master key 10. */
             { 0x0C, 0x75, 0x39, 0x15, 0x53, 0xEA, 0x81, 0x11, 0xA3, 0xE0, 0xDC, 0x3D, 0x0E, 0x76, 0xC6, 0xB8 }, /* Master key 10 encrypted with Master key 11. */
             { 0x90, 0x64, 0xF9, 0x08, 0x29, 0x88, 0xD4, 0xDC, 0x73, 0xA4, 0xA1, 0x13, 0x9E, 0x59, 0x85, 0xA0 }, /* Master key 11 encrypted with Master key 12. */
+            { 0x94, 0x46, 0x3B, 0xFA, 0x7D, 0xB9, 0xE2, 0x94, 0xC2, 0x9D, 0xB9, 0xA4, 0xB2, 0x56, 0xCA, 0xFE }, /* Master key 12 encrypted with Master key 13. */
         };
 
         alignas(se::AesBlockSize) constinit u8 MasterKeys[pkg1::OldMasterKeyCount][se::AesBlockSize] = {};

fusee/program/source/fusee_package2.cpp

@@ -80,7 +80,7 @@ namespace ams::nxboot {
             }
 
             /* Check that the key generation is one that we can use. */
-            static_assert(pkg1::KeyGeneration_Count == 19);
+            static_assert(pkg1::KeyGeneration_Count == 20);
             if (key_generation >= pkg1::KeyGeneration_Count) {
                 return false;
             }

fusee/program/source/fusee_setup_horizon.cpp

@@ -263,6 +263,8 @@ namespace ams::nxboot {
                         return ams::TargetFirmware_18_0_0;
                     } else if (std::memcmp(package1 + 0x10, "20240808", 8) == 0) {
                         return ams::TargetFirmware_19_0_0;
+                    } else if (std::memcmp(package1 + 0x10, "20250206", 8) == 0) {
+                        return ams::TargetFirmware_20_0_0;
                     }
                     break;
                 default:

fusee/program/source/fusee_stratosphere.cpp

@@ -180,6 +180,12 @@ namespace ams::nxboot {
             FsVersion_19_0_0,
             FsVersion_19_0_0_Exfat,
 
+            FsVersion_20_0_0,
+            FsVersion_20_0_0_Exfat,
+
+            FsVersion_20_1_0,
+            FsVersion_20_1_0_Exfat,
+
             FsVersion_Count,
         };
 
@@ -272,6 +278,12 @@ namespace ams::nxboot {
 
             { 0xD9, 0x4C, 0x68, 0x15, 0xF8, 0xF5, 0x0A, 0x20 }, /* FsVersion_19_0_0 */
             { 0xED, 0xA8, 0x78, 0x68, 0xA4, 0x49, 0x07, 0x50 }, /* FsVersion_19_0_0_Exfat */
+
+            { 0x63, 0x54, 0x96, 0x9E, 0x60, 0xA7, 0x97, 0x7B }, /* FsVersion_20_0_0 */
+            { 0x47, 0x41, 0x07, 0x10, 0x65, 0x4F, 0xA4, 0x3F }, /* FsVersion_20_0_0_Exfat */
+
+            { 0xED, 0x34, 0xB4, 0x50, 0x58, 0x4A, 0x5B, 0x43 }, /* FsVersion_20_1_0 */
+            { 0xA5, 0x1A, 0xA4, 0x92, 0x6C, 0x41, 0x87, 0x59 }, /* FsVersion_20_1_0_Exfat */
         };
 
         const InitialProcessBinaryHeader *FindInitialProcessBinary(const pkg2::Package2Header *header, const u8 *data, ams::TargetFirmware target_firmware) {
@@ -661,6 +673,18 @@ namespace ams::nxboot {
                     AddPatch(fs_meta, 0x1A16A5, NogcPatch0, sizeof(NogcPatch0));
                     AddPatch(fs_meta, 0x17A9A0, NogcPatch1, sizeof(NogcPatch1));
                     break;
+                case FsVersion_20_0_0:
+                case FsVersion_20_1_0:
+                    AddPatch(fs_meta, 0x1A7E25, NogcPatch0, sizeof(NogcPatch0));
+                    AddPatch(fs_meta, 0x1A8025, NogcPatch0, sizeof(NogcPatch0));
+                    AddPatch(fs_meta, 0x17C250, NogcPatch1, sizeof(NogcPatch1));
+                    break;
+                case FsVersion_20_0_0_Exfat:
+                case FsVersion_20_1_0_Exfat:
+                    AddPatch(fs_meta, 0x1B3745, NogcPatch0, sizeof(NogcPatch0));
+                    AddPatch(fs_meta, 0x1B3945, NogcPatch0, sizeof(NogcPatch0));
+                    AddPatch(fs_meta, 0x187B70, NogcPatch1, sizeof(NogcPatch1));
+                    break;
                 default:
                     break;
             }

libraries/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/Atmosphere-NX/Atmosphere-libs
 	branch = master
-	commit = 989fb7be0c68bf229fe6789428b6c448b6de142a
-	parent = be19749841e581de4cc5d38f39f4de5fa4046c52
+	commit = bc7a0fc11a57b62a27227e8cffd65cc8ed459c5b
+	parent = debfff9f620c7fad0da633ee92d8e2a678f19de6
 	method = merge
 	cmdver = 0.4.1

libraries/libexosphere/include/exosphere/pkg1/pkg1_key_generation.hpp

@@ -39,6 +39,7 @@ namespace ams::pkg1 {
         KeyGeneration_17_0_0 = 0x10,
         KeyGeneration_18_0_0 = 0x11,
         KeyGeneration_19_0_0 = 0x12,
+        KeyGeneration_20_0_0 = 0x13,
 
         KeyGeneration_Count,
 

libraries/libexosphere/include/exosphere/pkg2.hpp

@@ -24,7 +24,7 @@ namespace ams::pkg2 {
     constexpr inline int PayloadCount = 3;
 
     constexpr inline int MinimumValidDataVersion  = 0;   /* We allow older package2 to load; this value is currently 0x18 in Nintendo's code. */
-    constexpr inline int CurrentBootloaderVersion = 0x16;
+    constexpr inline int CurrentBootloaderVersion = 0x17;
 
     struct Package2Meta {
         using Magic = util::FourCC<'P','K','2','1'>;

libraries/libexosphere/source/fuse/fuse_api.cpp

@@ -177,6 +177,7 @@ namespace ams::fuse {
         }
 
         constexpr const TargetFirmware FuseVersionIncrementFirmwares[] = {
+            TargetFirmware_20_0_0,
             TargetFirmware_19_0_0,
             TargetFirmware_17_0_0,
             TargetFirmware_16_0_0,

libraries/libmesosphere/include/mesosphere/arch/arm/kern_generic_interrupt_controller.hpp

@@ -116,7 +116,9 @@ namespace ams::kern::arch::arm {
                 u32 ipriorityr[NumLocalInterrupts / 4];
                 u32 itargetsr[NumLocalInterrupts / 4];
                 u32 icfgr[NumLocalInterrupts / 16];
+                u32 spendsgir[4];
             };
+            static_assert(sizeof(LocalState{}.spendsgir) == sizeof(GicDistributor{}.spendsgir));
 
             struct GlobalState {
                 u32 isenabler[NumGlobalInterrupts / 32];

libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_page_table.hpp

@@ -200,6 +200,11 @@ namespace ams::kern::arch::arm64 {
             NOINLINE Result InitializeForKernel(void *table, KVirtualAddress start, KVirtualAddress end);
             NOINLINE Result InitializeForProcess(ams::svc::CreateProcessFlag flags, bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit, size_t process_index);
             Result Finalize();
+
+            static void NoteUpdatedCallback(const void *pt) {
+                /* Note the update. */
+                static_cast<const KPageTable *>(pt)->NoteUpdated();
+            }
         private:
             Result Unmap(KProcessAddress virt_addr, size_t num_pages, PageLinkedList *page_list, bool force, bool reuse_ll);
 

libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_page_table_impl.hpp

@@ -49,6 +49,8 @@ namespace ams::kern::arch::arm64 {
                 EntryLevel level;
                 bool is_contiguous;
             };
+
+            using EntryUpdatedCallback = void (*)(const void *);
         private:
             static constexpr size_t PageBits  = util::CountTrailingZeros(PageSize);
             static constexpr size_t NumLevels = 3;
@@ -144,8 +146,8 @@ namespace ams::kern::arch::arm64 {
 
             bool GetPhysicalAddress(KPhysicalAddress *out, KProcessAddress virt_addr) const;
 
-            static bool MergePages(KVirtualAddress *out, TraversalContext *context);
-            void SeparatePages(TraversalEntry *entry, TraversalContext *context, KProcessAddress address, PageTableEntry *pte) const;
+            static bool MergePages(KVirtualAddress *out, TraversalContext *context, EntryUpdatedCallback on_entry_updated, const void *pt);
+            void SeparatePages(TraversalEntry *entry, TraversalContext *context, KProcessAddress address, PageTableEntry *pte, EntryUpdatedCallback on_entry_updated, const void *pt) const;
 
             KProcessAddress GetAddressForContext(const TraversalContext *context) const {
                 KProcessAddress addr = m_is_kernel ? static_cast<uintptr_t>(-GetBlockSize(EntryLevel_L1)) * m_num_entries : 0;

libraries/libmesosphere/include/mesosphere/arch/arm64/kern_userspace_memory_access.hpp

@@ -22,49 +22,139 @@ namespace ams::kern::arch::arm64 {
 
     class UserspaceAccess {
         private:
-            static bool CopyMemoryFromUserSize32BitWithSupervisorAccessImpl(void *dst, const void *src);
+            class Impl {
+                public:
+                    static bool CopyMemoryFromUser(void *dst, const void *src, size_t size);
+                    static bool CopyMemoryFromUserAligned32Bit(void *dst, const void *src, size_t size);
+                    static bool CopyMemoryFromUserAligned64Bit(void *dst, const void *src, size_t size);
+                    static bool CopyMemoryFromUserSize64Bit(void *dst, const void *src);
+                    static bool CopyMemoryFromUserSize32Bit(void *dst, const void *src);
+                    static bool CopyMemoryFromUserSize32BitWithSupervisorAccess(void *dst, const void *src);
+                    static s32  CopyStringFromUser(void *dst, const void *src, size_t size);
+
+                    static bool CopyMemoryToUser(void *dst, const void *src, size_t size);
+                    static bool CopyMemoryToUserAligned32Bit(void *dst, const void *src, size_t size);
+                    static bool CopyMemoryToUserAligned64Bit(void *dst, const void *src, size_t size);
+                    static bool CopyMemoryToUserSize32Bit(void *dst, const void *src);
+                    static s32  CopyStringToUser(void *dst, const void *src, size_t size);
+
+                    static bool UpdateLockAtomic(u32 *out, u32 *address, u32 if_zero, u32 new_orr_mask);
+                    static bool UpdateIfEqualAtomic(s32 *out, s32 *address, s32 compare_value, s32 new_value);
+                    static bool DecrementIfLessThanAtomic(s32 *out, s32 *address, s32 compare);
+
+                    static bool StoreDataCache(uintptr_t start, uintptr_t end);
+                    static bool FlushDataCache(uintptr_t start, uintptr_t end);
+                    static bool InvalidateDataCache(uintptr_t start, uintptr_t end);
+
+                    static bool ReadIoMemory32Bit(void *dst, const void *src, size_t size);
+                    static bool ReadIoMemory16Bit(void *dst, const void *src, size_t size);
+                    static bool ReadIoMemory8Bit(void *dst, const void *src, size_t size);
+                    static bool WriteIoMemory32Bit(void *dst, const void *src, size_t size);
+                    static bool WriteIoMemory16Bit(void *dst, const void *src, size_t size);
+                    static bool WriteIoMemory8Bit(void *dst, const void *src, size_t size);
+            };
         public:
+            static bool CopyMemoryFromUser(void *dst, const void *src, size_t size) {
+                return Impl::CopyMemoryFromUser(dst, src, size);
+            }
+
+            static bool CopyMemoryFromUserAligned32Bit(void *dst, const void *src, size_t size) {
+                return Impl::CopyMemoryFromUserAligned32Bit(dst, src, size);
+            }
+
+            static bool CopyMemoryFromUserAligned64Bit(void *dst, const void *src, size_t size) {
+                return Impl::CopyMemoryFromUserAligned64Bit(dst, src, size);
+            }
+
+            static bool CopyMemoryFromUserSize64Bit(void *dst, const void *src) {
+                return Impl::CopyMemoryFromUserSize64Bit(dst, src);
+            }
+
+            static bool CopyMemoryFromUserSize32Bit(void *dst, const void *src) {
+                return Impl::CopyMemoryFromUserSize32Bit(dst, src);
+            }
+
+
             static bool CopyMemoryFromUserSize32BitWithSupervisorAccess(void *dst, const void *src) {
                 /* Check that the address is within the valid userspace range. */
                 if (const uintptr_t src_uptr = reinterpret_cast<uintptr_t>(src); src_uptr < ams::svc::AddressNullGuard32Size || (src_uptr + sizeof(u32) - 1) >= ams::svc::AddressMemoryRegion39Size) {
                     return false;
                 }
 
-                return CopyMemoryFromUserSize32BitWithSupervisorAccessImpl(dst, src);
+                return Impl::CopyMemoryFromUserSize32BitWithSupervisorAccess(dst, src);
             }
 
-            static bool CopyMemoryFromUser(void *dst, const void *src, size_t size);
-            static bool CopyMemoryFromUserAligned32Bit(void *dst, const void *src, size_t size);
-            static bool CopyMemoryFromUserAligned64Bit(void *dst, const void *src, size_t size);
-            static bool CopyMemoryFromUserSize64Bit(void *dst, const void *src);
-            static bool CopyMemoryFromUserSize32Bit(void *dst, const void *src);
-            static s32  CopyStringFromUser(void *dst, const void *src, size_t size);
+            static s32  CopyStringFromUser(void *dst, const void *src, size_t size) {
+                return Impl::CopyStringFromUser(dst, src, size);
+            }
 
-            static bool CopyMemoryToUser(void *dst, const void *src, size_t size);
-            static bool CopyMemoryToUserAligned32Bit(void *dst, const void *src, size_t size);
-            static bool CopyMemoryToUserAligned64Bit(void *dst, const void *src, size_t size);
-            static bool CopyMemoryToUserSize32Bit(void *dst, const void *src);
-            static s32  CopyStringToUser(void *dst, const void *src, size_t size);
+            static bool CopyMemoryToUser(void *dst, const void *src, size_t size) {
+                return Impl::CopyMemoryToUser(dst, src, size);
+            }
 
-            static bool ClearMemory(void *dst, size_t size);
-            static bool ClearMemoryAligned32Bit(void *dst, size_t size);
-            static bool ClearMemoryAligned64Bit(void *dst, size_t size);
-            static bool ClearMemorySize32Bit(void *dst);
+            static bool CopyMemoryToUserAligned32Bit(void *dst, const void *src, size_t size) {
+                return Impl::CopyMemoryToUserAligned32Bit(dst, src, size);
+            }
 
-            static bool UpdateLockAtomic(u32 *out, u32 *address, u32 if_zero, u32 new_orr_mask);
-            static bool UpdateIfEqualAtomic(s32 *out, s32 *address, s32 compare_value, s32 new_value);
-            static bool DecrementIfLessThanAtomic(s32 *out, s32 *address, s32 compare);
+            static bool CopyMemoryToUserAligned64Bit(void *dst, const void *src, size_t size) {
+                return Impl::CopyMemoryToUserAligned64Bit(dst, src, size);
+            }
 
-            static bool StoreDataCache(uintptr_t start, uintptr_t end);
-            static bool FlushDataCache(uintptr_t start, uintptr_t end);
-            static bool InvalidateDataCache(uintptr_t start, uintptr_t end);
+            static bool CopyMemoryToUserSize32Bit(void *dst, const void *src) {
+                return Impl::CopyMemoryToUserSize32Bit(dst, src);
+            }
 
-            static bool ReadIoMemory32Bit(void *dst, const void *src, size_t size);
-            static bool ReadIoMemory16Bit(void *dst, const void *src, size_t size);
-            static bool ReadIoMemory8Bit(void *dst, const void *src, size_t size);
-            static bool WriteIoMemory32Bit(void *dst, const void *src, size_t size);
-            static bool WriteIoMemory16Bit(void *dst, const void *src, size_t size);
-            static bool WriteIoMemory8Bit(void *dst, const void *src, size_t size);
+            static s32  CopyStringToUser(void *dst, const void *src, size_t size) {
+                return Impl::CopyStringToUser(dst, src, size);
+            }
+
+            static bool UpdateLockAtomic(u32 *out, u32 *address, u32 if_zero, u32 new_orr_mask) {
+                return Impl::UpdateLockAtomic(out, address, if_zero, new_orr_mask);
+            }
+
+            static bool UpdateIfEqualAtomic(s32 *out, s32 *address, s32 compare_value, s32 new_value) {
+                return Impl::UpdateIfEqualAtomic(out, address, compare_value, new_value);
+            }
+
+            static bool DecrementIfLessThanAtomic(s32 *out, s32 *address, s32 compare) {
+                return Impl::DecrementIfLessThanAtomic(out, address, compare);
+            }
+
+            static bool StoreDataCache(uintptr_t start, uintptr_t end) {
+                return Impl::StoreDataCache(start, end);
+            }
+
+            static bool FlushDataCache(uintptr_t start, uintptr_t end) {
+                return Impl::FlushDataCache(start, end);
+            }
+
+            static bool InvalidateDataCache(uintptr_t start, uintptr_t end) {
+                return Impl::InvalidateDataCache(start, end);
+            }
+
+            static bool ReadIoMemory32Bit(void *dst, const void *src, size_t size) {
+                return Impl::ReadIoMemory32Bit(dst, src, size);
+            }
+
+            static bool ReadIoMemory16Bit(void *dst, const void *src, size_t size) {
+                return Impl::ReadIoMemory16Bit(dst, src, size);
+            }
+
+            static bool ReadIoMemory8Bit(void *dst, const void *src, size_t size) {
+                return Impl::ReadIoMemory8Bit(dst, src, size);
+            }
+
+            static bool WriteIoMemory32Bit(void *dst, const void *src, size_t size) {
+                return Impl::WriteIoMemory32Bit(dst, src, size);
+            }
+
+            static bool WriteIoMemory16Bit(void *dst, const void *src, size_t size) {
+                return Impl::WriteIoMemory16Bit(dst, src, size);
+            }
+
+            static bool WriteIoMemory8Bit(void *dst, const void *src, size_t size) {
+                return Impl::WriteIoMemory8Bit(dst, src, size);
+            }
     };
 
 

libraries/libmesosphere/include/mesosphere/kern_k_address_space_info.hpp

@@ -37,7 +37,7 @@ namespace ams::kern {
             size_t m_size;
             Type m_type;
         public:
-            static uintptr_t GetAddressSpaceStart(ams::svc::CreateProcessFlag flags, Type type);
+            static uintptr_t GetAddressSpaceStart(ams::svc::CreateProcessFlag flags, Type type, size_t code_size);
             static size_t GetAddressSpaceSize(ams::svc::CreateProcessFlag flags, Type type);
 
             static void SetAddressSpaceSize(size_t width, Type type, size_t size);

libraries/libmesosphere/include/mesosphere/kern_k_memory_block_manager.hpp

@@ -99,6 +99,7 @@ namespace ams::kern {
             Result Initialize(KProcessAddress st, KProcessAddress nd, KMemoryBlockSlabManager *slab_manager);
             void   Finalize(KMemoryBlockSlabManager *slab_manager);
 
+            static bool GetRegionForFindFreeArea(KProcessAddress *out_start, KProcessAddress *out_end, KProcessAddress region_start, size_t region_num_pages, size_t num_pages, size_t alignment, size_t offset, size_t guard_pages);
             KProcessAddress FindFreeArea(KProcessAddress region_start, size_t region_num_pages, size_t num_pages, size_t alignment, size_t offset, size_t guard_pages) const;
 
             void Update(KMemoryBlockManagerUpdateAllocator *allocator, KProcessAddress address, size_t num_pages, KMemoryState state, KMemoryPermission perm, KMemoryAttribute attr, KMemoryBlockDisableMergeAttribute set_disable_attr, KMemoryBlockDisableMergeAttribute clear_disable_attr);

libraries/libmesosphere/include/mesosphere/kern_k_system_control_base.hpp

@@ -41,7 +41,7 @@ namespace ams::kern {
             /* Nintendo uses std::mt19937_t for randomness. */
             /* To save space (and because mt19337_t isn't secure anyway), */
             /* We will use TinyMT. */
-            static constinit inline bool         s_initialized_random_generator;
+            static constinit inline bool         s_uninitialized_random_generator{true};
             static constinit inline util::TinyMT s_random_generator{util::ConstantInitialize};
             static constinit inline KSpinLock    s_random_lock;
         public:

libraries/libmesosphere/include/mesosphere/kern_k_system_resource.hpp

@@ -94,7 +94,11 @@ namespace ams::kern {
             static void PostDestroy(uintptr_t arg) { MESOSPHERE_UNUSED(arg); /* ... */ }
 
             ALWAYS_INLINE size_t CalculateRequiredSecureMemorySize() const {
-                return CalculateRequiredSecureMemorySize(m_resource_size, m_resource_pool);
+                if (m_resource_limit != nullptr) {
+                    return CalculateRequiredSecureMemorySize(m_resource_size, m_resource_pool);
+                } else {
+                    return 0;
+                }
             }
 
             ALWAYS_INLINE size_t GetSize() const { return m_resource_size; }

libraries/libmesosphere/include/mesosphere/kern_k_target_system.hpp

@@ -25,35 +25,35 @@ namespace ams::kern {
             friend class KSystemControl;
         private:
             struct KTargetSystemData {
-                bool is_debug_mode;
-                bool enable_debug_logging;
-                bool enable_user_exception_handlers;
-                bool enable_debug_memory_fill;
-                bool enable_user_pmu_access;
-                bool enable_kernel_debugging;
-                bool enable_dynamic_resource_limits;
+                bool is_not_debug_mode;
+                bool disable_debug_logging;
+                bool disable_user_exception_handlers;
+                bool disable_debug_memory_fill;
+                bool disable_user_pmu_access;
+                bool disable_kernel_debugging;
+                bool disable_dynamic_resource_limits;
             };
         private:
-            static inline constinit bool s_is_initialized = false;
+            static inline constinit bool s_is_uninitialized = true;
             static inline constinit const volatile KTargetSystemData s_data = {
-                .is_debug_mode                  = true,
-                .enable_debug_logging           = true,
-                .enable_user_exception_handlers = true,
-                .enable_debug_memory_fill       = true,
-                .enable_user_pmu_access         = true,
-                .enable_kernel_debugging        = true,
-                .enable_dynamic_resource_limits = false,
+                .is_not_debug_mode               = false,
+                .disable_debug_logging           = false,
+                .disable_user_exception_handlers = false,
+                .disable_debug_memory_fill       = false,
+                .disable_user_pmu_access         = false,
+                .disable_kernel_debugging        = false,
+                .disable_dynamic_resource_limits = true,
             };
         private:
-            static ALWAYS_INLINE void SetInitialized() { s_is_initialized = true; }
+            static ALWAYS_INLINE void SetInitialized() { s_is_uninitialized = false; }
         public:
-            static ALWAYS_INLINE bool IsDebugMode() { return s_is_initialized && s_data.is_debug_mode; }
-            static ALWAYS_INLINE bool IsDebugLoggingEnabled() { return s_is_initialized && s_data.enable_debug_logging; }
-            static ALWAYS_INLINE bool IsUserExceptionHandlersEnabled() { return s_is_initialized && s_data.enable_user_exception_handlers; }
-            static ALWAYS_INLINE bool IsDebugMemoryFillEnabled() { return s_is_initialized && s_data.enable_debug_memory_fill; }
-            static ALWAYS_INLINE bool IsUserPmuAccessEnabled() { return s_is_initialized && s_data.enable_user_pmu_access; }
-            static ALWAYS_INLINE bool IsKernelDebuggingEnabled() { return s_is_initialized && s_data.enable_kernel_debugging; }
-            static ALWAYS_INLINE bool IsDynamicResourceLimitsEnabled() { return s_is_initialized && s_data.enable_dynamic_resource_limits; }
+            static ALWAYS_INLINE bool IsDebugMode() { return !(s_is_uninitialized | s_data.is_not_debug_mode); }
+            static ALWAYS_INLINE bool IsDebugLoggingEnabled() { return !(s_is_uninitialized | s_data.disable_debug_logging); }
+            static ALWAYS_INLINE bool IsUserExceptionHandlersEnabled() { return !(s_is_uninitialized | s_data.disable_user_exception_handlers); }
+            static ALWAYS_INLINE bool IsDebugMemoryFillEnabled() { return !(s_is_uninitialized | s_data.disable_debug_memory_fill); }
+            static ALWAYS_INLINE bool IsUserPmuAccessEnabled() { return !(s_is_uninitialized | s_data.disable_user_pmu_access); }
+            static ALWAYS_INLINE bool IsKernelDebuggingEnabled() { return !(s_is_uninitialized | s_data.disable_kernel_debugging); }
+            static ALWAYS_INLINE bool IsDynamicResourceLimitsEnabled() { return !(s_is_uninitialized | s_data.disable_dynamic_resource_limits); }
     };
 
 }

libraries/libmesosphere/source/arch/arm/kern_generic_interrupt_controller.inc

@@ -113,6 +113,11 @@ namespace ams::kern::arch::arm {
             constexpr size_t Offset = 0;
             state->icfgr[i] = m_gicd->icfgr[i + Offset];
         }
+
+        /* Save spendsgir. */
+        for (size_t i = 0; i < util::size(state->spendsgir); ++i) {
+            state->spendsgir[i] = m_gicd->spendsgir[i];
+        }
     }
 
     void KInterruptController::SaveGlobal(GlobalState *state) const {
@@ -168,6 +173,11 @@ namespace ams::kern::arch::arm {
             m_gicd->icenabler[i + Offset] = 0xFFFFFFFF;
             m_gicd->isenabler[i + Offset] = state->isenabler[i];
         }
+
+        /* Restore spendsgir. */
+        for (size_t i = 0; i < util::size(state->spendsgir); ++i) {
+            m_gicd->spendsgir[i] = state->spendsgir[i];
+        }
     }
 
     void KInterruptController::RestoreGlobal(const GlobalState *state) const {

libraries/libmesosphere/source/arch/arm64/kern_cpu.cpp

@@ -112,7 +112,7 @@ namespace ams::kern::arch::arm64::cpu {
         class KCoreBarrierInterruptHandler : public KInterruptHandler {
             private:
                 util::Atomic<u64> m_target_cores;
-                KSpinLock m_lock;
+                KLightLock m_lock;
             public:
                 constexpr KCoreBarrierInterruptHandler() : KInterruptHandler(), m_target_cores(0), m_lock() { /* ... */ }
 
@@ -123,11 +123,8 @@ namespace ams::kern::arch::arm64::cpu {
                 }
 
                 void SynchronizeCores(u64 core_mask) {
-                    /* Disable dispatch while we synchronize. */
-                    KScopedDisableDispatch dd;
-
                     /* Acquire exclusive access to ourselves. */
-                    KScopedSpinLock lk(m_lock);
+                    KScopedLightLock lk(m_lock);
 
                     /* If necessary, force synchronization with other cores. */
                     if (const u64 other_cores_mask = core_mask & ~(1ul << GetCurrentCoreId()); other_cores_mask != 0) {

libraries/libmesosphere/source/arch/arm64/kern_exception_handlers.cpp

@@ -109,12 +109,31 @@ namespace ams::kern::arch::arm64 {
             return insn;
         }
 
-        void HandleUserException(KExceptionContext *context, u64 esr, u64 far, u64 afsr0, u64 afsr1, u32 data) {
+        void HandleUserException(KExceptionContext *context, u64 raw_esr, u64 raw_far, u64 afsr0, u64 afsr1, u32 data) {
+            /* Pre-process exception registers as needed. */
+            u64 esr = raw_esr;
+            u64 far = raw_far;
+            const u64 ec = (esr >> 26) & 0x3F;
+            if (ec == EsrEc_InstructionAbortEl0 || ec == EsrEc_DataAbortEl0) {
+                /* Adjust registers if a synchronous external abort has occurred with far not valid. */
+                /*     Mask 0x03F = Low 6 bits IFSC == 0x10: "Synchronous External abort,            */
+                /*     not on translation table walk or hardware update of translation table.        */
+                /*     Mask 0x400 = FnV = "FAR Not Valid"                                            */
+                /* TODO: How would we perform this check using named register accesses? */
+                if ((esr & 0x43F) == 0x410) {
+                    /* Clear the faulting register on memory tagging exception. */
+                    far = 0;
+                } else {
+                    /* If the faulting address is a kernel address, set ISFC = 4. */
+                    if (far >= ams::svc::AddressMemoryRegion39Size) {
+                        esr = (esr & 0xFFFFFFC0) | 4;
+                    }
+                }
+            }
+
             KProcess &cur_process = GetCurrentProcess();
             bool should_process_user_exception = KTargetSystem::IsUserExceptionHandlersEnabled();
 
-            const u64 ec = (esr >> 26) & 0x3F;
-
             /* In the event that we return from this exception, we want SPSR.SS set so that we advance an instruction if single-stepping. */
             #if defined(MESOSPHERE_ENABLE_HARDWARE_SINGLE_STEP)
             context->psr |= (1ul << 21);
@@ -165,7 +184,7 @@ namespace ams::kern::arch::arm64 {
                     }
 
                     /* Save the debug parameters to the current thread. */
-                    GetCurrentThread().SaveDebugParams(far, esr, data);
+                    GetCurrentThread().SaveDebugParams(raw_far, raw_esr, data);
 
                     /* Get the exception type. */
                     u32 type;
@@ -387,7 +406,6 @@ namespace ams::kern::arch::arm64 {
             ams::svc::aarch32::ExceptionInfo info32;
         } info = {};
 
-
         const bool is_aarch64 = (e_ctx->psr & 0x10) == 0;
         if (is_aarch64) {
             /* We're 64-bit. */
@@ -432,9 +450,28 @@ namespace ams::kern::arch::arm64 {
                 uintptr_t far, esr, data;
                 GetCurrentThread().RestoreDebugParams(std::addressof(far), std::addressof(esr), std::addressof(data));
 
+                /* Pre-process exception registers as needed. */
+                const u64 ec = (esr >> 26) & 0x3F;
+                if (ec == EsrEc_InstructionAbortEl0 || ec == EsrEc_DataAbortEl0) {
+                    /* Adjust registers if a synchronous external abort has occurred with far not valid. */
+                    /*     Mask 0x03F = Low 6 bits IFSC == 0x10: "Synchronous External abort,            */
+                    /*     not on translation table walk or hardware update of translation table.        */
+                    /*     Mask 0x400 = FnV = "FAR Not Valid"                                            */
+                    /* TODO: How would we perform this check using named register accesses? */
+                    if ((esr & 0x43F) == 0x410) {
+                        /* Clear the faulting register on memory tagging exception. */
+                        far = 0;
+                    } else {
+                        /* If the faulting address is a kernel address, set ISFC = 4. */
+                        if (far >= ams::svc::AddressMemoryRegion39Size) {
+                            esr = (esr & 0xFFFFFFC0) | 4;
+                        }
+                    }
+                }
+
                 /* Collect additional information based on the ec. */
                 uintptr_t params[3] = {};
-                switch ((esr >> 26) & 0x3F) {
+                switch (ec) {
                      case EsrEc_Unknown:
                      case EsrEc_IllegalExecution:
                      case EsrEc_BkptInstruction:

libraries/libmesosphere/source/arch/arm64/kern_k_page_table.cpp

@@ -752,13 +752,10 @@ namespace ams::kern::arch::arm64 {
         while (true) {
             /* Try to merge. */
             KVirtualAddress freed_table = Null<KVirtualAddress>;
-            if (!impl.MergePages(std::addressof(freed_table), context)) {
+            if (!impl.MergePages(std::addressof(freed_table), context, &KPageTable::NoteUpdatedCallback, this)) {
                 break;
             }
 
-            /* Note that we updated. */
-            this->NoteUpdated();
-
             /* Free the page. */
             if (freed_table != Null<KVirtualAddress>) {
                 ClearPageTable(freed_table);
@@ -816,8 +813,7 @@ namespace ams::kern::arch::arm64 {
             }
 
             /* Separate. */
-            impl.SeparatePages(entry, context, virt_addr, GetPointer<PageTableEntry>(table));
-            this->NoteUpdated();
+            impl.SeparatePages(entry, context, virt_addr, GetPointer<PageTableEntry>(table), &KPageTable::NoteUpdatedCallback, this);
         }
 
         R_SUCCEED();
@@ -1025,6 +1021,9 @@ namespace ams::kern::arch::arm64 {
 
             /* Finally, apply the changes as directed, flushing the mappings before they're applied (if we should). */
             ApplyEntryTemplate(entry_template, flush_mapping ? ApplyOption_FlushDataCache : ApplyOption_None);
+
+            /* Wait for pending stores to complete. */
+            cpu::DataSynchronizationBarrierInnerShareableStore();
         }
 
         /* We've succeeded, now perform what coalescing we can. */

libraries/libmesosphere/source/arch/arm64/kern_k_page_table_impl.cpp

@@ -219,7 +219,7 @@ namespace ams::kern::arch::arm64 {
         return is_block;
     }
 
-    bool KPageTableImpl::MergePages(KVirtualAddress *out, TraversalContext *context) {
+    bool KPageTableImpl::MergePages(KVirtualAddress *out, TraversalContext *context, EntryUpdatedCallback on_entry_updated, const void *pt) {
         /* We want to upgrade the pages by one step. */
         if (context->is_contiguous) {
             /* We can't merge an L1 table. */
@@ -251,6 +251,7 @@ namespace ams::kern::arch::arm64 {
             const auto sw_reserved_bits = PageTableEntry::EncodeSoftwareReservedBits(head_pte->IsHeadMergeDisabled(), head_pte->IsHeadAndBodyMergeDisabled(), tail_pte->IsTailMergeDisabled());
 
             *context->level_entries[context->level + 1] = PageTableEntry(PageTableEntry::BlockTag{}, phys_addr, PageTableEntry(entry_template), sw_reserved_bits, false, false);
+            on_entry_updated(pt);
 
             /* Update our context. */
             context->is_contiguous = false;
@@ -285,6 +286,7 @@ namespace ams::kern::arch::arm64 {
             for (size_t i = 0; i < BlocksPerContiguousBlock; ++i) {
                 pte[i] = PageTableEntry(PageTableEntry::BlockTag{}, phys_addr + (i << (PageBits + LevelBits * context->level)), PageTableEntry(entry_template), sw_reserved_bits, true, context->level == EntryLevel_L3);
             }
+            on_entry_updated(pt);
 
             /* Update our context. */
             context->level_entries[context->level] = pte;
@@ -294,7 +296,7 @@ namespace ams::kern::arch::arm64 {
         return true;
     }
 
-    void KPageTableImpl::SeparatePages(TraversalEntry *entry, TraversalContext *context, KProcessAddress address, PageTableEntry *pte) const {
+    void KPageTableImpl::SeparatePages(TraversalEntry *entry, TraversalContext *context, KProcessAddress address, PageTableEntry *pte, EntryUpdatedCallback on_entry_updated, const void *pt) const {
         /* We want to downgrade the pages by one step. */
         if (context->is_contiguous) {
             /* We want to downgrade a contiguous mapping to a non-contiguous mapping. */
@@ -305,6 +307,7 @@ namespace ams::kern::arch::arm64 {
             for (size_t i = 0; i < BlocksPerContiguousBlock; ++i) {
                 pte[i] = PageTableEntry(PageTableEntry::BlockTag{}, block + (i << (PageBits + LevelBits * context->level)), PageTableEntry(first->GetEntryTemplateForSeparateContiguous(i)), PageTableEntry::SeparateContiguousTag{});
             }
+            on_entry_updated(pt);
 
             context->is_contiguous = false;
 
@@ -325,12 +328,12 @@ namespace ams::kern::arch::arm64 {
 
             /* Update the block entry to be a table entry. */
             *context->level_entries[context->level + 1] = PageTableEntry(PageTableEntry::TableTag{}, KPageTable::GetPageTablePhysicalAddress(KVirtualAddress(pte)), m_is_kernel, true, BlocksPerTable);
-
+            on_entry_updated(pt);
 
             context->level_entries[context->level] = pte + this->GetLevelIndex(address, context->level);
         }
 
-        entry->sw_reserved_bits = 0;
+        entry->sw_reserved_bits = context->level_entries[context->level]->GetSoftwareReservedBits();
         entry->attr             = 0;
         entry->phys_addr        = this->GetBlock(context->level_entries[context->level], context->level) + this->GetOffset(address, context->level);
         entry->block_size       = static_cast<size_t>(1) << (PageBits + LevelBits * context->level + 4 * context->is_contiguous);

libraries/libmesosphere/source/arch/arm64/kern_userspace_memory_access_asm.s

@@ -24,12 +24,12 @@ _ZN3ams4kern4arch5arm6432UserspaceAccessFunctionAreaBeginEv:
 
 /*  ================ All Userspace Access Functions after this line. ================ */
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryFromUser(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess18CopyMemoryFromUserEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess18CopyMemoryFromUserEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess18CopyMemoryFromUserEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryFromUser(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18CopyMemoryFromUserEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18CopyMemoryFromUserEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18CopyMemoryFromUserEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess18CopyMemoryFromUserEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18CopyMemoryFromUserEPvPKvm:
     /* Check if there's anything to copy. */
     cmp     x2, #0
     b.eq    2f
@@ -48,12 +48,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess18CopyMemoryFromUserEPvPKvm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryFromUserAligned32Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned32BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned32BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned32BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryFromUserAligned32Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned32BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned32BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned32BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned32BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned32BitEPvPKvm:
     /* Check if there are 0x40 bytes to copy */
     cmp     x2, #0x3F
     b.ls    1f
@@ -72,7 +72,7 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned32BitEPvPKvm:
     add     x0, x0, #0x40
     add     x1, x1, #0x40
     sub     x2, x2, #0x40
-    b       _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned32BitEPvPKvm
+    b       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned32BitEPvPKvm
 
 1:  /* We have less than 0x40 bytes to copy. */
     cmp     x2, #0
@@ -87,12 +87,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned32BitEPvPKvm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryFromUserAligned64Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned64BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned64BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned64BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryFromUserAligned64Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned64BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned64BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned64BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned64BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned64BitEPvPKvm:
     /* Check if there are 0x40 bytes to copy */
     cmp     x2, #0x3F
     b.ls    1f
@@ -111,7 +111,7 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned64BitEPvPKvm:
     add     x0, x0, #0x40
     add     x1, x1, #0x40
     sub     x2, x2, #0x40
-    b       _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned64BitEPvPKvm
+    b       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl30CopyMemoryFromUserAligned64BitEPvPKvm
 
 1:  /* We have less than 0x40 bytes to copy. */
     cmp     x2, #0
@@ -126,12 +126,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess30CopyMemoryFromUserAligned64BitEPvPKvm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryFromUserSize64Bit(void *dst, const void *src) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize64BitEPvPKv, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize64BitEPvPKv
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize64BitEPvPKv, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryFromUserSize64Bit(void *dst, const void *src) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl27CopyMemoryFromUserSize64BitEPvPKv, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl27CopyMemoryFromUserSize64BitEPvPKv
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl27CopyMemoryFromUserSize64BitEPvPKv, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize64BitEPvPKv:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl27CopyMemoryFromUserSize64BitEPvPKv:
     /* Just load and store a u64. */
     ldtr    x2, [x1]
     str     x2, [x0]
@@ -140,12 +140,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize64BitEPvPKv:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryFromUserSize32Bit(void *dst, const void *src) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize32BitEPvPKv, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize32BitEPvPKv
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize32BitEPvPKv, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryFromUserSize32Bit(void *dst, const void *src) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl27CopyMemoryFromUserSize32BitEPvPKv, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl27CopyMemoryFromUserSize32BitEPvPKv
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl27CopyMemoryFromUserSize32BitEPvPKv, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize32BitEPvPKv:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl27CopyMemoryFromUserSize32BitEPvPKv:
     /* Just load and store a u32. */
     ldtr    w2, [x1]
     str     w2, [x0]
@@ -154,12 +154,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess27CopyMemoryFromUserSize32BitEPvPKv:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryFromUserSize32BitWithSupervisorAccessImpl(void *dst, const void *src) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess51CopyMemoryFromUserSize32BitWithSupervisorAccessImplEPvPKv, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess51CopyMemoryFromUserSize32BitWithSupervisorAccessImplEPvPKv
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess51CopyMemoryFromUserSize32BitWithSupervisorAccessImplEPvPKv, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryFromUserSize32BitWithSupervisorAccess(void *dst, const void *src) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl47CopyMemoryFromUserSize32BitWithSupervisorAccessEPvPKv, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl47CopyMemoryFromUserSize32BitWithSupervisorAccessEPvPKv
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl47CopyMemoryFromUserSize32BitWithSupervisorAccessEPvPKv, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess51CopyMemoryFromUserSize32BitWithSupervisorAccessImplEPvPKv:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl47CopyMemoryFromUserSize32BitWithSupervisorAccessEPvPKv:
     /* Just load and store a u32. */
     /* NOTE: This is done with supervisor access permissions. */
     ldr     w2, [x1]
@@ -169,12 +169,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess51CopyMemoryFromUserSize32BitWithSupervi
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyStringFromUser(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess18CopyStringFromUserEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess18CopyStringFromUserEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess18CopyStringFromUserEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyStringFromUser(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18CopyStringFromUserEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18CopyStringFromUserEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18CopyStringFromUserEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess18CopyStringFromUserEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18CopyStringFromUserEPvPKvm:
     /* Check if there's anything to copy. */
     cmp     x2, #0
     b.eq    3f
@@ -204,12 +204,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess18CopyStringFromUserEPvPKvm:
     mov     x0, #0
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryToUser(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess16CopyMemoryToUserEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess16CopyMemoryToUserEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess16CopyMemoryToUserEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryToUser(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16CopyMemoryToUserEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16CopyMemoryToUserEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16CopyMemoryToUserEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess16CopyMemoryToUserEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16CopyMemoryToUserEPvPKvm:
     /* Check if there's anything to copy. */
     cmp     x2, #0
     b.eq    2f
@@ -228,12 +228,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess16CopyMemoryToUserEPvPKvm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryToUserAligned32Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned32BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned32BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned32BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryToUserAligned32Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned32BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned32BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned32BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned32BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned32BitEPvPKvm:
     /* Check if there are 0x40 bytes to copy */
     cmp     x2, #0x3F
     b.ls    1f
@@ -252,7 +252,7 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned32BitEPvPKvm:
     add     x0, x0, #0x40
     add     x1, x1, #0x40
     sub     x2, x2, #0x40
-    b       _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned32BitEPvPKvm
+    b       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned32BitEPvPKvm
 
 1:  /* We have less than 0x40 bytes to copy. */
     cmp     x2, #0
@@ -267,12 +267,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned32BitEPvPKvm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryToUserAligned64Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned64BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned64BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned64BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryToUserAligned64Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned64BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned64BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned64BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned64BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned64BitEPvPKvm:
     /* Check if there are 0x40 bytes to copy */
     cmp     x2, #0x3F
     b.ls    1f
@@ -291,7 +291,7 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned64BitEPvPKvm:
     add     x0, x0, #0x40
     add     x1, x1, #0x40
     sub     x2, x2, #0x40
-    b       _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned64BitEPvPKvm
+    b       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned64BitEPvPKvm
 
 1:  /* We have less than 0x40 bytes to copy. */
     cmp     x2, #0
@@ -306,12 +306,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess28CopyMemoryToUserAligned64BitEPvPKvm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyMemoryToUserSize32Bit(void *dst, const void *src) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess25CopyMemoryToUserSize32BitEPvPKv, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess25CopyMemoryToUserSize32BitEPvPKv
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess25CopyMemoryToUserSize32BitEPvPKv, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryToUserSize32Bit(void *dst, const void *src) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvPKv, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvPKv
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvPKv, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess25CopyMemoryToUserSize32BitEPvPKv:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvPKv:
     /* Just load and store a u32. */
     ldr     w2, [x1]
     sttr    w2, [x0]
@@ -320,12 +320,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess25CopyMemoryToUserSize32BitEPvPKv:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::CopyStringToUser(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess16CopyStringToUserEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess16CopyStringToUserEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess16CopyStringToUserEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyStringToUser(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16CopyStringToUserEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16CopyStringToUserEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16CopyStringToUserEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess16CopyStringToUserEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16CopyStringToUserEPvPKvm:
     /* Check if there's anything to copy. */
     cmp     x2, #0
     b.eq    3f
@@ -355,114 +355,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess16CopyStringToUserEPvPKvm:
     mov     x0, #0
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::ClearMemory(void *dst, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess11ClearMemoryEPvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess11ClearMemoryEPvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess11ClearMemoryEPvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::UpdateLockAtomic(u32 *out, u32 *address, u32 if_zero, u32 new_orr_mask) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16UpdateLockAtomicEPjS5_jj, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16UpdateLockAtomicEPjS5_jj
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16UpdateLockAtomicEPjS5_jj, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess11ClearMemoryEPvm:
-    /* Check if there's anything to clear. */
-    cmp     x1, #0
-    b.eq    2f
-
-    /* Keep track of the last address. */
-    add     x2, x0, x1
-
-1:  /* We're copying memory byte-by-byte. */
-    sttrb   wzr, [x0]
-    add     x0, x0, #1
-    cmp     x0, x2
-    b.ne    1b
-
-2:  /* We're done. */
-    mov     x0, #1
-    ret
-
-/* ams::kern::arch::arm64::UserspaceAccess::ClearMemoryAligned32Bit(void *dst, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned32BitEPvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned32BitEPvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned32BitEPvm, %function
-.balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned32BitEPvm:
-    /* Check if there are 0x40 bytes to clear. */
-    cmp     x1, #0x3F
-    b.ls    2f
-    sttr    xzr, [x0, #0x00]
-    sttr    xzr, [x0, #0x08]
-    sttr    xzr, [x0, #0x10]
-    sttr    xzr, [x0, #0x18]
-    sttr    xzr, [x0, #0x20]
-    sttr    xzr, [x0, #0x28]
-    sttr    xzr, [x0, #0x30]
-    sttr    xzr, [x0, #0x38]
-    add     x0, x0, #0x40
-    sub     x1, x1, #0x40
-    b       _ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned32BitEPvm
-
-1:  /* We have less than 0x40 bytes to clear. */
-    cmp     x1, #0
-    b.eq    2f
-    sttr    wzr, [x0]
-    add     x0, x0, #4
-    sub     x1, x1, #4
-    b       1b
-
-2:  /* We're done. */
-    mov     x0, #1
-    ret
-
-/* ams::kern::arch::arm64::UserspaceAccess::ClearMemoryAligned64Bit(void *dst, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned64BitEPvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned64BitEPvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned64BitEPvm, %function
-.balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned64BitEPvm:
-    /* Check if there are 0x40 bytes to clear. */
-    cmp     x1, #0x3F
-    b.ls    2f
-    sttr    xzr, [x0, #0x00]
-    sttr    xzr, [x0, #0x08]
-    sttr    xzr, [x0, #0x10]
-    sttr    xzr, [x0, #0x18]
-    sttr    xzr, [x0, #0x20]
-    sttr    xzr, [x0, #0x28]
-    sttr    xzr, [x0, #0x30]
-    sttr    xzr, [x0, #0x38]
-    add     x0, x0, #0x40
-    sub     x1, x1, #0x40
-    b       _ZN3ams4kern4arch5arm6415UserspaceAccess23ClearMemoryAligned64BitEPvm
-
-1:  /* We have less than 0x40 bytes to clear. */
-    cmp     x1, #0
-    b.eq    2f
-    sttr    xzr, [x0]
-    add     x0, x0, #8
-    sub     x1, x1, #8
-    b       1b
-
-2:  /* We're done. */
-    mov     x0, #1
-    ret
-
-/* ams::kern::arch::arm64::UserspaceAccess::ClearMemorySize32Bit(void *dst) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess20ClearMemorySize32BitEPv, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess20ClearMemorySize32BitEPv
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess20ClearMemorySize32BitEPv, %function
-.balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess20ClearMemorySize32BitEPv:
-    /* Just store a zero. */
-    sttr    wzr, [x0]
-
-    /* We're done. */
-    mov     x0, #1
-    ret
-
-/* ams::kern::arch::arm64::UserspaceAccess::UpdateLockAtomic(u32 *out, u32 *address, u32 if_zero, u32 new_orr_mask) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess16UpdateLockAtomicEPjS4_jj, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess16UpdateLockAtomicEPjS4_jj
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess16UpdateLockAtomicEPjS4_jj, %function
-.balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess16UpdateLockAtomicEPjS4_jj:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16UpdateLockAtomicEPjS5_jj:
     /* Load the value from the address. */
     ldaxr   w4, [x1]
 
@@ -477,7 +375,7 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess16UpdateLockAtomicEPjS4_jj:
     stlxr   w6, w5, [x1]
 
     /* If we failed to store, try again. */
-    cbnz    w6, _ZN3ams4kern4arch5arm6415UserspaceAccess16UpdateLockAtomicEPjS4_jj
+    cbnz    w6, _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16UpdateLockAtomicEPjS5_jj
 
     /* We're done. */
     str     w4, [x0]
@@ -485,12 +383,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess16UpdateLockAtomicEPjS4_jj:
     ret
 
 
-/* ams::kern::arch::arm64::UserspaceAccess::UpdateIfEqualAtomic(s32 *out, s32 *address, s32 compare_value, s32 new_value) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess19UpdateIfEqualAtomicEPiS4_ii, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess19UpdateIfEqualAtomicEPiS4_ii
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess19UpdateIfEqualAtomicEPiS4_ii, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::UpdateIfEqualAtomic(s32 *out, s32 *address, s32 compare_value, s32 new_value) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl19UpdateIfEqualAtomicEPiS5_ii, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl19UpdateIfEqualAtomicEPiS5_ii
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl19UpdateIfEqualAtomicEPiS5_ii, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess19UpdateIfEqualAtomicEPiS4_ii:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl19UpdateIfEqualAtomicEPiS5_ii:
     /* Load the value from the address. */
     ldaxr   w4, [x1]
 
@@ -508,19 +406,19 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess19UpdateIfEqualAtomicEPiS4_ii:
     stlxr   w5, w3, [x1]
 
     /* If we failed to store, try again. */
-    cbnz    w5, _ZN3ams4kern4arch5arm6415UserspaceAccess19UpdateIfEqualAtomicEPiS4_ii
+    cbnz    w5, _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl19UpdateIfEqualAtomicEPiS5_ii
 
 2:  /* We're done. */
     str     w4, [x0]
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::DecrementIfLessThanAtomic(s32 *out, s32 *address, s32 compare) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess25DecrementIfLessThanAtomicEPiS4_i, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess25DecrementIfLessThanAtomicEPiS4_i
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess25DecrementIfLessThanAtomicEPiS4_i, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::DecrementIfLessThanAtomic(s32 *out, s32 *address, s32 compare) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25DecrementIfLessThanAtomicEPiS5_i, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25DecrementIfLessThanAtomicEPiS5_i
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25DecrementIfLessThanAtomicEPiS5_i, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess25DecrementIfLessThanAtomicEPiS4_i:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25DecrementIfLessThanAtomicEPiS5_i:
     /* Load the value from the address. */
     ldaxr   w3, [x1]
 
@@ -539,19 +437,19 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess25DecrementIfLessThanAtomicEPiS4_i:
     stlxr   w5, w4, [x1]
 
     /* If we failed to store, try again. */
-    cbnz    w5, _ZN3ams4kern4arch5arm6415UserspaceAccess25DecrementIfLessThanAtomicEPiS4_i
+    cbnz    w5, _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25DecrementIfLessThanAtomicEPiS5_i
 
 2:  /* We're done. */
     str     w3, [x0]
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::StoreDataCache(uintptr_t start, uintptr_t end) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess14StoreDataCacheEmm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess14StoreDataCacheEmm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess14StoreDataCacheEmm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::StoreDataCache(uintptr_t start, uintptr_t end) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl14StoreDataCacheEmm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl14StoreDataCacheEmm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl14StoreDataCacheEmm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess14StoreDataCacheEmm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl14StoreDataCacheEmm:
     /* Check if we have any work to do. */
     cmp     x1, x0
     b.eq    2f
@@ -566,12 +464,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess14StoreDataCacheEmm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::FlushDataCache(uintptr_t start, uintptr_t end) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess14FlushDataCacheEmm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess14FlushDataCacheEmm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess14FlushDataCacheEmm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::FlushDataCache(uintptr_t start, uintptr_t end) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl14FlushDataCacheEmm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl14FlushDataCacheEmm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl14FlushDataCacheEmm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess14FlushDataCacheEmm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl14FlushDataCacheEmm:
     /* Check if we have any work to do. */
     cmp     x1, x0
     b.eq    2f
@@ -586,12 +484,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess14FlushDataCacheEmm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::InvalidateDataCache(uintptr_t start, uintptr_t end) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess19InvalidateDataCacheEmm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess19InvalidateDataCacheEmm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess19InvalidateDataCacheEmm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::InvalidateDataCache(uintptr_t start, uintptr_t end) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl19InvalidateDataCacheEmm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl19InvalidateDataCacheEmm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl19InvalidateDataCacheEmm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess19InvalidateDataCacheEmm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl19InvalidateDataCacheEmm:
     /* Check if we have any work to do. */
     cmp     x1, x0
     b.eq    2f
@@ -606,12 +504,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess19InvalidateDataCacheEmm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::ReadIoMemory32Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory32BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory32BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory32BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::ReadIoMemory32Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17ReadIoMemory32BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17ReadIoMemory32BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17ReadIoMemory32BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory32BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17ReadIoMemory32BitEPvPKvm:
     /* Check if we have any work to do. */
     cmp     x2, #0
     b.eq    3f
@@ -656,12 +554,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory32BitEPvPKvm:
     mov     w9, #0xFFFFFFFF
     b       2b
 
-/* ams::kern::arch::arm64::UserspaceAccess::ReadIoMemory16Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory16BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory16BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory16BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::ReadIoMemory16Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17ReadIoMemory16BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17ReadIoMemory16BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17ReadIoMemory16BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory16BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17ReadIoMemory16BitEPvPKvm:
     /* Check if we have any work to do. */
     cmp     x2, #0
     b.eq    3f
@@ -706,12 +604,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess17ReadIoMemory16BitEPvPKvm:
     mov     w9, #0xFFFFFFFF
     b       2b
 
-/* ams::kern::arch::arm64::UserspaceAccess::ReadIoMemory8Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess16ReadIoMemory8BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess16ReadIoMemory8BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess16ReadIoMemory8BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::ReadIoMemory8Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16ReadIoMemory8BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16ReadIoMemory8BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16ReadIoMemory8BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess16ReadIoMemory8BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl16ReadIoMemory8BitEPvPKvm:
     /* Check if we have any work to do. */
     cmp     x2, #0
     b.eq    3f
@@ -756,12 +654,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess16ReadIoMemory8BitEPvPKvm:
     mov     w9, #0xFFFFFFFF
     b       2b
 
-/* ams::kern::arch::arm64::UserspaceAccess::WriteIoMemory32Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory32BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory32BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory32BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::WriteIoMemory32Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18WriteIoMemory32BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18WriteIoMemory32BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18WriteIoMemory32BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory32BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18WriteIoMemory32BitEPvPKvm:
     /* Check if we have any work to do. */
     cmp     x2, #0
     b.eq    3f
@@ -801,12 +699,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory32BitEPvPKvm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::WriteIoMemory16Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory16BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory16BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory16BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::WriteIoMemory16Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18WriteIoMemory16BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18WriteIoMemory16BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18WriteIoMemory16BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory16BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl18WriteIoMemory16BitEPvPKvm:
     /* Check if we have any work to do. */
     cmp     x2, #0
     b.eq    3f
@@ -846,12 +744,12 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess18WriteIoMemory16BitEPvPKvm:
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::WriteIoMemory8Bit(void *dst, const void *src, size_t size) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess17WriteIoMemory8BitEPvPKvm, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess17WriteIoMemory8BitEPvPKvm
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess17WriteIoMemory8BitEPvPKvm, %function
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::WriteIoMemory8Bit(void *dst, const void *src, size_t size) */
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17WriteIoMemory8BitEPvPKvm, "ax", %progbits
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17WriteIoMemory8BitEPvPKvm
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17WriteIoMemory8BitEPvPKvm, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess17WriteIoMemory8BitEPvPKvm:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl17WriteIoMemory8BitEPvPKvm:
     /* Check if we have any work to do. */
     cmp     x2, #0
     b.eq    3f

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

@@ -524,6 +524,14 @@ namespace ams::kern::board::nintendo::nx {
                 /* Ensure that all cores get to this point before continuing. */
                 cpu::SynchronizeAllCores();
 
+                /* Wait 100us before continuing. */
+                {
+                    const s64 timeout = KHardwareTimer::GetTick() + ams::svc::Tick(TimeSpan::FromMicroSeconds(100));
+                    while (KHardwareTimer::GetTick() < timeout) {
+                        __asm__ __volatile__("" ::: "memory");
+                    }
+                }
+
                 /* Save the interrupt manager's state. */
                 Kernel::GetInterruptManager().Save(core_id);
 

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

@@ -361,7 +361,9 @@ namespace ams::kern::board::nintendo::nx {
         }();
 
         /* Return (possibly) adjusted size. */
-        constexpr size_t ExtraSystemMemoryForAtmosphere = 40_MB;
+        /* NOTE: On 20.0.0+ the browser requires much more memory in the applet pool in order to function. */
+        /* Thus, we have to reduce our extra system memory size by 26 MB to compensate. */
+        const size_t ExtraSystemMemoryForAtmosphere = kern::GetTargetFirmware() >= ams::TargetFirmware_20_0_0 ? 14_MB : 40_MB;
         return base_pool_size - ExtraSystemMemoryForAtmosphere - KTraceBufferSize;
     }
 
@@ -405,22 +407,22 @@ namespace ams::kern::board::nintendo::nx {
         /* Configure KTargetSystem. */
         volatile auto *ts = const_cast<volatile KTargetSystem::KTargetSystemData *>(std::addressof(KTargetSystem::s_data));
         {
-            /* Set IsDebugMode. */
+            /* Set whether we're in debug mode. */
             {
-                ts->is_debug_mode        = GetConfigBool(smc::ConfigItem::IsDebugMode);
+                ts->is_not_debug_mode    = !GetConfigBool(smc::ConfigItem::IsDebugMode);
 
-                /* If debug mode, we want to initialize uart logging. */
-                ts->enable_debug_logging = ts->is_debug_mode;
+                /* If we're not in debug mode, we don't want to initialize uart logging. */
+                ts->disable_debug_logging = ts->is_not_debug_mode;
             }
 
             /* Set Kernel Configuration. */
             {
                 const auto kernel_config = util::BitPack32{GetConfigU32(smc::ConfigItem::KernelConfiguration)};
 
-                ts->enable_debug_memory_fill       = kernel_config.Get<smc::KernelConfiguration::DebugFillMemory>();
-                ts->enable_user_exception_handlers = kernel_config.Get<smc::KernelConfiguration::EnableUserExceptionHandlers>();
-                ts->enable_dynamic_resource_limits = !kernel_config.Get<smc::KernelConfiguration::DisableDynamicResourceLimits>();
-                ts->enable_user_pmu_access         = kernel_config.Get<smc::KernelConfiguration::EnableUserPmuAccess>();
+                ts->disable_debug_memory_fill       = !kernel_config.Get<smc::KernelConfiguration::DebugFillMemory>();
+                ts->disable_user_exception_handlers = !kernel_config.Get<smc::KernelConfiguration::EnableUserExceptionHandlers>();
+                ts->disable_dynamic_resource_limits = kernel_config.Get<smc::KernelConfiguration::DisableDynamicResourceLimits>();
+                ts->disable_user_pmu_access         = !kernel_config.Get<smc::KernelConfiguration::EnableUserPmuAccess>();
 
                 /* Configure call smc on panic. */
                 *const_cast<volatile bool *>(std::addressof(g_call_smc_on_panic)) = kernel_config.Get<smc::KernelConfiguration::UseSecureMonitorPanicCall>();
@@ -430,7 +432,7 @@ namespace ams::kern::board::nintendo::nx {
             {
                 /* NOTE: This is used to restrict access to SvcKernelDebug/SvcChangeKernelTraceState. */
                 /* Mesosphere may wish to not require this, as we'd ideally keep ProgramVerification enabled for userland. */
-                ts->enable_kernel_debugging = GetConfigBool(smc::ConfigItem::DisableProgramVerification);
+                ts->disable_kernel_debugging = !GetConfigBool(smc::ConfigItem::DisableProgramVerification);
             }
         }
     }
@@ -524,7 +526,7 @@ namespace ams::kern::board::nintendo::nx {
         KScopedSpinLock lk(s_random_lock);
 
 
-        if (AMS_LIKELY(s_initialized_random_generator)) {
+        if (AMS_LIKELY(!s_uninitialized_random_generator)) {
             return KSystemControlBase::GenerateUniformRange(min, max, []() ALWAYS_INLINE_LAMBDA -> u64 { return s_random_generator.GenerateRandomU64(); });
         } else {
             return KSystemControlBase::GenerateUniformRange(min, max, GenerateRandomU64FromSmc);
@@ -535,7 +537,7 @@ namespace ams::kern::board::nintendo::nx {
         KScopedInterruptDisable intr_disable;
         KScopedSpinLock lk(s_random_lock);
 
-        if (AMS_LIKELY(s_initialized_random_generator)) {
+        if (AMS_LIKELY(!s_uninitialized_random_generator)) {
             return s_random_generator.GenerateRandomU64();
         } else {
             return GenerateRandomU64FromSmc();

libraries/libmesosphere/source/kern_k_address_space_info.cpp

@@ -66,12 +66,39 @@ namespace ams::kern {
 
     }
 
-    uintptr_t KAddressSpaceInfo::GetAddressSpaceStart(ams::svc::CreateProcessFlag flags, KAddressSpaceInfo::Type type) {
+    uintptr_t KAddressSpaceInfo::GetAddressSpaceStart(ams::svc::CreateProcessFlag flags, KAddressSpaceInfo::Type type, size_t code_size) {
+        MESOSPHERE_UNUSED(code_size);
         return GetAddressSpaceInfo(GetAddressSpaceWidth(flags), type).GetAddress();
     }
 
     size_t KAddressSpaceInfo::GetAddressSpaceSize(ams::svc::CreateProcessFlag flags, KAddressSpaceInfo::Type type) {
-        return GetAddressSpaceInfo(GetAddressSpaceWidth(flags), type).GetSize();
+        /* Extract the address space from the create process flags. */
+        const auto as_flags = (flags & ams::svc::CreateProcessFlag_AddressSpaceMask);
+
+        /* Get the address space width. */
+        const auto as_width = GetAddressSpaceWidth(flags);
+
+        /* Get the size. */
+        size_t as_size = GetAddressSpaceInfo(as_width, type).GetSize();
+
+        /* If we're getting size for 32-bit without alias, adjust the sizes accordingly. */
+        if (as_flags == ams::svc::CreateProcessFlag_AddressSpace32BitWithoutAlias) {
+            switch (type) {
+                /* The heap space receives space that would otherwise go to the alias space. */
+                case KAddressSpaceInfo::Type_Heap:
+                    as_size += GetAddressSpaceInfo(as_width, KAddressSpaceInfo::Type_Alias).GetSize();
+                    break;
+                /* The alias space doesn't exist. */
+                case KAddressSpaceInfo::Type_Alias:
+                    as_size = 0;
+                    break;
+                /* Nothing to do by default. */
+                default:
+                    break;
+            }
+        }
+
+        return as_size;
     }
 
     void KAddressSpaceInfo::SetAddressSpaceSize(size_t width, Type type, size_t size) {

libraries/libmesosphere/source/kern_k_initial_process_reader.cpp

@@ -229,9 +229,12 @@ namespace ams::kern {
         out->flags |= ams::svc::CreateProcessFlag_DisableDeviceAddressSpaceMerge;
 
         /* Set and check code address. */
+        /* NOTE: Even though Nintendo passes a size to GetAddressSpaceStart at other call sites, they pass */
+        /* a number of pages here. Even though this is presumably only used for debug assertions, this is */
+        /* almost certainly a bug. */
         using ASType = KAddressSpaceInfo::Type;
         const ASType    as_type       = this->Is64BitAddressSpace() ? ((GetTargetFirmware() >= TargetFirmware_2_0_0) ? KAddressSpaceInfo::Type_Map39Bit : KAddressSpaceInfo::Type_MapSmall) : KAddressSpaceInfo::Type_MapSmall;
-        const uintptr_t map_start     = KAddressSpaceInfo::GetAddressSpaceStart(static_cast<ams::svc::CreateProcessFlag>(out->flags), as_type);
+        const uintptr_t map_start     = KAddressSpaceInfo::GetAddressSpaceStart(static_cast<ams::svc::CreateProcessFlag>(out->flags), as_type, out->code_num_pages);
         const size_t    map_size      = KAddressSpaceInfo::GetAddressSpaceSize(static_cast<ams::svc::CreateProcessFlag>(out->flags), as_type);
         const uintptr_t map_end       = map_start + map_size;
         out->code_address             = map_start + start_address;

libraries/libmesosphere/source/kern_k_memory_block_manager.cpp

@@ -118,29 +118,78 @@ namespace ams::kern {
         MESOSPHERE_ASSERT(m_memory_block_tree.empty());
     }
 
+    bool KMemoryBlockManager::GetRegionForFindFreeArea(KProcessAddress *out_start, KProcessAddress *out_end, KProcessAddress region_start, size_t region_num_pages, size_t num_pages, size_t alignment, size_t offset, size_t guard_pages) {
+        /* Check that there's room for the pages in the specified region. */
+        if (num_pages + 2 * guard_pages > region_num_pages) {
+            return false;
+        }
+
+        /* Determine the aligned start of the guarded region. */
+        const KProcessAddress guarded_start                     = region_start + guard_pages * PageSize;
+        const KProcessAddress aligned_guarded_start             = util::AlignDown(GetInteger(guarded_start), alignment);
+              KProcessAddress aligned_guarded_start_with_offset = aligned_guarded_start + offset;
+        if (guarded_start > aligned_guarded_start_with_offset) {
+            if (!util::CanAddWithoutOverflow<uintptr_t>(GetInteger(aligned_guarded_start), alignment)) {
+                return false;
+            }
+            aligned_guarded_start_with_offset += alignment;
+        }
+
+        /* Determine the aligned end of the guarded region. */
+        const KProcessAddress guarded_end                     = region_start + ((region_num_pages - (num_pages + guard_pages)) * PageSize);
+        const KProcessAddress aligned_guarded_end             = util::AlignDown(GetInteger(guarded_end), alignment);
+              KProcessAddress aligned_guarded_end_with_offset = aligned_guarded_end + offset;
+        if (aligned_guarded_end_with_offset > guarded_end) {
+            if (aligned_guarded_end < alignment) {
+                return false;
+            }
+            aligned_guarded_end_with_offset -= alignment;
+        }
+
+        /* Check that the extents are valid. */
+        if (aligned_guarded_end_with_offset < aligned_guarded_start_with_offset) {
+            return false;
+        }
+
+        /* Set the output extents. */
+        *out_start = aligned_guarded_start_with_offset;
+        *out_end   = aligned_guarded_end_with_offset;
+        return true;
+    }
+
     KProcessAddress KMemoryBlockManager::FindFreeArea(KProcessAddress region_start, size_t region_num_pages, size_t num_pages, size_t alignment, size_t offset, size_t guard_pages) const {
-        if (num_pages > 0) {
-            const KProcessAddress region_end  = region_start + region_num_pages * PageSize;
-            const KProcessAddress region_last = region_end - 1;
-            for (const_iterator it = this->FindIterator(region_start); it != m_memory_block_tree.cend(); it++) {
-                if (region_last < it->GetAddress()) {
+        /* Determine the range to search in. */
+        KProcessAddress search_start = Null<KProcessAddress>;
+        KProcessAddress search_end   = Null<KProcessAddress>;
+        if (this->GetRegionForFindFreeArea(std::addressof(search_start), std::addressof(search_end), region_start, region_num_pages, num_pages, alignment, offset, guard_pages)) {
+            /* Iterate over blocks in the search space, looking for a suitable one. */
+            for (const_iterator it = this->FindIterator(search_start); it != m_memory_block_tree.cend(); it++) {
+                /* If our block is past the end of our search space, we're done. */
+                if (search_end < it->GetAddress()) {
                     break;
                 }
+
+                /* We only want to consider free blocks. */
                 if (it->GetState() != KMemoryState_Free) {
                     continue;
                 }
 
-                KProcessAddress area = (it->GetAddress() <= GetInteger(region_start)) ? region_start : it->GetAddress();
-                area += guard_pages * PageSize;
+                /* Determine the candidate range. */
+                KProcessAddress candidate_start = Null<KProcessAddress>;
+                KProcessAddress candidate_end   = Null<KProcessAddress>;
+                if (!this->GetRegionForFindFreeArea(std::addressof(candidate_start), std::addressof(candidate_end), it->GetAddress(), it->GetNumPages(), num_pages, alignment, offset, guard_pages)) {
+                    continue;
+                }
 
-                const KProcessAddress offset_area = util::AlignDown(GetInteger(area), alignment) + offset;
-                area = (area <= offset_area) ? offset_area : offset_area + alignment;
+                /* Try the suggested candidate (coercing into the search region if needed). */
+                KProcessAddress candidate = candidate_start;
+                if (candidate < search_start) {
+                    candidate = search_start;
+                }
 
-                const KProcessAddress area_end = area + num_pages * PageSize + guard_pages * PageSize;
-                const KProcessAddress area_last = area_end - 1;
-
-                if (GetInteger(it->GetAddress()) <= GetInteger(area) && area < area_last && area_last <= region_last && GetInteger(area_last) <= GetInteger(it->GetLastAddress())) {
-                    return area;
+                /* Check if the candidate is valid. */
+                if (candidate <= search_end && candidate <= candidate_end) {
+                    return candidate;
                 }
             }
         }

libraries/libmesosphere/source/kern_k_page_table_base.cpp

@@ -141,7 +141,7 @@ namespace ams::kern {
 
         /* Define helpers. */
         auto GetSpaceStart = [&](KAddressSpaceInfo::Type type) ALWAYS_INLINE_LAMBDA {
-            return KAddressSpaceInfo::GetAddressSpaceStart(flags, type);
+            return KAddressSpaceInfo::GetAddressSpaceStart(flags, type, code_size);
         };
         auto GetSpaceSize = [&](KAddressSpaceInfo::Type type) ALWAYS_INLINE_LAMBDA {
             return KAddressSpaceInfo::GetAddressSpaceSize(flags, type);
@@ -155,12 +155,6 @@ namespace ams::kern {
         size_t alias_region_size  = GetSpaceSize(KAddressSpaceInfo::Type_Alias);
         size_t heap_region_size   = GetSpaceSize(KAddressSpaceInfo::Type_Heap);
 
-        /* Adjust heap/alias size if we don't have an alias region. */
-        if ((flags & ams::svc::CreateProcessFlag_AddressSpaceMask) == ams::svc::CreateProcessFlag_AddressSpace32BitWithoutAlias) {
-            heap_region_size += alias_region_size;
-            alias_region_size = 0;
-        }
-
         /* Set code regions and determine remaining sizes. */
         KProcessAddress process_code_start;
         KProcessAddress process_code_end;
@@ -1339,34 +1333,37 @@ namespace ams::kern {
     KProcessAddress KPageTableBase::FindFreeArea(KProcessAddress region_start, size_t region_num_pages, size_t num_pages, size_t alignment, size_t offset, size_t guard_pages) const {
         KProcessAddress address = Null<KProcessAddress>;
 
-        if (num_pages <= region_num_pages) {
+        KProcessAddress search_start = Null<KProcessAddress>;
+        KProcessAddress search_end   = Null<KProcessAddress>;
+        if (m_memory_block_manager.GetRegionForFindFreeArea(std::addressof(search_start), std::addressof(search_end), region_start, region_num_pages, num_pages, alignment, offset, guard_pages)) {
             if (this->IsAslrEnabled()) {
                 /* Try to directly find a free area up to 8 times. */
                 for (size_t i = 0; i < 8; i++) {
-                    const size_t random_offset = KSystemControl::GenerateRandomRange(0, (region_num_pages - num_pages - guard_pages) * PageSize / alignment) * alignment;
-                    const KProcessAddress candidate = util::AlignDown(GetInteger(region_start + random_offset), alignment) + offset;
+                    const size_t random_offset = KSystemControl::GenerateRandomRange(0, (search_end - search_start) / alignment) * alignment;
+                    const KProcessAddress candidate = search_start + random_offset;
 
                     KMemoryBlockManager::const_iterator it = m_memory_block_manager.FindIterator(candidate);
                     MESOSPHERE_ABORT_UNLESS(it != m_memory_block_manager.end());
 
                     if (it->GetState() != KMemoryState_Free) { continue; }
-                    if (!(region_start <= candidate)) { continue; }
                     if (!(it->GetAddress() + guard_pages * PageSize <= GetInteger(candidate))) { continue; }
                     if (!(candidate + (num_pages + guard_pages) * PageSize - 1 <= it->GetLastAddress())) { continue; }
-                    if (!(candidate + (num_pages + guard_pages) * PageSize - 1 <= region_start + region_num_pages * PageSize - 1)) { continue; }
 
                     address = candidate;
                     break;
                 }
+
                 /* Fall back to finding the first free area with a random offset. */
                 if (address == Null<KProcessAddress>) {
                     /* NOTE: Nintendo does not account for guard pages here. */
                     /* This may theoretically cause an offset to be chosen that cannot be mapped. */
                     /* We will account for guard pages. */
-                    const size_t offset_pages = KSystemControl::GenerateRandomRange(0, region_num_pages - num_pages - guard_pages);
-                    address = m_memory_block_manager.FindFreeArea(region_start + offset_pages * PageSize, region_num_pages - offset_pages, num_pages, alignment, offset, guard_pages);
+                    const size_t offset_blocks = KSystemControl::GenerateRandomRange(0, (search_end - search_start) / alignment);
+                    const auto   region_end    = region_start + region_num_pages * PageSize;
+                    address = m_memory_block_manager.FindFreeArea(search_start + offset_blocks * alignment, (region_end - (search_start + offset_blocks * alignment)) / PageSize, num_pages, alignment, offset, guard_pages);
                 }
             }
+
             /* Find the first free area. */
             if (address == Null<KProcessAddress>) {
                 address = m_memory_block_manager.FindFreeArea(region_start, region_num_pages, num_pages, alignment, offset, guard_pages);
@@ -1792,19 +1789,24 @@ namespace ams::kern {
             KScopedSchedulerLock sl;
         }
 
+        /* Ensure cache coherency, if we're setting pages as executable. */
+        if (is_x) {
+            for (const auto &block : pg) {
+                cpu::StoreDataCache(GetVoidPointer(GetHeapVirtualAddress(block.GetAddress())), block.GetSize());
+            }
+            cpu::InvalidateEntireInstructionCache();
+        }
+
         /* Perform mapping operation. */
         const KPageProperties properties = { new_perm, false, false, DisableMergeAttribute_None };
-        const auto operation = was_x ? OperationType_ChangePermissionsAndRefreshAndFlush : OperationType_ChangePermissions;
+        const auto operation = was_x ? OperationType_ChangePermissionsAndRefresh : OperationType_ChangePermissions;
         R_TRY(this->Operate(updater.GetPageList(), addr, num_pages, Null<KPhysicalAddress>, false, properties, operation, false));
 
         /* Update the blocks. */
         m_memory_block_manager.Update(std::addressof(allocator), addr, num_pages, new_state, new_perm, KMemoryAttribute_None, KMemoryBlockDisableMergeAttribute_None, KMemoryBlockDisableMergeAttribute_None);
 
         /* Ensure cache coherency, if we're setting pages as executable. */
-        if (is_x) {
-            for (const auto &block : pg) {
-                cpu::StoreDataCache(GetVoidPointer(GetHeapVirtualAddress(block.GetAddress())), block.GetSize());
-            }
+        if (was_x) {
             cpu::InvalidateEntireInstructionCache();
         }
 
@@ -2546,6 +2548,11 @@ namespace ams::kern {
         /* We're going to perform an update, so create a helper. */
         KScopedPageTableUpdater updater(this);
 
+        /* Ensure cache coherency, if we're mapping executable pages. */
+        if ((perm & KMemoryPermission_UserExecute) == KMemoryPermission_UserExecute) {
+            cpu::InvalidateEntireInstructionCache();
+        }
+
         /* Perform mapping operation. */
         const KPageProperties properties = { perm, false, false, DisableMergeAttribute_DisableHead };
         R_TRY(this->MapPageGroupImpl(updater.GetPageList(), addr, pg, properties, false));
@@ -2569,8 +2576,9 @@ namespace ams::kern {
         KScopedLightLock lk(m_general_lock);
 
         /* Check if state allows us to unmap. */
+        KMemoryPermission old_perm;
         size_t num_allocator_blocks;
-        R_TRY(this->CheckMemoryState(std::addressof(num_allocator_blocks), address, size, KMemoryState_All, state, KMemoryPermission_None, KMemoryPermission_None, KMemoryAttribute_All, KMemoryAttribute_None));
+        R_TRY(this->CheckMemoryState(nullptr, std::addressof(old_perm), nullptr, std::addressof(num_allocator_blocks), address, size, KMemoryState_All, state, KMemoryPermission_None, KMemoryPermission_None, KMemoryAttribute_All, KMemoryAttribute_None));
 
         /* Check that the page group is valid. */
         R_UNLESS(this->IsValidPageGroup(pg, address, num_pages), svc::ResultInvalidCurrentMemory());
@@ -2587,6 +2595,11 @@ namespace ams::kern {
         const KPageProperties properties = { KMemoryPermission_None, false, false, DisableMergeAttribute_None };
         R_TRY(this->Operate(updater.GetPageList(), address, num_pages, Null<KPhysicalAddress>, false, properties, OperationType_Unmap, false));
 
+        /* Ensure cache coherency, if we're mapping executable pages. */
+        if ((old_perm & KMemoryPermission_UserExecute) == KMemoryPermission_UserExecute) {
+            cpu::InvalidateEntireInstructionCache();
+        }
+
         /* Update the blocks. */
         m_memory_block_manager.Update(std::addressof(allocator), address, num_pages, KMemoryState_Free, KMemoryPermission_None, KMemoryAttribute_None, KMemoryBlockDisableMergeAttribute_None, KMemoryBlockDisableMergeAttribute_Normal);
 

libraries/libmesosphere/source/kern_k_process.cpp

@@ -221,7 +221,7 @@ namespace ams::kern {
         }
 
         /* Set max memory. */
-        m_max_process_memory = m_page_table.GetHeapRegionSize();
+        m_max_process_memory = KAddressSpaceInfo::GetAddressSpaceSize(static_cast<ams::svc::CreateProcessFlag>(m_flags), KAddressSpaceInfo::Type_Heap);
 
         /* Generate random entropy. */
         KSystemControl::GenerateRandom(m_entropy, util::size(m_entropy));

libraries/libmesosphere/source/kern_k_system_control_base.cpp

@@ -102,10 +102,10 @@ namespace ams::kern {
 
     /* Randomness for Initialization. */
     void KSystemControlBase::Init::GenerateRandom(u64 *dst, size_t count) {
-        if (AMS_UNLIKELY(!s_initialized_random_generator)) {
+        if (AMS_UNLIKELY(s_uninitialized_random_generator)) {
             const u64 seed = KHardwareTimer::GetTick();
             s_random_generator.Initialize(reinterpret_cast<const u32*>(std::addressof(seed)), sizeof(seed) / sizeof(u32));
-            s_initialized_random_generator = true;
+            s_uninitialized_random_generator = false;
         }
 
         for (size_t i = 0; i < count; ++i) {
@@ -114,10 +114,10 @@ namespace ams::kern {
     }
 
     u64 KSystemControlBase::Init::GenerateRandomRange(u64 min, u64 max) {
-        if (AMS_UNLIKELY(!s_initialized_random_generator)) {
+        if (AMS_UNLIKELY(s_uninitialized_random_generator)) {
             const u64 seed = KHardwareTimer::GetTick();
             s_random_generator.Initialize(reinterpret_cast<const u32*>(std::addressof(seed)), sizeof(seed) / sizeof(u32));
-            s_initialized_random_generator = true;
+            s_uninitialized_random_generator = false;
         }
 
         return KSystemControlBase::GenerateUniformRange(min, max, []() ALWAYS_INLINE_LAMBDA -> u64 { return s_random_generator.GenerateRandomU64(); });
@@ -140,9 +140,9 @@ namespace ams::kern {
 
     void KSystemControlBase::InitializePhase1Base(u64 seed) {
         /* Initialize the rng, if we somehow haven't already. */
-        if (AMS_UNLIKELY(!s_initialized_random_generator)) {
+        if (AMS_UNLIKELY(s_uninitialized_random_generator)) {
             s_random_generator.Initialize(reinterpret_cast<const u32*>(std::addressof(seed)), sizeof(seed) / sizeof(u32));
-            s_initialized_random_generator = true;
+            s_uninitialized_random_generator = false;
         }
 
         /* Initialize debug logging. */

libraries/libmesosphere/source/kern_k_system_resource.cpp

@@ -59,7 +59,9 @@ namespace ams::kern {
         memory_reservation.Commit();
 
         /* Open reference to our resource limit. */
-        m_resource_limit->Open();
+        if (m_resource_limit != nullptr) {
+            m_resource_limit->Open();
+        }
 
         /* Set ourselves as initialized. */
         m_is_initialized = true;
@@ -76,11 +78,14 @@ namespace ams::kern {
         /* Free our secure memory. */
         KSystemControl::FreeSecureMemory(m_resource_address, m_resource_size, m_resource_pool);
 
-        /* Release the memory reservation. */
-        m_resource_limit->Release(ams::svc::LimitableResource_PhysicalMemoryMax, this->CalculateRequiredSecureMemorySize());
+        /* Clean up our resource usage. */
+        if (m_resource_limit != nullptr) {
+            /* Release the memory reservation. */
+            m_resource_limit->Release(ams::svc::LimitableResource_PhysicalMemoryMax, this->CalculateRequiredSecureMemorySize());
 
-        /* Close reference to our resource limit. */
-        m_resource_limit->Close();
+            /* Close reference to our resource limit. */
+            m_resource_limit->Close();
+        }
     }
 
     size_t KSecureSystemResource::CalculateRequiredSecureMemorySize(size_t size, KMemoryManager::Pool pool) {

libraries/libmesosphere/source/kern_kernel.cpp

@@ -74,43 +74,45 @@ namespace ams::kern {
         MESOSPHERE_ABORT_UNLESS(rc_size < size);
         size -= rc_size;
 
+        /* Determine dynamic page managers. */
+        KDynamicPageManager * const app_dynamic_page_manager = nullptr;
+        KDynamicPageManager * const sys_dynamic_page_manager = KTargetSystem::IsDynamicResourceLimitsEnabled() ? std::addressof(g_resource_manager_page_manager) : nullptr;
+
         /* Initialize the resource managers' shared page manager. */
         g_resource_manager_page_manager.Initialize(address, size, std::max<size_t>(PageSize, KPageBufferSlabHeap::BufferSize));
 
         /* Initialize the KPageBuffer slab heap. */
         KPageBuffer::InitializeSlabHeap(g_resource_manager_page_manager);
 
-        /* Initialize the fixed-size slabheaps. */
-        s_app_memory_block_heap.Initialize(std::addressof(g_resource_manager_page_manager), ApplicationMemoryBlockSlabHeapSize);
-        s_sys_memory_block_heap.Initialize(std::addressof(g_resource_manager_page_manager), SystemMemoryBlockSlabHeapSize);
+        /* Initialize the block info heap. */
         s_block_info_heap.Initialize(std::addressof(g_resource_manager_page_manager), BlockInfoSlabHeapSize);
 
+        /* Initialize the system slab managers. */
+        s_sys_block_info_manager.Initialize(sys_dynamic_page_manager, std::addressof(s_block_info_heap));
+        s_sys_memory_block_heap.Initialize(std::addressof(g_resource_manager_page_manager), SystemMemoryBlockSlabHeapSize);
+        s_sys_memory_block_manager.Initialize(sys_dynamic_page_manager, std::addressof(s_sys_memory_block_heap));
+
+        /* Initialize the application slab managers. */
+        s_app_block_info_manager.Initialize(app_dynamic_page_manager, std::addressof(s_block_info_heap));
+        s_app_memory_block_heap.Initialize(std::addressof(g_resource_manager_page_manager), ApplicationMemoryBlockSlabHeapSize);
+        s_app_memory_block_manager.Initialize(app_dynamic_page_manager, std::addressof(s_app_memory_block_heap));
+
         /* Reserve all but a fixed number of remaining pages for the page table heap. */
         const size_t num_pt_pages = g_resource_manager_page_manager.GetCount() - g_resource_manager_page_manager.GetUsed() - ReservedDynamicPageCount;
         s_page_table_heap.Initialize(std::addressof(g_resource_manager_page_manager), num_pt_pages, GetPointer<KPageTableManager::RefCount>(address + size));
 
-        /* Setup the slab managers. */
-        KDynamicPageManager * const app_dynamic_page_manager = nullptr;
-        KDynamicPageManager * const sys_dynamic_page_manager = KTargetSystem::IsDynamicResourceLimitsEnabled() ? std::addressof(g_resource_manager_page_manager) : nullptr;
-        s_app_memory_block_manager.Initialize(app_dynamic_page_manager, std::addressof(s_app_memory_block_heap));
-        s_sys_memory_block_manager.Initialize(sys_dynamic_page_manager, std::addressof(s_sys_memory_block_heap));
-
-        s_app_block_info_manager.Initialize(app_dynamic_page_manager, std::addressof(s_block_info_heap));
-        s_sys_block_info_manager.Initialize(sys_dynamic_page_manager, std::addressof(s_block_info_heap));
-
-        s_app_page_table_manager.Initialize(app_dynamic_page_manager, std::addressof(s_page_table_heap));
+        /* Create and initialize the system system resource. */
         s_sys_page_table_manager.Initialize(sys_dynamic_page_manager, std::addressof(s_page_table_heap));
+        KAutoObject::Create<KSystemResource>(std::addressof(s_sys_system_resource));
+        s_sys_system_resource.SetManagers(s_sys_memory_block_manager, s_sys_block_info_manager, s_sys_page_table_manager);
+
+        /* Create and initialize the application system resource. */
+        s_app_page_table_manager.Initialize(app_dynamic_page_manager, std::addressof(s_page_table_heap));
+        KAutoObject::Create<KSystemResource>(std::addressof(s_app_system_resource));
+        s_app_system_resource.SetManagers(s_app_memory_block_manager, s_app_block_info_manager, s_app_page_table_manager);
 
         /* Check that we have the correct number of dynamic pages available. */
         MESOSPHERE_ABORT_UNLESS(g_resource_manager_page_manager.GetCount() - g_resource_manager_page_manager.GetUsed() == ReservedDynamicPageCount);
-
-        /* Create the system page table managers. */
-        KAutoObject::Create<KSystemResource>(std::addressof(s_app_system_resource));
-        KAutoObject::Create<KSystemResource>(std::addressof(s_sys_system_resource));
-
-        /* Set the managers for the system resources. */
-        s_app_system_resource.SetManagers(s_app_memory_block_manager, s_app_block_info_manager, s_app_page_table_manager);
-        s_sys_system_resource.SetManagers(s_sys_memory_block_manager, s_sys_block_info_manager, s_sys_page_table_manager);
     }
 
     void Kernel::PrintLayout() {

libraries/libmesosphere/source/svc/kern_svc_process.cpp

@@ -109,11 +109,12 @@ namespace ams::kern::svc {
             /* Decide on an address space map region. */
             uintptr_t map_start, map_end;
             size_t map_size;
+            const size_t code_size = params.code_num_pages * PageSize;
             switch (params.flags & ams::svc::CreateProcessFlag_AddressSpaceMask) {
                 case ams::svc::CreateProcessFlag_AddressSpace32Bit:
                 case ams::svc::CreateProcessFlag_AddressSpace32BitWithoutAlias:
                     {
-                        map_start = KAddressSpaceInfo::GetAddressSpaceStart(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_MapSmall);
+                        map_start = KAddressSpaceInfo::GetAddressSpaceStart(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_MapSmall, code_size);
                         map_size  = KAddressSpaceInfo::GetAddressSpaceSize(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_MapSmall);
                         map_end   = map_start + map_size;
                     }
@@ -123,7 +124,7 @@ namespace ams::kern::svc {
                         /* 64-bit address space requires 64-bit process. */
                         R_UNLESS(is_64_bit, svc::ResultInvalidCombination());
 
-                        map_start = KAddressSpaceInfo::GetAddressSpaceStart(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_MapSmall);
+                        map_start = KAddressSpaceInfo::GetAddressSpaceStart(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_MapSmall, code_size);
                         map_size  = KAddressSpaceInfo::GetAddressSpaceSize(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_MapSmall);
                         map_end   = map_start + map_size;
                     }
@@ -133,7 +134,7 @@ namespace ams::kern::svc {
                         /* 64-bit address space requires 64-bit process. */
                         R_UNLESS(is_64_bit, svc::ResultInvalidCombination());
 
-                        map_start = KAddressSpaceInfo::GetAddressSpaceStart(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_Map39Bit);
+                        map_start = KAddressSpaceInfo::GetAddressSpaceStart(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_Map39Bit, code_size);
                         map_end   = map_start + KAddressSpaceInfo::GetAddressSpaceSize(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_Map39Bit);
 
                         map_size  = KAddressSpaceInfo::GetAddressSpaceSize(static_cast<ams::svc::CreateProcessFlag>(params.flags), KAddressSpaceInfo::Type_Heap);
@@ -181,7 +182,6 @@ namespace ams::kern::svc {
             const size_t code_num_pages            = params.code_num_pages;
             const size_t system_resource_num_pages = params.system_resource_num_pages;
             const size_t total_pages               = code_num_pages + system_resource_num_pages;
-            const size_t code_size                 = code_num_pages * PageSize;
             const size_t system_resource_size      = system_resource_num_pages * PageSize;
             const size_t total_size                = code_size + system_resource_size;
 

libraries/libstratosphere/include/stratosphere/ams/impl/ams_system_thread_definitions.hpp

@@ -171,6 +171,8 @@ namespace ams::impl {
     AMS_DEFINE_SYSTEM_THREAD(21, TioServer, FileServerHtcsServer);
     AMS_DEFINE_SYSTEM_THREAD(21, TioServer, SdCardObserver);
 
+    AMS_DEFINE_SYSTEM_THREAD(16, memlet, Main);
+
     /* ServiceProfile */
     AMS_DEFINE_SYSTEM_THREAD(-1, sprofile, IpcServer);
 

libraries/libstratosphere/include/stratosphere/erpt/erpt_ids.autogen.hpp

@@ -181,6 +181,13 @@
     HANDLER(NANDTypeInfoDeprecated,              140 ) \
     HANDLER(MicroSDTypeInfo,                     141 ) \
     HANDLER(AttachmentFileInfo,                  142 ) \
+    HANDLER(WlanInfo,                            143 ) \
+    HANDLER(HalfAwakeStateInfo,                  144 ) \
+    HANDLER(PctlSettingInfo,                     145 ) \
+    HANDLER(GameCardLogInfo,                     146 ) \
+    HANDLER(WlanIoctlErrorInfo,                  147 ) \
+    HANDLER(SdCardActivationInfo,                148 ) \
+    HANDLER(GameCardDetailedErrorInfo,           149 ) \
     HANDLER(TestNx,                              1000) \
     HANDLER(NANDTypeInfo,                        1001) \
     HANDLER(NANDExtendedCsd,                     1002) \
@@ -342,7 +349,7 @@
     HANDLER(TemperaturePcb,                                           153,  ThermalInfo,                         FieldType_NumericI32, FieldFlag_None   ) \
     HANDLER(TemperatureSoc,                                           154,  ThermalInfo,                         FieldType_NumericI32, FieldFlag_None   ) \
     HANDLER(CurrentFanDuty,                                           155,  ThermalInfo,                         FieldType_NumericI32, FieldFlag_None   ) \
-    HANDLER(LastDvfsThresholdTripped,                                 156,  ThermalInfo,                         FieldType_NumericI32, FieldFlag_None   ) \
+    HANDLER(LastDvfsThresholdTrippedDeprecated,                       156,  ThermalInfo,                         FieldType_NumericI32, FieldFlag_None   ) \
     HANDLER(CradlePdcHFwVersion,                                      157,  CradleFirmwareInfo,                  FieldType_NumericU32, FieldFlag_None   ) \
     HANDLER(CradlePdcAFwVersion,                                      158,  CradleFirmwareInfo,                  FieldType_NumericU32, FieldFlag_None   ) \
     HANDLER(CradleMcuFwVersion,                                       159,  CradleFirmwareInfo,                  FieldType_NumericU32, FieldFlag_None   ) \
@@ -448,7 +455,7 @@
     HANDLER(AdspExceptionStackAddressDeprecated,                      259,  AdspErrorInfo,                       FieldType_NumericU32, FieldFlag_None   ) \
     HANDLER(AdspExceptionStackDumpDeprecated,                         260,  AdspErrorInfo,                       FieldType_U32Array,   FieldFlag_None   ) \
     HANDLER(AdspExceptionReasonDeprecated,                            261,  AdspErrorInfo,                       FieldType_NumericU32, FieldFlag_None   ) \
-    HANDLER(OscillatorClock,                                          262,  PowerClockInfo,                      FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(OscillatorClockDeprecated,                                262,  PowerClockInfo,                      FieldType_NumericU32, FieldFlag_None   ) \
     HANDLER(CpuDvfsTableClocksDeprecated,                             263,  PowerClockInfo,                      FieldType_U32Array,   FieldFlag_None   ) \
     HANDLER(CpuDvfsTableVoltagesDeprecated,                           264,  PowerClockInfo,                      FieldType_I32Array,   FieldFlag_None   ) \
     HANDLER(GpuDvfsTableClocksDeprecated,                             265,  PowerClockInfo,                      FieldType_U32Array,   FieldFlag_None   ) \
@@ -456,8 +463,8 @@
     HANDLER(EmcDvfsTableClocksDeprecated,                             267,  PowerClockInfo,                      FieldType_U32Array,   FieldFlag_None   ) \
     HANDLER(EmcDvfsTableVoltagesDeprecated,                           268,  PowerClockInfo,                      FieldType_I32Array,   FieldFlag_None   ) \
     HANDLER(ModuleClockFrequencies,                                   269,  PowerClockInfo,                      FieldType_U32Array,   FieldFlag_None   ) \
-    HANDLER(ModuleClockEnableFlags,                                   270,  PowerClockInfo,                      FieldType_U8Array,    FieldFlag_None   ) \
-    HANDLER(ModulePowerEnableFlags,                                   271,  PowerClockInfo,                      FieldType_U8Array,    FieldFlag_None   ) \
+    HANDLER(ModuleClockEnableFlagsDeprecated,                         270,  PowerClockInfo,                      FieldType_U8Array,    FieldFlag_None   ) \
+    HANDLER(ModulePowerEnableFlagsDeprecated,                         271,  PowerClockInfo,                      FieldType_U8Array,    FieldFlag_None   ) \
     HANDLER(ModuleResetAssertFlags,                                   272,  PowerClockInfo,                      FieldType_U8Array,    FieldFlag_None   ) \
     HANDLER(ModuleMinimumVoltageClockRates,                           273,  PowerClockInfo,                      FieldType_U32Array,   FieldFlag_None   ) \
     HANDLER(PowerDomainEnableFlagsDeprecated,                         274,  PowerClockInfo,                      FieldType_U8Array,    FieldFlag_None   ) \
@@ -726,7 +733,7 @@
     HANDLER(EncryptedExceptionInfo2,                                  537,  ErrorInfo,                           FieldType_U8Array,    FieldFlag_None   ) \
     HANDLER(EncryptedExceptionInfo3,                                  538,  ErrorInfo,                           FieldType_U8Array,    FieldFlag_None   ) \
     HANDLER(EncryptedDyingMessage,                                    539,  ErrorInfo,                           FieldType_U8Array,    FieldFlag_None   ) \
-    HANDLER(DramId,                                                   540,  PowerClockInfo,                      FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(DramIdDeprecated,                                         540,  PowerClockInfo,                      FieldType_NumericU32, FieldFlag_None   ) \
     HANDLER(NifmConnectionTestRedirectUrl,                            541,  NifmConnectionTestInfo,              FieldType_String,     FieldFlag_None   ) \
     HANDLER(AcpRequiredNetworkServiceLicenseOnLaunchFlag,             542,  AcpUserAccountSettingsInfo,          FieldType_NumericU8,  FieldFlag_None   ) \
     HANDLER(PciePort0Flags,                                           543,  PcieLoggedStateInfo,                 FieldType_NumericU32, FieldFlag_None   ) \
@@ -881,6 +888,45 @@
     HANDLER(LastConnectionTestDownloadSpeed64,                        692,  ConnectionInfo,                      FieldType_NumericU64, FieldFlag_None   ) \
     HANDLER(LastConnectionTestUploadSpeed64,                          693,  ConnectionInfo,                      FieldType_NumericU64, FieldFlag_None   ) \
     HANDLER(EncryptionKeyV1,                                          694,  ErrorInfo,                           FieldType_U8Array,    FieldFlag_None   ) \
+    HANDLER(GpuCrashDumpAttachmentId,                                 695,  GpuCrashInfo,                        FieldType_U8Array,    FieldFlag_None   ) \
+    HANDLER(GpuCrashDumpIsAttached,                                   696,  AttachmentFileInfo,                  FieldType_Bool,       FieldFlag_None   ) \
+    HANDLER(CallerIdentifier,                                         697,  ErrorInfo,                           FieldType_NumericU64, FieldFlag_None   ) \
+    HANDLER(WlanMainState,                                            698,  WlanInfo,                            FieldType_NumericU8,  FieldFlag_None   ) \
+    HANDLER(WlanSubState,                                             699,  WlanInfo,                            FieldType_NumericU8,  FieldFlag_None   ) \
+    HANDLER(AdspSyslogIsAttached,                                     702,  AttachmentFileInfo,                  FieldType_Bool,       FieldFlag_None   ) \
+    HANDLER(LastHalfAwakeTime,                                        703,  HalfAwakeStateInfo,                  FieldType_NumericI64, FieldFlag_None   ) \
+    HANDLER(LastHalfAwakeTimeAfterBackgroundTaskDone,                 704,  HalfAwakeStateInfo,                  FieldType_NumericI64, FieldFlag_None   ) \
+    HANDLER(LastHalfAwakeTimeAfterStateUnlocked,                      705,  HalfAwakeStateInfo,                  FieldType_NumericI64, FieldFlag_None   ) \
+    HANDLER(LastHalfAwakePowerStateMessage,                           706,  HalfAwakeStateInfo,                  FieldType_NumericI32, FieldFlag_None   ) \
+    HANDLER(FastlyRequestId,                                          707,  ErrorInfo,                           FieldType_String,     FieldFlag_None   ) \
+    HANDLER(CloudflareCfRay,                                          708,  ErrorInfo,                           FieldType_String,     FieldFlag_None   ) \
+    HANDLER(WlanCommandEventHistory,                                  709,  WlanInfo,                            FieldType_U8Array,    FieldFlag_None   ) \
+    HANDLER(FsSaveDataAttributeCheckFailureCount,                     710,  FsProxyErrorInfo2,                   FieldType_NumericU8,  FieldFlag_None   ) \
+    HANDLER(PctlIsRestrictionEnabled,                                 711,  PctlSettingInfo,                     FieldType_Bool,       FieldFlag_None   ) \
+    HANDLER(PctlIsPairingActive,                                      712,  PctlSettingInfo,                     FieldType_Bool,       FieldFlag_None   ) \
+    HANDLER(PctlSafetyLevel,                                          713,  PctlSettingInfo,                     FieldType_NumericU8,  FieldFlag_None   ) \
+    HANDLER(PctlRatingAge,                                            714,  PctlSettingInfo,                     FieldType_NumericU8,  FieldFlag_None   ) \
+    HANDLER(PctlRatingOrganization,                                   715,  PctlSettingInfo,                     FieldType_NumericU8,  FieldFlag_None   ) \
+    HANDLER(PctlIsSnsPostRestricted,                                  716,  PctlSettingInfo,                     FieldType_Bool,       FieldFlag_None   ) \
+    HANDLER(PctlIsFreeCommunicationRestrictedByDefault,               717,  PctlSettingInfo,                     FieldType_Bool,       FieldFlag_None   ) \
+    HANDLER(PctlIsStereoVisionRestricted,                             718,  PctlSettingInfo,                     FieldType_Bool,       FieldFlag_None   ) \
+    HANDLER(PctlRestrictedFreeCommunicationApplicationIdList,         719,  PctlSettingInfo,                     FieldType_U64Array,   FieldFlag_None   ) \
+    HANDLER(PctlExemptApplicationIdList,                              720,  PctlSettingInfo,                     FieldType_U64Array,   FieldFlag_None   ) \
+    HANDLER(GameCardLogEncryptionKeyIndex,                            721,  GameCardLogInfo,                     FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(GameCardLogEncryptedKey,                                  722,  GameCardLogInfo,                     FieldType_U8Array,    FieldFlag_None   ) \
+    HANDLER(GameCardAsicHandlerLogLength,                             723,  GameCardLogInfo,                     FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(GameCardWorkerLogLength,                                  724,  GameCardLogInfo,                     FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(GameCardAsicHandlerLogTimeStamp,                          725,  GameCardLogInfo,                     FieldType_NumericI64, FieldFlag_None   ) \
+    HANDLER(GameCardWorkerLogTimeStamp,                               726,  GameCardLogInfo,                     FieldType_NumericI64, FieldFlag_None   ) \
+    HANDLER(GameCardEncryptedAsicHandlerLog,                          727,  GameCardLogInfo,                     FieldType_U8Array,    FieldFlag_None   ) \
+    HANDLER(GameCardEncryptedWorkerLog,                               728,  GameCardLogInfo,                     FieldType_U8Array,    FieldFlag_None   ) \
+    HANDLER(WlanIoctlErrno,                                           729,  ErrorInfo,                           FieldType_NumericI32, FieldFlag_None   ) \
+    HANDLER(FsSaveDataCertificateVerificationFailureCount,            730,  FsProxyErrorInfo2,                   FieldType_NumericU8,  FieldFlag_None   ) \
+    HANDLER(SdCardActivationMilliSeconds,                             731,  SdCardActivationInfo,                FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(GameCardLastAwakenFailureResult,                          732,  GameCardDetailedErrorInfo,           FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(GameCardInsertedTimestamp,                                733,  GameCardDetailedErrorInfo,           FieldType_NumericI64, FieldFlag_None   ) \
+    HANDLER(GameCardPreviousInsertedTimestamp,                        734,  GameCardDetailedErrorInfo,           FieldType_NumericI64, FieldFlag_None   ) \
+    HANDLER(WlanChipResetTriggered,                                   735,  WlanInfo,                            FieldType_Bool,       FieldFlag_None   ) \
     HANDLER(TestStringNx,                                             1000, TestNx,                              FieldType_String,     FieldFlag_None   ) \
     HANDLER(BoostModeCurrentLimit,                                    1001, BatteryChargeInfo,                   FieldType_NumericI32, FieldFlag_None   ) \
     HANDLER(ChargeConfiguration,                                      1002, BatteryChargeInfo,                   FieldType_NumericI32, FieldFlag_None   ) \
@@ -909,5 +955,10 @@
     HANDLER(BluetoothLePairingInfoCount,                              1025, BluetoothPairingCountInfo,           FieldType_NumericU8,  FieldFlag_None   ) \
     HANDLER(NANDPreEolInfo,                                           1026, NANDExtendedCsd,                     FieldType_NumericU32, FieldFlag_None   ) \
     HANDLER(NANDDeviceLifeTimeEstTypA,                                1027, NANDExtendedCsd,                     FieldType_NumericU32, FieldFlag_None   ) \
-    HANDLER(NANDDeviceLifeTimeEstTypB,                                1028, NANDExtendedCsd,                     FieldType_NumericU32, FieldFlag_None   )
+    HANDLER(NANDDeviceLifeTimeEstTypB,                                1028, NANDExtendedCsd,                     FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(OscillatorClock,                                          1029, PowerClockInfo,                      FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(DramId,                                                   1030, PowerClockInfo,                      FieldType_NumericU32, FieldFlag_None   ) \
+    HANDLER(LastDvfsThresholdTripped,                                 1031, ThermalInfo,                         FieldType_NumericI32, FieldFlag_None   ) \
+    HANDLER(ModuleClockEnableFlags,                                   1032, PowerClockInfo,                      FieldType_U8Array,    FieldFlag_None   ) \
+    HANDLER(ModulePowerEnableFlags,                                   1033, PowerClockInfo,                      FieldType_U8Array,    FieldFlag_None   ) \
 

libraries/libstratosphere/include/stratosphere/erpt/sf/erpt_sf_i_context.hpp

@@ -20,26 +20,28 @@
 #include <stratosphere/erpt/erpt_multiple_category_context.hpp>
 #include <stratosphere/time/time_steady_clock_time_point.hpp>
 
-#define AMS_ERPT_I_CONTEXT_INTERFACE_INFO(C, H)                                                                                                                                                                                                                                                                                                                                                                            \
-    AMS_SF_METHOD_INFO(C, H,  0, Result, SubmitContext,                             (const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer),                                                                                                                                     (ctx_buffer, str_buffer))                                                                                              \
-    AMS_SF_METHOD_INFO(C, H,  1, Result, CreateReportV0,                            (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer),                                                                 (report_type, ctx_buffer, str_buffer, meta_buffer))                                                                    \
-    AMS_SF_METHOD_INFO(C, H,  2, Result, SetInitialLaunchSettingsCompletionTime,    (const time::SteadyClockTimePoint &time_point),                                                                                                                                                                 (time_point),                                                                hos::Version_3_0_0)                       \
-    AMS_SF_METHOD_INFO(C, H,  3, Result, ClearInitialLaunchSettingsCompletionTime,  (),                                                                                                                                                                                                             (),                                                                          hos::Version_3_0_0)                       \
-    AMS_SF_METHOD_INFO(C, H,  4, Result, UpdatePowerOnTime,                         (),                                                                                                                                                                                                             (),                                                                          hos::Version_3_0_0)                       \
-    AMS_SF_METHOD_INFO(C, H,  5, Result, UpdateAwakeTime,                           (),                                                                                                                                                                                                             (),                                                                          hos::Version_3_0_0,  hos::Version_12_0_0) \
-    AMS_SF_METHOD_INFO(C, H,  6, Result, SubmitMultipleCategoryContext,             (const erpt::MultipleCategoryContextEntry &ctx_entry, const ams::sf::InBuffer &str_buffer),                                                                                                                     (ctx_entry, str_buffer),                                                     hos::Version_5_0_0,  hos::Version_12_0_0) \
-    AMS_SF_METHOD_INFO(C, H,  7, Result, UpdateApplicationLaunchTime,               (),                                                                                                                                                                                                             (),                                                                          hos::Version_6_0_0)                       \
-    AMS_SF_METHOD_INFO(C, H,  8, Result, ClearApplicationLaunchTime,                (),                                                                                                                                                                                                             (),                                                                          hos::Version_6_0_0)                       \
-    AMS_SF_METHOD_INFO(C, H,  9, Result, SubmitAttachment,                          (ams::sf::Out<erpt::AttachmentId> out, const ams::sf::InBuffer &attachment_name, const ams::sf::InBuffer &attachment_data),                                                                                     (out, attachment_name, attachment_data),                                     hos::Version_8_0_0)                       \
-    AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachmentsDeprecated,     (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer),                                                       (report_type, ctx_buffer, str_buffer, attachment_ids_buffer),                hos::Version_8_0_0,  hos::Version_10_2_0) \
-    AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachmentsDeprecated2,    (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer, Result result),                                        (report_type, ctx_buffer, str_buffer, attachment_ids_buffer, result),        hos::Version_11_0_0, hos::Version_16_1_0) \
-    AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachments,               (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer, Result result, erpt::CreateReportOptionFlagSet flags), (report_type, ctx_buffer, str_buffer, attachment_ids_buffer, result, flags), hos::Version_17_0_0)                      \
-    AMS_SF_METHOD_INFO(C, H, 11, Result, CreateReportV1,                            (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer, Result result),                                                  (report_type, ctx_buffer, str_buffer, meta_buffer, result),                  hos::Version_11_0_0)                      \
-    AMS_SF_METHOD_INFO(C, H, 12, Result, CreateReport,                              (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer, Result result, erpt::CreateReportOptionFlagSet flags),           (report_type, ctx_buffer, str_buffer, meta_buffer, result, flags),           hos::Version_17_0_0)                      \
-    AMS_SF_METHOD_INFO(C, H, 20, Result, RegisterRunningApplet,                     (ncm::ProgramId program_id),                                                                                                                                                                                    (program_id),                                                                hos::Version_12_0_0)                      \
-    AMS_SF_METHOD_INFO(C, H, 21, Result, UnregisterRunningApplet,                   (ncm::ProgramId program_id),                                                                                                                                                                                    (program_id),                                                                hos::Version_12_0_0)                      \
-    AMS_SF_METHOD_INFO(C, H, 22, Result, UpdateAppletSuspendedDuration,             (ncm::ProgramId program_id, TimeSpanType duration),                                                                                                                                                             (program_id, duration),                                                      hos::Version_12_0_0)                      \
-    AMS_SF_METHOD_INFO(C, H, 30, Result, InvalidateForcedShutdownDetection,         (),                                                                                                                                                                                                             (),                                                                          hos::Version_12_0_0)
+#define AMS_ERPT_I_CONTEXT_INTERFACE_INFO(C, H)                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+    AMS_SF_METHOD_INFO(C, H,  0, Result, SubmitContext,                             (const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer),                                                                                                                                                                                                            (ctx_buffer, str_buffer))                                                                                                                      \
+    AMS_SF_METHOD_INFO(C, H,  1, Result, CreateReportV0,                            (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer),                                                                                                                                        (report_type, ctx_buffer, str_buffer, meta_buffer))                                                                                            \
+    AMS_SF_METHOD_INFO(C, H,  2, Result, SetInitialLaunchSettingsCompletionTime,    (const time::SteadyClockTimePoint &time_point),                                                                                                                                                                                                                                        (time_point),                                                                                        hos::Version_3_0_0)                       \
+    AMS_SF_METHOD_INFO(C, H,  3, Result, ClearInitialLaunchSettingsCompletionTime,  (),                                                                                                                                                                                                                                                                                    (),                                                                                                  hos::Version_3_0_0)                       \
+    AMS_SF_METHOD_INFO(C, H,  4, Result, UpdatePowerOnTime,                         (),                                                                                                                                                                                                                                                                                    (),                                                                                                  hos::Version_3_0_0)                       \
+    AMS_SF_METHOD_INFO(C, H,  5, Result, UpdateAwakeTime,                           (),                                                                                                                                                                                                                                                                                    (),                                                                                                  hos::Version_3_0_0,  hos::Version_12_0_0) \
+    AMS_SF_METHOD_INFO(C, H,  6, Result, SubmitMultipleCategoryContext,             (const erpt::MultipleCategoryContextEntry &ctx_entry, const ams::sf::InBuffer &str_buffer),                                                                                                                                                                                            (ctx_entry, str_buffer),                                                                             hos::Version_5_0_0,  hos::Version_12_0_0) \
+    AMS_SF_METHOD_INFO(C, H,  7, Result, UpdateApplicationLaunchTime,               (),                                                                                                                                                                                                                                                                                    (),                                                                                                  hos::Version_6_0_0)                       \
+    AMS_SF_METHOD_INFO(C, H,  8, Result, ClearApplicationLaunchTime,                (),                                                                                                                                                                                                                                                                                    (),                                                                                                  hos::Version_6_0_0)                       \
+    AMS_SF_METHOD_INFO(C, H,  9, Result, SubmitAttachment,                          (ams::sf::Out<erpt::AttachmentId> out, const ams::sf::InBuffer &attachment_name, const ams::sf::InBuffer &attachment_data),                                                                                                                                                            (out, attachment_name, attachment_data),                                                             hos::Version_8_0_0)                       \
+    AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachmentsDeprecated,     (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer),                                                                                                                              (report_type, ctx_buffer, str_buffer, attachment_ids_buffer),                                        hos::Version_8_0_0,  hos::Version_10_2_0) \
+    AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachmentsDeprecated2,    (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer, Result result),                                                                                                               (report_type, ctx_buffer, str_buffer, attachment_ids_buffer, result),                                hos::Version_11_0_0, hos::Version_16_1_0) \
+    AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachments,               (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer, Result result, erpt::CreateReportOptionFlagSet flags),                                                                        (report_type, ctx_buffer, str_buffer, attachment_ids_buffer, result, flags),                         hos::Version_17_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 11, Result, CreateReportV1,                            (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer, Result result),                                                                                                                         (report_type, ctx_buffer, str_buffer, meta_buffer, result),                                          hos::Version_11_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 12, Result, CreateReport,                              (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer, Result result, erpt::CreateReportOptionFlagSet flags),                                                                                  (report_type, ctx_buffer, str_buffer, meta_buffer, result, flags),                                   hos::Version_17_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 13, Result, SubmitAttachmentWithLz4Compression,        (ams::sf::Out<erpt::AttachmentId> out, const ams::sf::InBuffer &attachment_name, const ams::sf::InBuffer &attachment_data),                                                                                                                                                            (out, attachment_name, attachment_data),                                                             hos::Version_20_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 14, Result, CreateReportWithSpecifiedReprotId,         (erpt::ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer, const ams::sf::InBuffer &attachment_ids_buffer, Result result, erpt::CreateReportOptionFlagSet flags, const erpt::ReportId &report_id), (report_type, ctx_buffer, str_buffer, meta_buffer, attachment_ids_buffer, result, flags, report_id), hos::Version_20_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 20, Result, RegisterRunningApplet,                     (ncm::ProgramId program_id),                                                                                                                                                                                                                                                           (program_id),                                                                                        hos::Version_12_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 21, Result, UnregisterRunningApplet,                   (ncm::ProgramId program_id),                                                                                                                                                                                                                                                           (program_id),                                                                                        hos::Version_12_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 22, Result, UpdateAppletSuspendedDuration,             (ncm::ProgramId program_id, TimeSpanType duration),                                                                                                                                                                                                                                    (program_id, duration),                                                                              hos::Version_12_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 30, Result, InvalidateForcedShutdownDetection,         (),                                                                                                                                                                                                                                                                                    (),                                                                                                  hos::Version_12_0_0)
 
 
 AMS_SF_DEFINE_INTERFACE(ams::erpt::sf, IContext, AMS_ERPT_I_CONTEXT_INTERFACE_INFO, 0xDD41DD03)

libraries/libstratosphere/include/stratosphere/erpt/sf/erpt_sf_i_manager.hpp

@@ -17,13 +17,16 @@
 #include <vapours.hpp>
 #include <stratosphere/erpt/erpt_types.hpp>
 
-#define AMS_ERPT_I_MANAGER_INTERFACE_INFO(C, H)                                                                                                                                        \
-    AMS_SF_METHOD_INFO(C, H,  0, Result, GetReportList,             (const ams::sf::OutBuffer &out_list, erpt::ReportType type_filter),   (out_list, type_filter))                     \
-    AMS_SF_METHOD_INFO(C, H,  1, Result, GetEvent,                  (ams::sf::OutCopyHandle out),                                         (out))                                       \
-    AMS_SF_METHOD_INFO(C, H,  2, Result, CleanupReports,            (),                                                                   (),                      hos::Version_4_0_0) \
-    AMS_SF_METHOD_INFO(C, H,  3, Result, DeleteReport,              (const erpt::ReportId &report_id),                                    (report_id),             hos::Version_5_0_0) \
-    AMS_SF_METHOD_INFO(C, H,  4, Result, GetStorageUsageStatistics, (ams::sf::Out<erpt::StorageUsageStatistics> out),                     (out),                   hos::Version_5_0_0) \
-    AMS_SF_METHOD_INFO(C, H,  5, Result, GetAttachmentList,         (const ams::sf::OutBuffer &out_buf, const erpt::ReportId &report_id), (out_buf, report_id),    hos::Version_8_0_0)
+#define AMS_ERPT_I_MANAGER_INTERFACE_INFO(C, H)                                                                                                                                                                                                     \
+    AMS_SF_METHOD_INFO(C, H,  0, Result, GetReportList,               (const ams::sf::OutBuffer &out_list, erpt::ReportType type_filter),                                (out_list, type_filter))                                                   \
+    AMS_SF_METHOD_INFO(C, H,  1, Result, GetEvent,                    (ams::sf::OutCopyHandle out),                                                                      (out))                                                                     \
+    AMS_SF_METHOD_INFO(C, H,  2, Result, CleanupReports,              (),                                                                                                (),                              hos::Version_4_0_0)                       \
+    AMS_SF_METHOD_INFO(C, H,  3, Result, DeleteReport,                (const erpt::ReportId &report_id),                                                                 (report_id),                     hos::Version_5_0_0)                       \
+    AMS_SF_METHOD_INFO(C, H,  4, Result, GetStorageUsageStatistics,   (ams::sf::Out<erpt::StorageUsageStatistics> out),                                                  (out),                           hos::Version_5_0_0)                       \
+    AMS_SF_METHOD_INFO(C, H,  5, Result, GetAttachmentListDeprecated, (const ams::sf::OutBuffer &out_buf, const erpt::ReportId &report_id),                              (out_buf, report_id),            hos::Version_8_0_0,  hos::Version_19_0_1) \
+    AMS_SF_METHOD_INFO(C, H,  6, Result, GetAttachmentList,           (ams::sf::Out<u32> out_count, const ams::sf::OutBuffer &out_buf, const erpt::ReportId &report_id), (out_count, out_buf, report_id), hos::Version_20_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 10, Result, GetReportSizeMax,            (ams::sf::Out<u32> out),                                                                           (out),                           hos::Version_20_0_0)
+
 
 
 AMS_SF_DEFINE_INTERFACE(ams::erpt::sf, IManager, AMS_ERPT_I_MANAGER_INTERFACE_INFO, 0x5CFCC43F)

libraries/libstratosphere/include/stratosphere/fs/fs_code.hpp

@@ -21,9 +21,9 @@
 namespace ams::fs {
 
     /* ACCURATE_TO_VERSION: 16.2.0.0 */
-    Result MountCode(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id);
+    Result MountCode(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id);
 
-    Result MountCodeForAtmosphereWithRedirection(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, bool is_hbl, bool is_specific);
-    Result MountCodeForAtmosphere(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id);
+    Result MountCodeForAtmosphereWithRedirection(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id, bool is_hbl, bool is_specific);
+    Result MountCodeForAtmosphere(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id);
 
 }

libraries/libstratosphere/include/stratosphere/fssrv/fssrv_file_system_proxy_impl.hpp

@@ -150,7 +150,8 @@ namespace ams::fssrv {
             Result OpenCodeFileSystemDeprecated(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const fssrv::sf::Path &path, ncm::ProgramId program_id);
             Result OpenCodeFileSystemDeprecated2(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, ams::sf::Out<fs::CodeVerificationData> out_verif, const fssrv::sf::Path &path, ncm::ProgramId program_id);
             Result OpenCodeFileSystemDeprecated3(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, ams::sf::Out<fs::CodeVerificationData> out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id);
-            Result OpenCodeFileSystem(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id);
+            Result OpenCodeFileSystemDeprecated4(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id);
+            Result OpenCodeFileSystem(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id);
             Result IsArchivedProgram(ams::sf::Out<bool> out, u64 process_id);
     };
     static_assert(sf::IsIFileSystemProxy<FileSystemProxyImpl>);
@@ -174,11 +175,16 @@ namespace ams::fssrv {
                 R_THROW(fs::ResultPortAcceptableCountLimited());
             }
 
-            Result OpenCodeFileSystem(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
+            Result OpenCodeFileSystemDeprecated4(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
                 AMS_UNUSED(out_fs, out_verif, path, attr, program_id);
                 R_THROW(fs::ResultPortAcceptableCountLimited());
             }
 
+            Result OpenCodeFileSystem(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id) {
+                AMS_UNUSED(out_fs, out_verif, attr, program_id, storage_id);
+                R_THROW(fs::ResultPortAcceptableCountLimited());
+            }
+
             Result IsArchivedProgram(ams::sf::Out<bool> out, u64 process_id) {
                 AMS_UNUSED(out, process_id);
                 R_THROW(fs::ResultPortAcceptableCountLimited());

libraries/libstratosphere/include/stratosphere/fssrv/sf/fssrv_sf_i_file_system_proxy_for_loader.hpp

@@ -21,12 +21,13 @@
 #include <stratosphere/fs/fs_content_attributes.hpp>
 
 /* ACCURATE_TO_VERSION: 17.5.0.0 */
-#define AMS_FSSRV_I_FILE_SYSTEM_PROXY_FOR_LOADER_INTERFACE_INFO(C, H)                                                                                                                                                                                                                                                                                                      \
-    AMS_SF_METHOD_INFO(C, H, 0, Result, OpenCodeFileSystemDeprecated,  (ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const fssrv::sf::Path &path, ncm::ProgramId program_id),                                                                               (out_fs, path, program_id),                  hos::Version_Min,    hos::Version_9_2_0)  \
-    AMS_SF_METHOD_INFO(C, H, 0, Result, OpenCodeFileSystemDeprecated2, (ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, ams::sf::Out<fs::CodeVerificationData> out_verif, const fssrv::sf::Path &path, ncm::ProgramId program_id),                             (out_fs, out_verif, path, program_id),       hos::Version_10_0_0, hos::Version_15_0_1) \
-    AMS_SF_METHOD_INFO(C, H, 0, Result, OpenCodeFileSystemDeprecated3, (ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, ams::sf::Out<fs::CodeVerificationData> out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id), (out_fs, out_verif, path, attr, program_id), hos::Version_16_0_0, hos::Version_16_1_0) \
-    AMS_SF_METHOD_INFO(C, H, 0, Result, OpenCodeFileSystem,            (ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id),              (out_fs, out_verif, path, attr, program_id), hos::Version_17_0_0)                      \
-    AMS_SF_METHOD_INFO(C, H, 1, Result, IsArchivedProgram,             (ams::sf::Out<bool> out, u64 process_id),                                                                                                                                                                    (out, process_id))                                                                     \
-    AMS_SF_METHOD_INFO(C, H, 2, Result, SetCurrentProcess,             (const ams::sf::ClientProcessId &client_pid),                                                                                                                                                                (client_pid),                                hos::Version_4_0_0)
+#define AMS_FSSRV_I_FILE_SYSTEM_PROXY_FOR_LOADER_INTERFACE_INFO(C, H)                                                                                                                                                                                                                                                                                                            \
+    AMS_SF_METHOD_INFO(C, H, 0, Result, OpenCodeFileSystemDeprecated,  (ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const fssrv::sf::Path &path, ncm::ProgramId program_id),                                                                               (out_fs, path, program_id),                        hos::Version_Min,    hos::Version_9_2_0)  \
+    AMS_SF_METHOD_INFO(C, H, 0, Result, OpenCodeFileSystemDeprecated2, (ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, ams::sf::Out<fs::CodeVerificationData> out_verif, const fssrv::sf::Path &path, ncm::ProgramId program_id),                             (out_fs, out_verif, path, program_id),             hos::Version_10_0_0, hos::Version_15_0_1) \
+    AMS_SF_METHOD_INFO(C, H, 0, Result, OpenCodeFileSystemDeprecated3, (ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, ams::sf::Out<fs::CodeVerificationData> out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id), (out_fs, out_verif, path, attr, program_id),       hos::Version_16_0_0, hos::Version_16_1_0) \
+    AMS_SF_METHOD_INFO(C, H, 0, Result, OpenCodeFileSystemDeprecated4, (ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id),              (out_fs, out_verif, path, attr, program_id),       hos::Version_17_0_0, hos::Version_19_0_1) \
+    AMS_SF_METHOD_INFO(C, H, 0, Result, OpenCodeFileSystem,            (ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id),                (out_fs, out_verif, attr, program_id, storage_id), hos::Version_20_0_0)                      \
+    AMS_SF_METHOD_INFO(C, H, 1, Result, IsArchivedProgram,             (ams::sf::Out<bool> out, u64 process_id),                                                                                                                                                                    (out, process_id))                                                                           \
+    AMS_SF_METHOD_INFO(C, H, 2, Result, SetCurrentProcess,             (const ams::sf::ClientProcessId &client_pid),                                                                                                                                                                (client_pid),                                      hos::Version_4_0_0)
 
 AMS_SF_DEFINE_INTERFACE(ams::fssrv::sf, IFileSystemProxyForLoader, AMS_FSSRV_I_FILE_SYSTEM_PROXY_FOR_LOADER_INTERFACE_INFO, 0xDC92EE15)

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

@@ -83,8 +83,17 @@ namespace ams::hos {
         Version_17_0_0  = ::ams::TargetFirmware_17_0_0,
         Version_17_0_1  = ::ams::TargetFirmware_17_0_1,
         Version_18_0_0  = ::ams::TargetFirmware_18_0_0,
+        Version_18_0_1  = ::ams::TargetFirmware_18_0_1,
         Version_18_1_0  = ::ams::TargetFirmware_18_1_0,
         Version_19_0_0  = ::ams::TargetFirmware_19_0_0,
+        Version_19_0_1  = ::ams::TargetFirmware_19_0_1,
+        Version_20_0_0  = ::ams::TargetFirmware_20_0_0,
+        Version_20_0_1  = ::ams::TargetFirmware_20_0_1,
+        Version_20_1_0  = ::ams::TargetFirmware_20_1_0,
+        Version_20_1_1  = ::ams::TargetFirmware_20_1_1,
+        Version_20_1_5  = ::ams::TargetFirmware_20_1_5,
+        Version_20_2_0  = ::ams::TargetFirmware_20_2_0,
+        Version_20_3_0  = ::ams::TargetFirmware_20_3_0,
 
         Version_Current = ::ams::TargetFirmware_Current,
 

libraries/libstratosphere/include/stratosphere/ldr/impl/ldr_process_manager_interface.hpp

@@ -19,14 +19,14 @@
 #include <stratosphere/ldr/ldr_types.hpp>
 #include <stratosphere/sf.hpp>
 
-#define AMS_LDR_I_PROCESS_MANAGER_INTERFACE_INTERFACE_INFO(C, H)                                                                                                                                                                                                \
-    AMS_SF_METHOD_INFO(C, H,     0, Result, CreateProcess,                    (sf::OutMoveHandle proc_h, ldr::PinId id, u32 flags, sf::CopyHandle &&reslimit_h),                                      (proc_h, id, flags, std::move(reslimit_h)))               \
-    AMS_SF_METHOD_INFO(C, H,     1, Result, GetProgramInfo,                   (sf::Out<ldr::ProgramInfo> out_program_info, const ncm::ProgramLocation &loc),                                          (out_program_info, loc))                                  \
-    AMS_SF_METHOD_INFO(C, H,     2, Result, PinProgram,                       (sf::Out<ldr::PinId> out_id, const ncm::ProgramLocation &loc),                                                          (out_id, loc))                                            \
-    AMS_SF_METHOD_INFO(C, H,     3, Result, UnpinProgram,                     (ldr::PinId id),                                                                                                        (id))                                                     \
-    AMS_SF_METHOD_INFO(C, H,     4, Result, SetEnabledProgramVerification,    (bool enabled),                                                                                                         (enabled),                           hos::Version_10_0_0) \
-    AMS_SF_METHOD_INFO(C, H, 65000, void,   AtmosphereHasLaunchedBootProgram, (sf::Out<bool> out, ncm::ProgramId program_id),                                                                         (out, program_id))                                        \
-    AMS_SF_METHOD_INFO(C, H, 65001, Result, AtmosphereGetProgramInfo,         (sf::Out<ldr::ProgramInfo> out_program_info, sf::Out<cfg::OverrideStatus> out_status, const ncm::ProgramLocation &loc), (out_program_info, out_status, loc))                      \
-    AMS_SF_METHOD_INFO(C, H, 65002, Result, AtmospherePinProgram,             (sf::Out<ldr::PinId> out_id, const ncm::ProgramLocation &loc, const cfg::OverrideStatus &override_status),              (out_id, loc, override_status))
+#define AMS_LDR_I_PROCESS_MANAGER_INTERFACE_INTERFACE_INFO(C, H)                                                                                                                                                                                                                                     \
+    AMS_SF_METHOD_INFO(C, H,     0, Result, CreateProcess,                    (sf::OutMoveHandle proc_h, ldr::PinId id, u32 flags, sf::CopyHandle &&reslimit_h, const ldr::ProgramAttributes &attrs),                                      (proc_h, id, flags, std::move(reslimit_h), attrs))        \
+    AMS_SF_METHOD_INFO(C, H,     1, Result, GetProgramInfo,                   (sf::Out<ldr::ProgramInfo> out_program_info, const ncm::ProgramLocation &loc, const ldr::ProgramAttributes &attrs),                                          (out_program_info, loc, attrs))                           \
+    AMS_SF_METHOD_INFO(C, H,     2, Result, PinProgram,                       (sf::Out<ldr::PinId> out_id, const ncm::ProgramLocation &loc),                                                                                               (out_id, loc))                                            \
+    AMS_SF_METHOD_INFO(C, H,     3, Result, UnpinProgram,                     (ldr::PinId id),                                                                                                                                             (id))                                                     \
+    AMS_SF_METHOD_INFO(C, H,     4, Result, SetEnabledProgramVerification,    (bool enabled),                                                                                                                                              (enabled),                           hos::Version_10_0_0) \
+    AMS_SF_METHOD_INFO(C, H, 65000, void,   AtmosphereHasLaunchedBootProgram, (sf::Out<bool> out, ncm::ProgramId program_id),                                                                                                              (out, program_id))                                        \
+    AMS_SF_METHOD_INFO(C, H, 65001, Result, AtmosphereGetProgramInfo,         (sf::Out<ldr::ProgramInfo> out_program_info, sf::Out<cfg::OverrideStatus> out_status, const ncm::ProgramLocation &loc, const ldr::ProgramAttributes &attrs), (out_program_info, out_status, loc, attrs))               \
+    AMS_SF_METHOD_INFO(C, H, 65002, Result, AtmospherePinProgram,             (sf::Out<ldr::PinId> out_id, const ncm::ProgramLocation &loc, const cfg::OverrideStatus &override_status),                                                   (out_id, loc, override_status))
 
 AMS_SF_DEFINE_INTERFACE(ams::ldr::impl, IProcessManagerInterface, AMS_LDR_I_PROCESS_MANAGER_INTERFACE_INTERFACE_INFO, 0x01518B8E)

libraries/libstratosphere/include/stratosphere/ldr/ldr_pm_api.hpp

@@ -20,15 +20,15 @@
 namespace ams::ldr::pm {
 
     /* Process Manager API. */
-    Result CreateProcess(os::NativeHandle *out, PinId pin_id, u32 flags, os::NativeHandle reslimit);
-    Result GetProgramInfo(ProgramInfo *out, const ncm::ProgramLocation &loc);
+    Result CreateProcess(os::NativeHandle *out, PinId pin_id, u32 flags, os::NativeHandle reslimit, ldr::ProgramAttributes attrs);
+    Result GetProgramInfo(ProgramInfo *out, const ncm::ProgramLocation &loc, ldr::ProgramAttributes attrs);
     Result PinProgram(PinId *out, const ncm::ProgramLocation &loc);
     Result UnpinProgram(PinId pin_id);
     Result SetEnabledProgramVerification(bool enabled);
     Result HasLaunchedBootProgram(bool *out, ncm::ProgramId program_id);
 
     /* Atmosphere extension API. */
-    Result AtmosphereGetProgramInfo(ProgramInfo *out, cfg::OverrideStatus *out_status, const ncm::ProgramLocation &loc);
+    Result AtmosphereGetProgramInfo(ProgramInfo *out, cfg::OverrideStatus *out_status, const ncm::ProgramLocation &loc, ldr::ProgramAttributes attrs);
     Result AtmospherePinProgram(PinId *out, const ncm::ProgramLocation &loc, const cfg::OverrideStatus &status);
 
 }

libraries/libstratosphere/include/stratosphere/ldr/ldr_types.hpp

@@ -20,6 +20,7 @@
 #include <stratosphere/ncm/ncm_program_location.hpp>
 #include <stratosphere/sf/sf_buffer_tags.hpp>
 #include <stratosphere/ncm/ncm_content_meta_platform.hpp>
+#include <stratosphere/fs/fs_content_attributes.hpp>
 
 namespace ams::ldr {
 
@@ -265,4 +266,10 @@ namespace ams::ldr {
     };
     static_assert(sizeof(Npdm) == 0x80 && util::is_pod<Npdm>::value, "Npdm definition!");
 
+    struct ProgramAttributes {
+        ncm::ContentMetaPlatform platform;
+        fs::ContentAttributes content_attributes;
+    };
+    static_assert(sizeof(ProgramAttributes) == 2 && util::is_pod<ProgramAttributes>::value, "ProgramAttributes definition!");
+
 }

libraries/libstratosphere/include/stratosphere/ncm/ncm_content_meta_database.hpp

@@ -226,6 +226,11 @@ namespace ams::ncm {
                 AMS_ASSERT(m_interface != nullptr);
                 R_RETURN(m_interface->GetPlatform(out, key));
             }
+
+            Result HasAttributes(u8 *out, u8 attr_mask) {
+                AMS_ASSERT(m_interface != nullptr);
+                R_RETURN(m_interface->HasAttributes(out, attr_mask));
+            }
     };
 
 }

libraries/libstratosphere/include/stratosphere/ncm/ncm_i_content_meta_database.hpp

@@ -44,7 +44,8 @@
     AMS_SF_METHOD_INFO(C, H, 23, Result, GetContentAccessibilities,       (sf::Out<u8> out_accessibilities, const ncm::ContentMetaKey &key),                                                                                                                                                                                (out_accessibilities, key),                                                                            hos::Version_15_0_0) \
     AMS_SF_METHOD_INFO(C, H, 24, Result, GetContentInfoByType,            (sf::Out<ncm::ContentInfo> out_content_info, const ncm::ContentMetaKey &key, ncm::ContentType type),                                                                                                                                              (out_content_info, key, type),                                                                         hos::Version_15_0_0) \
     AMS_SF_METHOD_INFO(C, H, 25, Result, GetContentInfoByTypeAndIdOffset, (sf::Out<ncm::ContentInfo> out_content_info, const ncm::ContentMetaKey &key, ncm::ContentType type, u8 id_offset),                                                                                                                                (out_content_info, key, type, id_offset),                                                              hos::Version_15_0_0) \
-    AMS_SF_METHOD_INFO(C, H, 26, Result, GetPlatform,                     (sf::Out<ncm::ContentMetaPlatform> out, const ncm::ContentMetaKey &key),                                                                                                                                                                          (out, key),                                                                                            hos::Version_17_0_0)
+    AMS_SF_METHOD_INFO(C, H, 26, Result, GetPlatform,                     (sf::Out<ncm::ContentMetaPlatform> out, const ncm::ContentMetaKey &key),                                                                                                                                                                          (out, key),                                                                                            hos::Version_17_0_0) \
+    AMS_SF_METHOD_INFO(C, H, 27, Result, HasAttributes,                   (sf::Out<u8> out, u8 attr_mask),                                                                                                                                                                                                                  (out, attr_mask),                                                                                      hos::Version_20_0_0)
 
 
 AMS_SF_DEFINE_INTERFACE(ams::ncm, IContentMetaDatabase, AMS_NCM_I_CONTENT_META_DATABASE_INTERFACE_INFO, 0x58021FEC)

libraries/libstratosphere/include/stratosphere/ncm/ncm_integrated_content_meta_database_impl.hpp

@@ -72,6 +72,7 @@ namespace ams::ncm {
             Result GetContentInfoByType(sf::Out<ContentInfo> out_content_info, const ContentMetaKey &key, ContentType type);
             Result GetContentInfoByTypeAndIdOffset(sf::Out<ContentInfo> out_content_info, const ContentMetaKey &key, ContentType type, u8 id_offset);
             Result GetPlatform(sf::Out<ncm::ContentMetaPlatform> out, const ContentMetaKey &key);
+            Result HasAttributes(sf::Out<u8> out, u8 attr_mask);
     };
     static_assert(ncm::IsIContentMetaDatabase<IntegratedContentMetaDatabaseImpl>);
 

libraries/libstratosphere/include/stratosphere/ncm/ncm_system_content_meta_id.hpp

@@ -121,13 +121,15 @@ namespace ams::ncm {
 
         static const AtmosphereProgramId Mitm;
         static const AtmosphereProgramId AtmosphereLogManager;
+        static const AtmosphereProgramId AtmosphereMemlet;
     };
 
     inline constexpr const AtmosphereProgramId AtmosphereProgramId::Mitm = { 0x010041544D530000ul };
     inline constexpr const AtmosphereProgramId AtmosphereProgramId::AtmosphereLogManager = { 0x0100000000000420ul };
+    inline constexpr const AtmosphereProgramId AtmosphereProgramId::AtmosphereMemlet = { 0x0100000000000421ul };
 
     inline constexpr bool IsAtmosphereProgramId(const ProgramId &program_id) {
-        return program_id == AtmosphereProgramId::Mitm || program_id == AtmosphereProgramId::AtmosphereLogManager;
+        return program_id == AtmosphereProgramId::Mitm || program_id == AtmosphereProgramId::AtmosphereLogManager || program_id == AtmosphereProgramId::AtmosphereMemlet;
     }
 
     inline constexpr bool IsSystemProgramId(const AtmosphereProgramId &) {

libraries/libstratosphere/source/boot2/boot2_api.board.nintendo_nx.cpp

@@ -450,6 +450,9 @@ namespace ams::boot2 {
             LaunchProgram(nullptr, ncm::ProgramLocation::Make(ncm::SystemProgramId::Migration, ncm::StorageId::BuiltInSystem), 0);
         }
 
+        /* Launch atmosphere's applet memory service program. */
+        LaunchProgram(nullptr, ncm::ProgramLocation::Make(ncm::AtmosphereProgramId::AtmosphereMemlet, ncm::StorageId::None), 0);
+
         /* Launch user programs off of the SD. */
         LaunchFlaggedProgramsOnSdCard();
     }

libraries/libstratosphere/source/erpt/srv/erpt_srv_context_impl.cpp

@@ -50,7 +50,7 @@ namespace ams::erpt::srv {
         R_UNLESS(ctx_size == sizeof(ContextEntry),                      erpt::ResultInvalidArgument());
         R_UNLESS(meta_size == 0 || meta_size == sizeof(ReportMetaData), erpt::ResultInvalidArgument());
 
-        R_TRY(Reporter::CreateReport(report_type, result, ctx, data, data_size, meta_size != 0 ? meta : nullptr, nullptr, 0, flags));
+        R_TRY(Reporter::CreateReport(report_type, result, ctx, data, data_size, meta_size != 0 ? meta : nullptr, nullptr, 0, flags, nullptr));
 
         ManagerImpl::NotifyAll();
 
@@ -142,6 +142,11 @@ namespace ams::erpt::srv {
         R_RETURN(JournalForAttachments::SubmitAttachment(out.GetPointer(), name_safe, data, data_size));
     }
 
+    Result ContextImpl::SubmitAttachmentWithLz4Compression(ams::sf::Out<AttachmentId> out, const ams::sf::InBuffer &attachment_name, const ams::sf::InBuffer &attachment_data) {
+        /* TODO: Implement LZ4 compression on attachments. */
+        R_RETURN(this->SubmitAttachment(out, attachment_name, attachment_data));
+    }
+
     Result ContextImpl::CreateReportWithAttachments(ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &data_buffer, const ams::sf::InBuffer &attachment_ids_buffer, Result result, erpt::CreateReportOptionFlagSet flags) {
         const ContextEntry *ctx  = reinterpret_cast<const ContextEntry *>( ctx_buffer.GetPointer());
         const           u8 *data = reinterpret_cast<const           u8 *>(data_buffer.GetPointer());
@@ -154,7 +159,7 @@ namespace ams::erpt::srv {
         R_UNLESS(ctx_size == sizeof(ContextEntry),           erpt::ResultInvalidArgument());
         R_UNLESS(num_attachments <= AttachmentsPerReportMax, erpt::ResultInvalidArgument());
 
-        R_TRY(Reporter::CreateReport(report_type, result, ctx, data, data_size, nullptr, attachments, num_attachments, flags));
+        R_TRY(Reporter::CreateReport(report_type, result, ctx, data, data_size, nullptr, attachments, num_attachments, flags, nullptr));
 
         ManagerImpl::NotifyAll();
 
@@ -169,6 +174,29 @@ namespace ams::erpt::srv {
         R_RETURN(this->CreateReportWithAttachmentsDeprecated2(report_type, ctx_buffer, data_buffer, attachment_ids_buffer, ResultSuccess()));
     }
 
+    Result ContextImpl::CreateReportWithSpecifiedReprotId(ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &data_buffer, const ams::sf::InBuffer &meta_buffer, const ams::sf::InBuffer &attachment_ids_buffer, Result result, erpt::CreateReportOptionFlagSet flags, const ReportId &report_id) {
+        const   ContextEntry *ctx  = reinterpret_cast<const   ContextEntry *>( ctx_buffer.GetPointer());
+        const             u8 *data = reinterpret_cast<const             u8 *>(data_buffer.GetPointer());
+        const ReportMetaData *meta = reinterpret_cast<const ReportMetaData *>(meta_buffer.GetPointer());
+
+        const u32 ctx_size  = static_cast<u32>(ctx_buffer.GetSize());
+        const u32 data_size = static_cast<u32>(data_buffer.GetSize());
+        const u32 meta_size = static_cast<u32>(meta_buffer.GetSize());
+
+        const AttachmentId *attachments = reinterpret_cast<const AttachmentId *>(attachment_ids_buffer.GetPointer());
+        const u32 num_attachments = attachment_ids_buffer.GetSize() / sizeof(*attachments);
+
+        R_UNLESS(ctx_size == sizeof(ContextEntry),                      erpt::ResultInvalidArgument());
+        R_UNLESS(meta_size == 0 || meta_size == sizeof(ReportMetaData), erpt::ResultInvalidArgument());
+        R_UNLESS(num_attachments <= AttachmentsPerReportMax,            erpt::ResultInvalidArgument());
+
+        R_TRY(Reporter::CreateReport(report_type, result, ctx, data, data_size, meta_size != 0 ? meta : nullptr, attachments, num_attachments, flags, std::addressof(report_id)));
+
+        ManagerImpl::NotifyAll();
+
+        R_SUCCEED();
+    }
+
     Result ContextImpl::RegisterRunningApplet(ncm::ProgramId program_id) {
         R_RETURN(Reporter::RegisterRunningApplet(program_id));
     }

libraries/libstratosphere/source/erpt/srv/erpt_srv_context_impl.hpp

@@ -35,6 +35,8 @@ namespace ams::erpt::srv {
             Result CreateReportWithAttachments(ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &data_buffer, const ams::sf::InBuffer &attachment_ids_buffer, Result result, erpt::CreateReportOptionFlagSet flags);
             Result CreateReportV1(ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &data_buffer, const ams::sf::InBuffer &meta_buffer, Result result);
             Result CreateReport(ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &data_buffer, const ams::sf::InBuffer &meta_buffer, Result result, erpt::CreateReportOptionFlagSet flags);
+            Result SubmitAttachmentWithLz4Compression(ams::sf::Out<AttachmentId> out, const ams::sf::InBuffer &attachment_name, const ams::sf::InBuffer &attachment_data);
+            Result CreateReportWithSpecifiedReprotId(ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &data_buffer, const ams::sf::InBuffer &meta_buffer, const ams::sf::InBuffer &attachment_data, Result result, erpt::CreateReportOptionFlagSet flags, const ReportId &report_id);
             Result RegisterRunningApplet(ncm::ProgramId program_id);
             Result UnregisterRunningApplet(ncm::ProgramId program_id);
             Result UpdateAppletSuspendedDuration(ncm::ProgramId program_id, TimeSpanType duration);

libraries/libstratosphere/source/erpt/srv/erpt_srv_forced_shutdown.cpp

@@ -86,7 +86,7 @@ namespace ams::erpt::srv {
             R_TRY(record->Add(FieldId_ErrorCode, error_code_str, std::strlen(error_code_str)));
 
             /* Create report. */
-            R_TRY(Reporter::CreateReport(ReportType_Invisible, ResultSuccess(), std::move(record), nullptr, nullptr, 0, erpt::srv::MakeNoCreateReportOptionFlags()));
+            R_TRY(Reporter::CreateReport(ReportType_Invisible, ResultSuccess(), std::move(record), nullptr, nullptr, 0, erpt::srv::MakeNoCreateReportOptionFlags(), nullptr));
 
             R_SUCCEED();
         }

libraries/libstratosphere/source/erpt/srv/erpt_srv_journal.cpp

@@ -51,8 +51,8 @@ namespace ams::erpt::srv {
         R_RETURN(JournalForReports::DeleteReport(report_id));
     }
 
-    Result Journal::GetAttachmentList(AttachmentList *out, ReportId report_id) {
-        R_RETURN(JournalForAttachments::GetAttachmentList(out, report_id));
+    Result Journal::GetAttachmentList(u32 *out_count, AttachmentInfo *out_infos, size_t max_out_infos, ReportId report_id) {
+        R_RETURN(JournalForAttachments::GetAttachmentList(out_count, out_infos, max_out_infos, report_id));
     }
 
     util::Uuid Journal::GetJournalId() {

libraries/libstratosphere/source/erpt/srv/erpt_srv_journal.hpp

@@ -82,7 +82,7 @@ namespace ams::erpt::srv {
             static void CleanupAttachments();
             static Result CommitJournal(Stream *stream);
             static Result DeleteAttachments(ReportId report_id);
-            static Result GetAttachmentList(AttachmentList *out, ReportId report_id);
+            static Result GetAttachmentList(u32 *out_count, AttachmentInfo *out_infos, size_t max_out_infos, ReportId report_id);
             static u32    GetUsedStorage();
             static Result RestoreJournal(Stream *stream);
 
@@ -99,7 +99,7 @@ namespace ams::erpt::srv {
             static void       CleanupReports();
             static Result     Commit();
             static Result     Delete(ReportId report_id);
-            static Result     GetAttachmentList(AttachmentList *out, ReportId report_id);
+            static Result     GetAttachmentList(u32 *out_count, AttachmentInfo *out_infos, size_t max_out_infos, ReportId report_id);
             static util::Uuid GetJournalId();
             static s64        GetMaxReportSize();
             static Result     GetReportList(ReportList *out, ReportType type_filter);

libraries/libstratosphere/source/erpt/srv/erpt_srv_journal_for_attachments.cpp

@@ -77,14 +77,19 @@ namespace ams::erpt::srv {
         R_SUCCEED();
     }
 
-    Result JournalForAttachments::GetAttachmentList(AttachmentList *out, ReportId report_id) {
+    Result JournalForAttachments::GetAttachmentList(u32 *out_count, AttachmentInfo *out_infos, size_t max_out_infos, ReportId report_id) {
+        if (hos::GetVersion() >= hos::Version_20_0_0) {
+            /* TODO: What define gives a minimum of 10? */
+            R_UNLESS(max_out_infos >= 10, erpt::ResultInvalidArgument());
+        }
+
         u32 count = 0;
-        for (auto it = s_attachment_list.cbegin(); it != s_attachment_list.cend() && count < util::size(out->attachments); it++) {
+        for (auto it = s_attachment_list.cbegin(); it != s_attachment_list.cend() && count < max_out_infos; it++) {
             if (report_id == it->m_info.owner_report_id) {
-                out->attachments[count++] = it->m_info;
+                out_infos[count++] = it->m_info;
             }
         }
-        out->attachment_count = count;
+        *out_count = count;
         R_SUCCEED();
     }
 

libraries/libstratosphere/source/erpt/srv/erpt_srv_manager_impl.cpp

@@ -86,10 +86,23 @@ namespace ams::erpt::srv {
         R_SUCCEED();
     }
 
-    Result ManagerImpl::GetAttachmentList(const ams::sf::OutBuffer &out_list, const ReportId &report_id) {
+    Result ManagerImpl::GetAttachmentListDeprecated(const ams::sf::OutBuffer &out_list, const ReportId &report_id) {
         R_UNLESS(out_list.GetSize() == sizeof(AttachmentList), erpt::ResultInvalidArgument());
 
-        R_RETURN(Journal::GetAttachmentList(reinterpret_cast<AttachmentList *>(out_list.GetPointer()), report_id));
+        auto *attachment_list = reinterpret_cast<AttachmentList *>(out_list.GetPointer());
+
+        R_RETURN(Journal::GetAttachmentList(std::addressof(attachment_list->attachment_count), attachment_list->attachments, util::size(attachment_list->attachments), report_id));
+    }
+
+    Result ManagerImpl::GetAttachmentList(ams::sf::Out<u32> out_count, const ams::sf::OutBuffer &out_buf, const ReportId &report_id) {
+        R_RETURN(Journal::GetAttachmentList(out_count.GetPointer(), reinterpret_cast<AttachmentInfo *>(out_buf.GetPointer()), out_buf.GetSize() / sizeof(AttachmentInfo), report_id));
+    }
+
+    Result ManagerImpl::GetReportSizeMax(ams::sf::Out<u32> out) {
+        /* TODO: Where is this size defined? */
+        constexpr size_t ReportSizeMax = 0x3FF4F;
+        *out = ReportSizeMax;
+        R_SUCCEED();
     }
 
 }

libraries/libstratosphere/source/erpt/srv/erpt_srv_manager_impl.hpp

@@ -34,7 +34,9 @@ namespace ams::erpt::srv {
             Result CleanupReports();
             Result DeleteReport(const ReportId &report_id);
             Result GetStorageUsageStatistics(ams::sf::Out<StorageUsageStatistics> out);
-            Result GetAttachmentList(const ams::sf::OutBuffer &out_buf, const ReportId &report_id);
+            Result GetAttachmentListDeprecated(const ams::sf::OutBuffer &out_buf, const ReportId &report_id);
+            Result GetAttachmentList(ams::sf::Out<u32> out_count, const ams::sf::OutBuffer &out_buf, const ReportId &report_id);
+            Result GetReportSizeMax(ams::sf::Out<u32> out);
     };
     static_assert(erpt::sf::IsIManager<ManagerImpl>);
 

libraries/libstratosphere/source/erpt/srv/erpt_srv_reporter.cpp

@@ -414,7 +414,7 @@ namespace ams::erpt::srv {
         R_SUCCEED();
     }
 
-    Result Reporter::CreateReport(ReportType type, Result ctx_result, const ContextEntry *ctx, const u8 *data, u32 data_size, const ReportMetaData *meta, const AttachmentId *attachments, u32 num_attachments, erpt::CreateReportOptionFlagSet flags) {
+    Result Reporter::CreateReport(ReportType type, Result ctx_result, const ContextEntry *ctx, const u8 *data, u32 data_size, const ReportMetaData *meta, const AttachmentId *attachments, u32 num_attachments, erpt::CreateReportOptionFlagSet flags, const ReportId *specified_report_id) {
         /* Create a context record for the report. */
         auto record = std::make_unique<ContextRecord>();
         R_UNLESS(record != nullptr, erpt::ResultOutOfMemory());
@@ -423,10 +423,10 @@ namespace ams::erpt::srv {
         R_TRY(record->Initialize(ctx, data, data_size));
 
         /* Create the report. */
-        R_RETURN(CreateReport(type, ctx_result, std::move(record), meta, attachments, num_attachments, flags));
+        R_RETURN(CreateReport(type, ctx_result, std::move(record), meta, attachments, num_attachments, flags, specified_report_id));
     }
 
-    Result Reporter::CreateReport(ReportType type, Result ctx_result, std::unique_ptr<ContextRecord> record, const ReportMetaData *meta, const AttachmentId *attachments, u32 num_attachments, erpt::CreateReportOptionFlagSet flags) {
+    Result Reporter::CreateReport(ReportType type, Result ctx_result, std::unique_ptr<ContextRecord> record, const ReportMetaData *meta, const AttachmentId *attachments, u32 num_attachments, erpt::CreateReportOptionFlagSet flags, const ReportId *specified_report_id) {
         /* Clear the automatic categories, when we're done with our report. */
         ON_SCOPE_EXIT {
             Context::ClearContext(CategoryId_ErrorInfo);
@@ -444,7 +444,7 @@ namespace ams::erpt::srv {
         R_TRY(SubmitReportDefaults(ctx));
 
         /* Generate report id. */
-        const ReportId report_id = { .uuid = util::GenerateUuid() };
+        const ReportId report_id = specified_report_id ? *specified_report_id : ReportId{ .uuid = util::GenerateUuid() };
 
         /* Get posix timestamps. */
         time::PosixTime timestamp_user;

libraries/libstratosphere/source/erpt/srv/erpt_srv_reporter.hpp

@@ -58,8 +58,8 @@ namespace ams::erpt::srv {
         private:
             static Result SubmitReportContexts(const ReportId &report_id, ReportType type, Result ctx_result, std::unique_ptr<ContextRecord> record, const time::PosixTime &user_timestamp, const time::PosixTime &network_timestamp, erpt::CreateReportOptionFlagSet flags);
         public:
-            static Result CreateReport(ReportType type, Result ctx_result, const ContextEntry *ctx, const u8 *data, u32 data_size, const ReportMetaData *meta, const AttachmentId *attachments, u32 num_attachments, erpt::CreateReportOptionFlagSet flags);
-            static Result CreateReport(ReportType type, Result ctx_result, std::unique_ptr<ContextRecord> record, const ReportMetaData *meta, const AttachmentId *attachments, u32 num_attachments, erpt::CreateReportOptionFlagSet flags);
+            static Result CreateReport(ReportType type, Result ctx_result, const ContextEntry *ctx, const u8 *data, u32 data_size, const ReportMetaData *meta, const AttachmentId *attachments, u32 num_attachments, erpt::CreateReportOptionFlagSet flags, const ReportId *specified_report_id);
+            static Result CreateReport(ReportType type, Result ctx_result, std::unique_ptr<ContextRecord> record, const ReportMetaData *meta, const AttachmentId *attachments, u32 num_attachments, erpt::CreateReportOptionFlagSet flags, const ReportId *specified_report_id);
     };
 
 }

libraries/libstratosphere/source/fs/fs_code.cpp

@@ -69,7 +69,7 @@ namespace ams::fs {
             return GetReference(g_stratosphere_romfs_fs);
         }
 
-        Result OpenCodeFileSystemImpl(CodeVerificationData *out_verification_data, std::unique_ptr<fsa::IFileSystem> *out, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
+        Result OpenCodeFileSystemImpl(CodeVerificationData *out_verification_data, std::unique_ptr<fsa::IFileSystem> *out, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id) {
             /* Print a path suitable for the remote service. */
             fssrv::sf::Path sf_path;
             R_TRY(FormatToFspPath(std::addressof(sf_path), "%s", path));
@@ -79,7 +79,11 @@ namespace ams::fs {
             R_TRY(fsp->SetCurrentProcess({}));
 
             sf::SharedPointer<fssrv::sf::IFileSystem> fs;
-            R_TRY(fsp->OpenCodeFileSystem(std::addressof(fs), ams::sf::OutBuffer(out_verification_data, sizeof(*out_verification_data)), sf_path, attr, program_id));
+            if (hos::GetVersion() >= hos::Version_20_0_0) {
+                R_TRY(fsp->OpenCodeFileSystem(std::addressof(fs), ams::sf::OutBuffer(out_verification_data, sizeof(*out_verification_data)), attr, program_id, storage_id));
+            } else {
+                R_TRY(fsp->OpenCodeFileSystemDeprecated4(std::addressof(fs), ams::sf::OutBuffer(out_verification_data, sizeof(*out_verification_data)), sf_path, attr, program_id));
+            }
 
             /* Allocate a new filesystem wrapper. */
             auto fsa = std::make_unique<impl::FileSystemServiceObjectAdapter>(std::move(fs));
@@ -148,7 +152,7 @@ namespace ams::fs {
             R_SUCCEED();
         }
 
-        Result OpenSdCardCodeOrStratosphereCodeOrCodeFileSystemImpl(CodeVerificationData *out_verification_data, std::unique_ptr<fsa::IFileSystem> *out, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
+        Result OpenSdCardCodeOrStratosphereCodeOrCodeFileSystemImpl(CodeVerificationData *out_verification_data, std::unique_ptr<fsa::IFileSystem> *out, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id) {
             /* If we can open an sd card code fs, use it. */
             R_SUCCEED_IF(R_SUCCEEDED(OpenSdCardCodeFileSystemImpl(out, program_id)));
 
@@ -156,7 +160,7 @@ namespace ams::fs {
             R_SUCCEED_IF(R_SUCCEEDED(OpenStratosphereCodeFileSystemImpl(out, program_id)));
 
             /* Otherwise, fall back to a normal code fs. */
-            R_RETURN(OpenCodeFileSystemImpl(out_verification_data, out, path, attr, program_id));
+            R_RETURN(OpenCodeFileSystemImpl(out_verification_data, out, path, attr, program_id, storage_id));
         }
 
         Result OpenHblCodeFileSystemImpl(std::unique_ptr<fsa::IFileSystem> *out) {
@@ -334,11 +338,12 @@ namespace ams::fs {
                 util::optional<SdCardRedirectionCodeFileSystem> m_code_fs;
                 util::optional<ReadOnlyFileSystem> m_hbl_fs;
                 ncm::ProgramId m_program_id;
+                ncm::StorageId m_storage_id;
                 bool m_initialized;
             public:
                 AtmosphereCodeFileSystem() : m_initialized(false) { /* ... */ }
 
-                Result Initialize(CodeVerificationData *out_verification_data, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, bool is_hbl, bool is_specific) {
+                Result Initialize(CodeVerificationData *out_verification_data, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id, bool is_hbl, bool is_specific) {
                     AMS_ABORT_UNLESS(!m_initialized);
 
                     /* If we're hbl, we need to open a hbl fs. */
@@ -350,10 +355,11 @@ namespace ams::fs {
 
                     /* Open the code filesystem. */
                     std::unique_ptr<fsa::IFileSystem> fsa;
-                    R_TRY(OpenSdCardCodeOrStratosphereCodeOrCodeFileSystemImpl(out_verification_data, std::addressof(fsa), path, attr, program_id));
+                    R_TRY(OpenSdCardCodeOrStratosphereCodeOrCodeFileSystemImpl(out_verification_data, std::addressof(fsa), path, attr, program_id, storage_id));
                     m_code_fs.emplace(std::move(fsa), program_id, is_specific);
 
-                    m_program_id = program_id;
+                    m_program_id  = program_id;
+                    m_storage_id  = storage_id;
                     m_initialized = true;
 
                     R_SUCCEED();
@@ -386,7 +392,7 @@ namespace ams::fs {
 
     }
 
-    Result MountCode(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
+    Result MountCode(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id) {
         auto mount_impl = [=]() -> Result {
             /* Clear the output. */
             std::memset(out, 0, sizeof(*out));
@@ -399,7 +405,7 @@ namespace ams::fs {
 
             /* Open the code file system. */
             std::unique_ptr<fsa::IFileSystem> fsa;
-            R_TRY(OpenCodeFileSystemImpl(out, std::addressof(fsa), path, attr, program_id));
+            R_TRY(OpenCodeFileSystemImpl(out, std::addressof(fsa), path, attr, program_id, storage_id));
 
             /* Register. */
             R_RETURN(fsa::Register(name, std::move(fsa)));
@@ -414,7 +420,7 @@ namespace ams::fs {
         R_SUCCEED();
     }
 
-    Result MountCodeForAtmosphereWithRedirection(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, bool is_hbl, bool is_specific) {
+    Result MountCodeForAtmosphereWithRedirection(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id, bool is_hbl, bool is_specific) {
         auto mount_impl = [=]() -> Result {
             /* Clear the output. */
             std::memset(out, 0, sizeof(*out));
@@ -430,7 +436,7 @@ namespace ams::fs {
             R_UNLESS(ams_code_fs != nullptr, fs::ResultAllocationMemoryFailedInCodeA());
 
             /* Initialize the code file system. */
-            R_TRY(ams_code_fs->Initialize(out, path, attr, program_id, is_hbl, is_specific));
+            R_TRY(ams_code_fs->Initialize(out, path, attr, program_id, storage_id, is_hbl, is_specific));
 
             /* Register. */
             R_RETURN(fsa::Register(name, std::move(ams_code_fs)));
@@ -445,7 +451,7 @@ namespace ams::fs {
         R_SUCCEED();
     }
 
-    Result MountCodeForAtmosphere(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
+    Result MountCodeForAtmosphere(CodeVerificationData *out, const char *name, const char *path, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id) {
         auto mount_impl = [=]() -> Result {
             /* Clear the output. */
             std::memset(out, 0, sizeof(*out));
@@ -458,7 +464,7 @@ namespace ams::fs {
 
             /* Open the code file system. */
             std::unique_ptr<fsa::IFileSystem> fsa;
-            R_TRY(OpenSdCardCodeOrStratosphereCodeOrCodeFileSystemImpl(out, std::addressof(fsa), path, attr, program_id));
+            R_TRY(OpenSdCardCodeOrStratosphereCodeOrCodeFileSystemImpl(out, std::addressof(fsa), path, attr, program_id, storage_id));
 
             /* Create a wrapper fs. */
             auto wrap_fsa = std::make_unique<SdCardRedirectionCodeFileSystem>(std::move(fsa), program_id, false);

libraries/libstratosphere/source/fs/fs_remote_file_system_proxy_for_loader.hpp

@@ -33,7 +33,7 @@ namespace ams::fs {
             Result OpenCodeFileSystemDeprecated(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const fssrv::sf::Path &path, ncm::ProgramId program_id) {
                 ::FsCodeInfo dummy;
                 ::FsFileSystem fs;
-                R_TRY(fsldrOpenCodeFileSystem(std::addressof(dummy), program_id.value, path.str, static_cast<::FsContentAttributes>(static_cast<u8>(fs::ContentAttributes_None)), std::addressof(fs)));
+                R_TRY(fsldrOpenCodeFileSystem(std::addressof(dummy), program_id.value, ::NcmStorageId_None, path.str, static_cast<::FsContentAttributes>(static_cast<u8>(fs::ContentAttributes_None)), std::addressof(fs)));
 
                 out_fs.SetValue(ObjectFactory::CreateSharedEmplaced<fssrv::sf::IFileSystem, fssrv::impl::RemoteFileSystem>(fs));
                 R_SUCCEED();
@@ -41,7 +41,7 @@ namespace ams::fs {
 
             Result OpenCodeFileSystemDeprecated2(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, ams::sf::Out<fs::CodeVerificationData> out_verif, const fssrv::sf::Path &path, ncm::ProgramId program_id) {
                 ::FsFileSystem fs;
-                R_TRY(fsldrOpenCodeFileSystem(reinterpret_cast<::FsCodeInfo *>(out_verif.GetPointer()), program_id.value, path.str, static_cast<::FsContentAttributes>(static_cast<u8>(fs::ContentAttributes_None)), std::addressof(fs)));
+                R_TRY(fsldrOpenCodeFileSystem(reinterpret_cast<::FsCodeInfo *>(out_verif.GetPointer()), program_id.value, ::NcmStorageId_None, path.str, static_cast<::FsContentAttributes>(static_cast<u8>(fs::ContentAttributes_None)), std::addressof(fs)));
 
                 out_fs.SetValue(ObjectFactory::CreateSharedEmplaced<fssrv::sf::IFileSystem, fssrv::impl::RemoteFileSystem>(fs));
                 R_SUCCEED();
@@ -49,15 +49,23 @@ namespace ams::fs {
 
             Result OpenCodeFileSystemDeprecated3(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, ams::sf::Out<fs::CodeVerificationData> out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
                 ::FsFileSystem fs;
-                R_TRY(fsldrOpenCodeFileSystem(reinterpret_cast<::FsCodeInfo *>(out_verif.GetPointer()), program_id.value, path.str, static_cast<::FsContentAttributes>(static_cast<u8>(attr)), std::addressof(fs)));
+                R_TRY(fsldrOpenCodeFileSystem(reinterpret_cast<::FsCodeInfo *>(out_verif.GetPointer()), program_id.value, ::NcmStorageId_None, path.str, static_cast<::FsContentAttributes>(static_cast<u8>(attr)), std::addressof(fs)));
 
                 out_fs.SetValue(ObjectFactory::CreateSharedEmplaced<fssrv::sf::IFileSystem, fssrv::impl::RemoteFileSystem>(fs));
                 R_SUCCEED();
             }
 
-            Result OpenCodeFileSystem(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
+            Result OpenCodeFileSystemDeprecated4(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
                 ::FsFileSystem fs;
-                R_TRY(fsldrOpenCodeFileSystem(reinterpret_cast<::FsCodeInfo *>(out_verif.GetPointer()), program_id.value, path.str, static_cast<::FsContentAttributes>(static_cast<u8>(attr)), std::addressof(fs)));
+                R_TRY(fsldrOpenCodeFileSystem(reinterpret_cast<::FsCodeInfo *>(out_verif.GetPointer()), program_id.value, ::NcmStorageId_None, path.str, static_cast<::FsContentAttributes>(static_cast<u8>(attr)), std::addressof(fs)));
+
+                out_fs.SetValue(ObjectFactory::CreateSharedEmplaced<fssrv::sf::IFileSystem, fssrv::impl::RemoteFileSystem>(fs));
+                R_SUCCEED();
+            }
+
+            Result OpenCodeFileSystem(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id) {
+                ::FsFileSystem fs;
+                R_TRY(fsldrOpenCodeFileSystem(reinterpret_cast<::FsCodeInfo *>(out_verif.GetPointer()), program_id.value, static_cast<::NcmStorageId>(static_cast<u8>(storage_id)), nullptr, static_cast<::FsContentAttributes>(static_cast<u8>(attr)), std::addressof(fs)));
 
                 out_fs.SetValue(ObjectFactory::CreateSharedEmplaced<fssrv::sf::IFileSystem, fssrv::impl::RemoteFileSystem>(fs));
                 R_SUCCEED();

libraries/libstratosphere/source/fs/impl/fs_id_string_impl.os.generic.cpp

@@ -21,7 +21,7 @@ namespace ams::fs::impl {
     #define ADD_ENUM_CASE(v) case v: return #v
 
     template<> const char *IdString::ToString<pkg1::KeyGeneration>(pkg1::KeyGeneration id) {
-        static_assert(pkg1::KeyGeneration_Current == pkg1::KeyGeneration_19_0_0);
+        static_assert(pkg1::KeyGeneration_Current == pkg1::KeyGeneration_20_0_0);
         switch (id) {
             using enum pkg1::KeyGeneration;
             case KeyGeneration_1_0_0:  return "1.0.0-2.3.0";
@@ -42,7 +42,8 @@ namespace ams::fs::impl {
             case KeyGeneration_16_0_0: return "16.0.0-16.0.3";
             case KeyGeneration_17_0_0: return "17.0.0-17.0.1";
             case KeyGeneration_18_0_0: return "18.0.0-18.1.0";
-            case KeyGeneration_19_0_0: return "19.0.0-";
+            case KeyGeneration_19_0_0: return "19.0.0-19.0.1";
+            case KeyGeneration_20_0_0: return "20.0.0-";
             default: return "Unknown";
         }
     }

libraries/libstratosphere/source/fssrv/fssrv_file_system_proxy_impl.cpp

@@ -482,11 +482,16 @@ namespace ams::fssrv {
         AMS_UNUSED(out_fs, out_verif, path, attr, program_id);
     }
 
-    Result FileSystemProxyImpl::OpenCodeFileSystem(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
+    Result FileSystemProxyImpl::OpenCodeFileSystemDeprecated4(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, const fssrv::sf::Path &path, fs::ContentAttributes attr, ncm::ProgramId program_id) {
         AMS_ABORT("TODO");
         AMS_UNUSED(out_fs, out_verif, path, attr, program_id);
     }
 
+    Result FileSystemProxyImpl::OpenCodeFileSystem(ams::sf::Out<ams::sf::SharedPointer<fssrv::sf::IFileSystem>> out_fs, const ams::sf::OutBuffer &out_verif, fs::ContentAttributes attr, ncm::ProgramId program_id, ncm::StorageId storage_id) {
+        AMS_ABORT("TODO");
+        AMS_UNUSED(out_fs, out_verif, attr, program_id, storage_id);
+    }
+
     Result FileSystemProxyImpl::IsArchivedProgram(ams::sf::Out<bool> out, u64 process_id) {
         AMS_ABORT("TODO");
         AMS_UNUSED(out, process_id);

libraries/libstratosphere/source/ldr/ldr_ams.os.horizon.c

@@ -32,8 +32,14 @@ Result ldrPmAtmosphereHasLaunchedBootProgram(bool *out, u64 program_id) {
     return _ldrAtmosphereHasLaunchedBootProgram(ldrPmGetServiceSession(), out, program_id);
 }
 
-Result ldrPmAtmosphereGetProgramInfo(LoaderProgramInfo *out_program_info, CfgOverrideStatus *out_status, const NcmProgramLocation *loc) {
-    return serviceDispatchInOut(ldrPmGetServiceSession(), 65001, *loc, *out_status,
+Result ldrPmAtmosphereGetProgramInfo(LoaderProgramInfo *out_program_info, CfgOverrideStatus *out_status, const NcmProgramLocation *loc, const LoaderProgramAttributes *attr) {
+    const struct {
+        LoaderProgramAttributes attr;
+        u16 pad1;
+        u32 pad2;
+        NcmProgramLocation loc;
+    } in = { *attr, 0, 0, *loc };
+    return serviceDispatchInOut(ldrPmGetServiceSession(), 65001, in, *out_status,
         .buffer_attrs = { SfBufferAttr_Out | SfBufferAttr_HipcPointer | SfBufferAttr_FixedSize },
         .buffers = { { out_program_info, sizeof(*out_program_info) } },
     );