pm: update for fsp-pr RegisterProgram api change

Starting in 20.0.0, the browser needs more applet memory to function, so we can't steal as much any more.
Thus, we now steal 14 MB on 20.0.0+ instead of 40MB.

However, since this reduces memory available for custom system modules, we are adjusting to compensate.
ams.mitm's heap size has been reduced from 32MB to 12MB (recovering 20MB).
In addition, fs.mitm now uses a new mechanism for stealing memory from the applet pool while romfs is being built.

On net, we are compromising:
    * Custom sysmodules lose memory available to them.
        On 19.0.0/AMS 1.8.0, there was 30 MB available for custom sysmodules.
        Stealing 14 MB instead of 40 MB, we lose 26 MB of that. Reducing ams.mitm's usage will gain us back 20.
        Nintendo also appears to...use 4 extra MB, in 20.0.0, from my test homebrew.
        So on 20.0.0/AMS 1.9.0, there should be 20 MB available for custom sysmodules.
        On the bright side, on <20.0.0/AMS 1.9.0, I guess there will be 50 MB available for custom sysmodules now?
    * totk mods will lose the ability to...put every file in the romfs on sd card. There will be some unknown maximum filecount for totk mods.
        On the bright side, implementing the transient memory stealing should improve compatibility for some mods which strictly add files?

README.md

@@ -4,7 +4,6 @@
 
 ![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.
 

atmosphere.mk

@@ -107,7 +107,7 @@ dist-no-debug: package3 $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
 	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
-	@PATH="$(DEVKITPRO)/tools/bin:$$PATH" build_romfs $(DIST_DIR)/stratosphere_romfs $(DIST_DIR)/atmosphere/stratosphere.romfs
+	@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
 	cp troposphere/daybreak/daybreak.nro $(DIST_DIR)/switch/daybreak.nro
@@ -117,7 +117,7 @@ dist-no-debug: package3 $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
 	cp fusee/$(ATMOSPHERE_BOOT_OUT_DIR)/fusee.bin $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/fusee.bin
 
 package3: emummc fusee stratosphere mesosphere exosphere troposphere
-	$(SILENTCMD)$(PYTHON) fusee/build_package3.py $(CURRENT_DIRECTORY) $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BOOT_OUT_DIR) $(ATMOSPHERE_GIT_HASH) $(ATMOSPHERE_MAJOR_VERSION) $(ATMOSPHERE_MINOR_VERSION) $(ATMOSPHERE_MICRO_VERSION) 0 $(ATMOSPHERE_SUPPORTED_HOS_MAJOR_VERSION) $(ATMOSPHERE_SUPPORTED_HOS_MINOR_VERSION) $(ATMOSPHERE_SUPPORTED_HOS_MICRO_VERSION) 0
+	@python fusee/build_package3.py $(CURRENT_DIRECTORY) $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BOOT_OUT_DIR) $(ATMOSPHERE_GIT_HASH) $(ATMOSPHERE_MAJOR_VERSION) $(ATMOSPHERE_MINOR_VERSION) $(ATMOSPHERE_MICRO_VERSION) 0 $(ATMOSPHERE_SUPPORTED_HOS_MAJOR_VERSION) $(ATMOSPHERE_SUPPORTED_HOS_MINOR_VERSION) $(ATMOSPHERE_SUPPORTED_HOS_MICRO_VERSION) 0
 	@echo "Built package3!"
 
 emummc:

config_templates/exosphere.ini

@@ -15,13 +15,6 @@
 #  Desc: Controls whether userland has access to the PMU registers.
 #  NOTE: It is unknown what effects this has on official code.
 
-# Key: enable_mem_mode, default: 0.
-#  Desc: Controls whether boot config memory mode is taken into account
-#   for retail units. This does not affect development units.
-#  NOTE: On retail units max ram size is capped to 4GB.
-#   Enabling this will use the boot config memory mode parameter,
-#   which by default is auto and size gets set based on physical size.
-
 # Key: blank_prodinfo_sysmmc, default: 0.
 #  Desc: Controls whether PRODINFO should be blanked in sysmmc.
 #   This will cause the system to see dummied out keys and
@@ -58,7 +51,6 @@ debugmode=1
 debugmode_user=0
 disable_user_exception_handlers=0
 enable_user_pmu_access=0
-enable_mem_mode=0
 blank_prodinfo_sysmmc=0
 blank_prodinfo_emummc=0
 allow_writing_to_cal_sysmmc=0

docs/changelog.md

@@ -1,77 +1,4 @@
 # Changelog
-## 1.11.1
-+ Basic support was added for 22.1.0.
-+ General system stability improvements to enhance the user's experience.
-## 1.11.0
-+ Support was added for 22.0.0.
-+ Special thanks to @alula for handling a large chunk of the necessary kernel, loader and erpt changes.
-  + The console should boot and atmosphère should be fully functional.
-  + **Please note**: A change in how applications/applets' lifespan is managed broke the homebrew ecosystem.
-    + All applications and applets are expected to perform a clean exit by calling the relevant IPC commands.
-    + Homebrew compiled with libnx and hbmenu itself explicitly avoid exiting so it can keep using the same process.
-      + Properly fixing this would require a re-design of how homebrew is launched and terminated.
-    + As a temporary solution, patches to the `am` sysmodule are now included which allow restoring the previous behavior and regain homebrew compatibility without any further changes.
-    + Nonetheless, please report any issues you may face when testing homebrew to ensure no edge cases have been missed.    
-  + `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.
-  + `erpt` was updated to reflect the latest official behavior.
-  + `pgl` was updated to fix a few issues.
-+ Support was added for memory modes above 4GB (thanks @CTCaer).
-+ A build time option to configure Joy-Con rails as UART for debugging was added (thanks @alula).
-+ General system stability improvements to enhance the user's experience.
-## 1.10.2
-+ Basic support was added for 21.2.0.
-+ General system stability improvements to enhance the user's experience.
-## 1.10.1
-+ Basic support was added for 21.1.0.
-+ A bug was fixed that caused some games (e.g. Tomb Raider definitive edition) to fail to launch.
-+ General system stability improvements to enhance the user's experience.
-## 1.10.0
-+ Basic support was added for 21.0.0.
-  + The console should boot and atmosphère should be fully functional.
-  + **Please note**: All homebrew software may need to be re-compiled with the latest libnx (>= 4.10.0), or else it may crash/experience memory corruption.
-    + Nintendo broke the userland<->kernel TLS ABI in 21.0.0, by writing to previously reserved space.
-    + Homebrew used this reserved space for its TLS slots, which means any homebrew software using TLS slots will experience memory corruption when running under Atmosphere 1.10.0.
-    + This doesn't appear to impact everything, but a large portion of tested homebrew crashes (often on exit), and so will need re-compile for the new ABI.
-      + For those technically inclined, while TLS slots are rarely used by developers, they're used to implement features like e.g. C++ exceptions under the hood, and so anything using those crashes, etc.
-    + To help make this transition easier, hbmenu now shows a warning when selecting homebrew compiled with an older, incompatible ABI version.
-      + I apologize for the hassle in general.
-      + libnx has been updated so that its reserved space matches Nintendo's now -- this particular issue can never occur again, even if Nintendo touches more reserved space.
-  + `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.
-  + `erpt` was updated to reflect the latest official behavior.
-  + `pgl` was updated to reflect the latest official behavior.
-  + `fatal` was updated to reflect the latest official behavior.
-+ Support was added for launching another game-which-has-too-many-files with romfs mods.
-  + I rely on user reports for adding support/fixing these, and some of these games can be pretty obscure!
-  + 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.
-    + Although some games may be impossible to fix, I believe I can get almost everything working, so please let me try to help you (and improve atmosphère's support!) if you run into this!
-+ General system stability improvements to enhance the user's experience.
-## 1.9.5
-+ Basic support was added for 20.5.0.
-+ General system stability improvements to enhance the user's experience.
-## 1.9.4
-+ Basic support was added for 20.4.0.
-+ An issue was fixed in `exosphère`'s register accessilibity tables (thanks @CTCaer).
-  + I believe this had no impact on official code, though it would have prevented some homebrew from interacting correctly with the MC0/MC1 registers.
-+ An issue was fixed that could cause a deadlock when building multiple romfs images simultaneously (thanks @Ereza).
-  + This fixes support for certain mods, e.g. system language translations overriding content for both overlayDisp and qlaunch.
-+ General system stability improvements to enhance the user's experience.
-## 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.

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()`.
 
-+ 00000000 00000001: A
++ 000000001: A
-+ 00000000 00000002: B
++ 000000002: B
-+ 00000000 00000004: X
++ 000000004: X
-+ 00000000 00000008: Y
++ 000000008: Y
-+ 00000000 00000010: Left Stick Pressed
++ 000000010: Left Stick Pressed
-+ 00000000 00000020: Right Stick Pressed
++ 000000020: Right Stick Pressed
-+ 00000000 00000040: L
++ 000000040: L
-+ 00000000 00000080: R
++ 000000080: R
-+ 00000000 00000100: ZL
++ 000000100: ZL
-+ 00000000 00000200: ZR
++ 000000200: ZR
-+ 00000000 00000400: Plus
++ 000000400: Plus
-+ 00000000 00000800: Minus
++ 000000800: Minus
-+ 00000000 00001000: Left
++ 000001000: Left
-+ 00000000 00002000: Up
++ 000002000: Up
-+ 00000000 00004000: Right
++ 000004000: Right
-+ 00000000 00008000: Down
++ 000008000: Down
-+ 00000000 00010000: Left Stick Left
++ 000010000: Left Stick Left
-+ 00000000 00020000: Left Stick Up
++ 000020000: Left Stick Up
-+ 00000000 00040000: Left Stick Right
++ 000040000: Left Stick Right
-+ 00000000 00080000: Left Stick Down
++ 000080000: Left Stick Down
-+ 00000000 00100000: Right Stick Left
++ 000100000: Right Stick Left
-+ 00000000 00200000: Right Stick Up
++ 000200000: Right Stick Up
-+ 00000000 00400000: Right Stick Right
++ 000400000: Right Stick Right
-+ 00000000 00800000: Right Stick Down
++ 000800000: Right Stick Down
-+ 00000000 01000000: SL Left Joy-Con
++ 001000000: SL Left Joy-Con
-+ 00000000 02000000: SR Left Joy-Con
++ 002000000: SR Left Joy-Con
-+ 00000000 04000000: SL Right Joy-Con
++ 004000000: SL Right Joy-Con
-+ 00000000 08000000: SR Right Joy-Con
++ 008000000: SR Right Joy-Con
-+ 00000000 10000000: Top button on Poké Ball Plus (Palma) controller
++ 010000000: Top button on Poké Ball Plus (Palma) controller
-+ 00000000 20000000: Verification
++ 020000000: Verification
-+ 00000000 40000000: B button on Left NES/HVC controller in Handheld mode
++ 040000000: B button on Left NES/HVC controller in Handheld mode
-+ 00000000 80000000: Left C button in N64 controller
++ 080000000: Left C button in N64 controller
-+ 00000001 00000000: Up C button in N64 controller
++ 100000000: Up C button in N64 controller
-+ 00000002 00000000: Right C button in N64 controller
++ 200000000: Right C button in N64 controller
-+ 00000004 00000000: Down C button in N64 controller
++ 400000000: 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 = 3726bfd659600cdafd138277054568a3edba60a6
+	commit = d248ea6f700c3e6987549e30a1e2eeb609ce9f8c
-	parent = 80bd459516e813fc6f10268ca31dd72a053a4ef3
+	parent = 9112461620330ba73a74926edd4c08b3cc0310f0
 	method = merge
-	cmdver = 0.4.9
+	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 - 21.2.0**
+**1.0.0 - 20.0.0**
 
 ## Features
 * Arbitrary SDMMC backend selection  

emummc/source/FS/FS_offsets.c

@@ -77,14 +77,6 @@
 #include "offsets/1900_exfat.h"
 #include "offsets/2000.h"
 #include "offsets/2000_exfat.h"
-#include "offsets/2010.h"
-#include "offsets/2010_exfat.h"
-#include "offsets/2100.h"
-#include "offsets/2100_exfat.h"
-#include "offsets/2120.h"
-#include "offsets/2120_exfat.h"
-#include "offsets/2200.h"
-#include "offsets/2200_exfat.h"
 #include "../utils/fatal.h"
 
 #define GET_OFFSET_STRUCT_NAME(vers) g_offsets##vers
@@ -173,14 +165,6 @@ 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);
-DEFINE_OFFSET_STRUCT(_2100);
-DEFINE_OFFSET_STRUCT(_2100_EXFAT);
-DEFINE_OFFSET_STRUCT(_2120);
-DEFINE_OFFSET_STRUCT(_2120_EXFAT);
-DEFINE_OFFSET_STRUCT(_2200);
-DEFINE_OFFSET_STRUCT(_2200_EXFAT);
 
 const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
     switch (version) {
@@ -306,22 +290,6 @@ const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
             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));
-        case FS_VER_21_0_0:
-            return &(GET_OFFSET_STRUCT_NAME(_2100));
-        case FS_VER_21_0_0_EXFAT:
-            return &(GET_OFFSET_STRUCT_NAME(_2100_EXFAT));
-        case FS_VER_21_2_0:
-            return &(GET_OFFSET_STRUCT_NAME(_2120));
-        case FS_VER_21_2_0_EXFAT:
-            return &(GET_OFFSET_STRUCT_NAME(_2120_EXFAT));
-        case FS_VER_22_0_0:
-            return &(GET_OFFSET_STRUCT_NAME(_2200));
-        case FS_VER_22_0_0_EXFAT:
-            return &(GET_OFFSET_STRUCT_NAME(_2200_EXFAT));
         default:
             fatal_abort(Fatal_UnknownVersion);
     }

emummc/source/FS/FS_versions.h

@@ -113,18 +113,6 @@ enum FS_VER
     FS_VER_20_0_0,
     FS_VER_20_0_0_EXFAT,
 
-    FS_VER_20_1_0,
-    FS_VER_20_1_0_EXFAT,
-
-    FS_VER_21_0_0,
-    FS_VER_21_0_0_EXFAT,
-
-    FS_VER_21_2_0,
-    FS_VER_21_2_0_EXFAT,
-
-    FS_VER_22_0_0,
-    FS_VER_22_0_0_EXFAT,
-
     FS_VER_MAX,
 };
 

emummc/source/FS/offsets/2010.h

@@ -1,59 +0,0 @@
-/*
- * 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

@@ -1,59 +0,0 @@
-/*
- * 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__

emummc/source/FS/offsets/2100.h

@@ -1,59 +0,0 @@
-/*
- * 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_2100_H__
-#define __FS_2100_H__
-
-// Accessor vtable getters
-#define FS_OFFSET_2100_SDMMC_ACCESSOR_GC   0x1AC970
-#define FS_OFFSET_2100_SDMMC_ACCESSOR_SD   0x1AE980
-#define FS_OFFSET_2100_SDMMC_ACCESSOR_NAND 0x1ACFA0
-
-// Hooks
-#define FS_OFFSET_2100_SDMMC_WRAPPER_READ  0x1A8850
-#define FS_OFFSET_2100_SDMMC_WRAPPER_WRITE 0x1A88B0
-#define FS_OFFSET_2100_RTLD                0x2E1C0
-#define FS_OFFSET_2100_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
-
-#define FS_OFFSET_2100_CLKRST_SET_MIN_V_CLK_RATE 0x1CB9B0
-
-// Misc funcs
-#define FS_OFFSET_2100_LOCK_MUTEX          0x1A17D0
-#define FS_OFFSET_2100_UNLOCK_MUTEX        0x1A1830
-
-#define FS_OFFSET_2100_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1A8810
-#define FS_OFFSET_2100_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1A8830
-
-// Misc Data
-#define FS_OFFSET_2100_SD_MUTEX            0xFEE408
-#define FS_OFFSET_2100_NAND_MUTEX          0xFE9CF0
-#define FS_OFFSET_2100_ACTIVE_PARTITION    0xFE9D30
-#define FS_OFFSET_2100_SDMMC_DAS_HANDLE    0xFCBB18
-
-// NOPs
-#define FS_OFFSET_2100_SD_DAS_INIT         0x2B5C8
-
-// Nintendo Paths
-#define FS_OFFSET_2100_NINTENDO_PATHS \
-{ \
-	{.opcode_reg = 3, .adrp_offset = 0x000718CC, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 3, .adrp_offset = 0x000824F4, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 4, .adrp_offset = 0x0008AF18, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 4, .adrp_offset = 0x000A0B8C, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
-}
-
-#endif // __FS_2100_H__

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

@@ -1,59 +0,0 @@
-/*
- * 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_2100_EXFAT_EXFAT_H__
-#define __FS_2100_EXFAT_EXFAT_H__
-
-// Accessor vtable getters
-#define FS_OFFSET_2100_EXFAT_SDMMC_ACCESSOR_GC   0x1B7AD0
-#define FS_OFFSET_2100_EXFAT_SDMMC_ACCESSOR_SD   0x1B9AE0
-#define FS_OFFSET_2100_EXFAT_SDMMC_ACCESSOR_NAND 0x1B8100
-
-// Hooks
-#define FS_OFFSET_2100_EXFAT_SDMMC_WRAPPER_READ  0x1B39B0
-#define FS_OFFSET_2100_EXFAT_SDMMC_WRAPPER_WRITE 0x1B3A10
-#define FS_OFFSET_2100_EXFAT_RTLD                0x2E1C0
-#define FS_OFFSET_2100_EXFAT_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
-
-#define FS_OFFSET_2100_EXFAT_CLKRST_SET_MIN_V_CLK_RATE 0x1D6B10
-
-// Misc funcs
-#define FS_OFFSET_2100_EXFAT_LOCK_MUTEX          0x1AC930
-#define FS_OFFSET_2100_EXFAT_UNLOCK_MUTEX        0x1AC990
-
-#define FS_OFFSET_2100_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1B3970
-#define FS_OFFSET_2100_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1B3990
-
-// Misc Data
-#define FS_OFFSET_2100_EXFAT_SD_MUTEX            0xFFF408
-#define FS_OFFSET_2100_EXFAT_NAND_MUTEX          0xFFACF0
-#define FS_OFFSET_2100_EXFAT_ACTIVE_PARTITION    0xFFAD30
-#define FS_OFFSET_2100_EXFAT_SDMMC_DAS_HANDLE    0xFD8B18
-
-// NOPs
-#define FS_OFFSET_2100_EXFAT_SD_DAS_INIT         0x2B5C8
-
-// Nintendo Paths
-#define FS_OFFSET_2100_EXFAT_NINTENDO_PATHS \
-{ \
-	{.opcode_reg = 3, .adrp_offset = 0x000718CC, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 3, .adrp_offset = 0x000824F4, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 4, .adrp_offset = 0x0008AF18, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 4, .adrp_offset = 0x000A0B8C, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
-}
-
-#endif // __FS_2100_EXFAT_EXFAT_H__

emummc/source/FS/offsets/2120.h

@@ -1,59 +0,0 @@
-/*
- * 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_2120_H__
-#define __FS_2120_H__
-
-// Accessor vtable getters
-#define FS_OFFSET_2120_SDMMC_ACCESSOR_GC   0x1AC970
-#define FS_OFFSET_2120_SDMMC_ACCESSOR_SD   0x1AE980
-#define FS_OFFSET_2120_SDMMC_ACCESSOR_NAND 0x1ACFA0
-
-// Hooks
-#define FS_OFFSET_2120_SDMMC_WRAPPER_READ  0x1A8850
-#define FS_OFFSET_2120_SDMMC_WRAPPER_WRITE 0x1A88B0
-#define FS_OFFSET_2120_RTLD                0x2E1C0
-#define FS_OFFSET_2120_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
-
-#define FS_OFFSET_2120_CLKRST_SET_MIN_V_CLK_RATE 0x1CB9B0
-
-// Misc funcs
-#define FS_OFFSET_2120_LOCK_MUTEX          0x1A17D0
-#define FS_OFFSET_2120_UNLOCK_MUTEX        0x1A1830
-
-#define FS_OFFSET_2120_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1A8810
-#define FS_OFFSET_2120_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1A8830
-
-// Misc Data
-#define FS_OFFSET_2120_SD_MUTEX            0xFEE408
-#define FS_OFFSET_2120_NAND_MUTEX          0xFE9CF0
-#define FS_OFFSET_2120_ACTIVE_PARTITION    0xFE9D30
-#define FS_OFFSET_2120_SDMMC_DAS_HANDLE    0xFCBB18
-
-// NOPs
-#define FS_OFFSET_2120_SD_DAS_INIT         0x2B5C8
-
-// Nintendo Paths
-#define FS_OFFSET_2120_NINTENDO_PATHS \
-{ \
-	{.opcode_reg = 3, .adrp_offset = 0x000718CC, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 3, .adrp_offset = 0x000824F4, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 4, .adrp_offset = 0x0008AF18, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 4, .adrp_offset = 0x000A0B8C, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
-}
-
-#endif // __FS_2120_H__

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

@@ -1,59 +0,0 @@
-/*
- * 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_2120_EXFAT_EXFAT_H__
-#define __FS_2120_EXFAT_EXFAT_H__
-
-// Accessor vtable getters
-#define FS_OFFSET_2120_EXFAT_SDMMC_ACCESSOR_GC   0x1B7AD0
-#define FS_OFFSET_2120_EXFAT_SDMMC_ACCESSOR_SD   0x1B9AE0
-#define FS_OFFSET_2120_EXFAT_SDMMC_ACCESSOR_NAND 0x1B8100
-
-// Hooks
-#define FS_OFFSET_2120_EXFAT_SDMMC_WRAPPER_READ  0x1B39B0
-#define FS_OFFSET_2120_EXFAT_SDMMC_WRAPPER_WRITE 0x1B3A10
-#define FS_OFFSET_2120_EXFAT_RTLD                0x2E1C0
-#define FS_OFFSET_2120_EXFAT_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
-
-#define FS_OFFSET_2120_EXFAT_CLKRST_SET_MIN_V_CLK_RATE 0x1D6B10
-
-// Misc funcs
-#define FS_OFFSET_2120_EXFAT_LOCK_MUTEX          0x1AC930
-#define FS_OFFSET_2120_EXFAT_UNLOCK_MUTEX        0x1AC990
-
-#define FS_OFFSET_2120_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1B3970
-#define FS_OFFSET_2120_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1B3990
-
-// Misc Data
-#define FS_OFFSET_2120_EXFAT_SD_MUTEX            0xFFF408
-#define FS_OFFSET_2120_EXFAT_NAND_MUTEX          0xFFACF0
-#define FS_OFFSET_2120_EXFAT_ACTIVE_PARTITION    0xFFAD30
-#define FS_OFFSET_2120_EXFAT_SDMMC_DAS_HANDLE    0xFD8B18
-
-// NOPs
-#define FS_OFFSET_2120_EXFAT_SD_DAS_INIT         0x2B5C8
-
-// Nintendo Paths
-#define FS_OFFSET_2120_EXFAT_NINTENDO_PATHS \
-{ \
-	{.opcode_reg = 3, .adrp_offset = 0x000718CC, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 3, .adrp_offset = 0x000824F4, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 4, .adrp_offset = 0x0008AF18, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 4, .adrp_offset = 0x000A0B8C, .add_rel_offset = 0x00000004}, \
-	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
-}
-
-#endif // __FS_2120_EXFAT_EXFAT_H__

emummc/source/FS/offsets/2200.h

@@ -1,59 +0,0 @@
-/*
- * 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_2200_H__
-#define __FS_2200_H__
-
-// Accessor vtable getters
-#define FS_OFFSET_2200_SDMMC_ACCESSOR_GC   0x1B01C0
-#define FS_OFFSET_2200_SDMMC_ACCESSOR_SD   0x1B21C0
-#define FS_OFFSET_2200_SDMMC_ACCESSOR_NAND 0x1B07F0
-
-// Hooks
-#define FS_OFFSET_2200_SDMMC_WRAPPER_READ  0x1AC0F0
-#define FS_OFFSET_2200_SDMMC_WRAPPER_WRITE 0x1AC150
-#define FS_OFFSET_2200_RTLD                0x2DED0
-#define FS_OFFSET_2200_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
-
-#define FS_OFFSET_2200_CLKRST_SET_MIN_V_CLK_RATE 0x1CF260
-
-// Misc funcs
-#define FS_OFFSET_2200_LOCK_MUTEX          0x1A4EF0
-#define FS_OFFSET_2200_UNLOCK_MUTEX        0x1A4F40
-
-#define FS_OFFSET_2200_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1AC0B0
-#define FS_OFFSET_2200_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1AC0D0
-
-// Misc Data
-#define FS_OFFSET_2200_SD_MUTEX            0xFF1408
-#define FS_OFFSET_2200_NAND_MUTEX          0xFECD00
-#define FS_OFFSET_2200_ACTIVE_PARTITION    0xFECD40
-#define FS_OFFSET_2200_SDMMC_DAS_HANDLE    0xFCEB98
-
-// NOPs
-#define FS_OFFSET_2200_SD_DAS_INIT         0x2B438
-
-// Nintendo Paths
-#define FS_OFFSET_2200_NINTENDO_PATHS \
-{ \
-    {.opcode_reg = 3, .adrp_offset = 0x000715EC, .add_rel_offset = 0x00000004}, \
-    {.opcode_reg = 3, .adrp_offset = 0x00082E64, .add_rel_offset = 0x00000004}, \
-    {.opcode_reg = 4, .adrp_offset = 0x0008B888, .add_rel_offset = 0x00000004}, \
-    {.opcode_reg = 4, .adrp_offset = 0x000A1B1C, .add_rel_offset = 0x00000004}, \
-    {.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
-}
-
-#endif // __FS_2200_H__

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

@@ -1,59 +0,0 @@
-/*
- * 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_2200_EXFAT_H__
-#define __FS_2200_EXFAT_H__
-
-// Accessor vtable getters
-#define FS_OFFSET_2200_EXFAT_SDMMC_ACCESSOR_GC   0x1BB3B0
-#define FS_OFFSET_2200_EXFAT_SDMMC_ACCESSOR_SD   0x1BD3B0
-#define FS_OFFSET_2200_EXFAT_SDMMC_ACCESSOR_NAND 0x1BB9E0
-
-// Hooks
-#define FS_OFFSET_2200_EXFAT_SDMMC_WRAPPER_READ  0x1B72E0
-#define FS_OFFSET_2200_EXFAT_SDMMC_WRAPPER_WRITE 0x1B7340
-#define FS_OFFSET_2200_EXFAT_RTLD                0x2DED0
-#define FS_OFFSET_2200_EXFAT_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x4C)))
-
-#define FS_OFFSET_2200_EXFAT_CLKRST_SET_MIN_V_CLK_RATE 0x1DA450
-
-// Misc funcs
-#define FS_OFFSET_2200_EXFAT_LOCK_MUTEX          0x1B00E0
-#define FS_OFFSET_2200_EXFAT_UNLOCK_MUTEX        0x1B0130
-
-#define FS_OFFSET_2200_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0x1B72A0
-#define FS_OFFSET_2200_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1B72C0
-
-// Misc Data
-#define FS_OFFSET_2200_EXFAT_SD_MUTEX            0x1002408
-#define FS_OFFSET_2200_EXFAT_NAND_MUTEX          0xFFDD00
-#define FS_OFFSET_2200_EXFAT_ACTIVE_PARTITION    0xFFDD40
-#define FS_OFFSET_2200_EXFAT_SDMMC_DAS_HANDLE    0xFDBB98
-
-// NOPs
-#define FS_OFFSET_2200_EXFAT_SD_DAS_INIT         0x2B438
-
-// Nintendo Paths
-#define FS_OFFSET_2200_EXFAT_NINTENDO_PATHS \
-{ \
-    {.opcode_reg = 3, .adrp_offset = 0x000715EC, .add_rel_offset = 0x00000004}, \
-    {.opcode_reg = 3, .adrp_offset = 0x00082E64, .add_rel_offset = 0x00000004}, \
-    {.opcode_reg = 4, .adrp_offset = 0x0008B888, .add_rel_offset = 0x00000004}, \
-    {.opcode_reg = 4, .adrp_offset = 0x000A1B1C, .add_rel_offset = 0x00000004}, \
-    {.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
-}
-
-#endif // __FS_2200_EXFAT_H__

exosphere/exosphere.mk

@@ -70,6 +70,6 @@ clean:
 	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk clean
 	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk clean ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
 	@rm -fr $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
-	@for i in $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR); do [ -d $$i ] && rmdir $$i 2>/dev/null || true; done
+	@for i in $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
 
 .PHONY: all clean check_lib check_boot_lib check_loader_stub check_program check_mariko_fatal check_warmboot

exosphere/program/program.mk

@@ -119,7 +119,7 @@ DEPENDS	:=	$(OFILES:.o=.d)
 #---------------------------------------------------------------------------------
 
 $(OUTPUT).lz4	:	$(OUTPUT).bin
-	$(SILENTCMD)$(PYTHON) $(CURRENT_DIRECTORY)/split_program.py $(OUTPUT).bin $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
+	@python $(CURRENT_DIRECTORY)/split_program.py $(OUTPUT).bin $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
 	@echo built ... $(notdir $@)
 
 $(OUTPUT).bin	:	$(OUTPUT).elf

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 0x2E, 0x27, 0x44, 0xEA, 0x32, 0xF8, 0x2C, 0xF0, 0x6F, 0xCA, 0xCD, 0x77, 0xAE, 0xAE, 0x1A, 0x1B
+.byte 0x8C, 0x2E, 0xC1, 0x1C, 0xA0, 0x28, 0x35, 0xFC, 0x9A, 0x9F, 0x1D, 0x9B, 0x4E, 0xDF, 0x1E, 0x03
 
 /* Mariko Production Master Kek Source. */
-.byte 0x82, 0xE2, 0x0A, 0x59, 0x67, 0xDF, 0xBF, 0x51, 0x47, 0x62, 0x11, 0xF2, 0x41, 0xD3, 0xEE, 0x13
+.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. */
@@ -111,8 +111,6 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .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. */
-.byte 0x74, 0xB2, 0x5F, 0xA0, 0x4B, 0x74, 0x6D, 0x47, 0x5B, 0xA9, 0xF5, 0x26, 0x46, 0xD7, 0x4B, 0x6E /* Master key 13 encrypted with Master key 14. */
-.byte 0x97, 0xB3, 0x61, 0x88, 0x5C, 0x0D, 0xA1, 0x38, 0x73, 0xA4, 0x2F, 0x1A, 0x46, 0xA1, 0x09, 0xBF /* Master key 14 encrypted with Master key 15. */
 
 /* 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. */
@@ -135,8 +133,6 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .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. */
-.byte 0xF7, 0x92, 0xC0, 0xEC, 0xF3, 0xA4, 0x8C, 0xB7, 0x0D, 0xB3, 0xF3, 0xAB, 0x10, 0x9B, 0x18, 0xBA /* Master key 13 encrypted with Master key 14. */
-.byte 0x14, 0xCB, 0x60, 0x29, 0x3D, 0xE0, 0xFB, 0xF2, 0x5B, 0x60, 0xB6, 0xC5, 0x2E, 0x77, 0x8F, 0x98 /* Master key 14 encrypted with Master key 15. */
 
 /* 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. */
@@ -156,8 +152,6 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .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. */
-.byte 0xF9, 0x62, 0x05, 0x99, 0xE0, 0xB9, 0xA6, 0x9B, 0x9D, 0xAA, 0xB4, 0x12, 0x0B, 0x0F, 0xF5, 0x8F /* 21.0.0 Device Master Key Source Source. */
-.byte 0xF8, 0xF4, 0x22, 0xA4, 0x34, 0xAE, 0x0E, 0x0C, 0x4D, 0x5C, 0x5B, 0xA1, 0x1B, 0x46, 0x1C, 0x78 /* 22.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. */
@@ -177,8 +171,6 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .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. */
-.byte 0x7A, 0x4C, 0x38, 0xB7, 0x03, 0x6B, 0x1E, 0x81, 0x20, 0x53, 0x14, 0x99, 0xA4, 0x21, 0x92, 0x9F /* 21.0.0 Device Master Kek Source. */
-.byte 0xF3, 0xBC, 0xB5, 0xB5, 0x5F, 0x01, 0x50, 0x2B, 0x69, 0x69, 0x3A, 0x6B, 0xF9, 0x2C, 0x11, 0x9F /* 22.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. */
@@ -197,6 +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. */
+.byte 0xDA, 0xFB, 0x61, 0x39, 0x48, 0x2D, 0xC2, 0x7E, 0x0D, 0x8E, 0x8F, 0x98, 0x57, 0x20, 0xB8, 0x15 /* 20.0.0 Device Master Kek Source. */
-.byte 0x92, 0xBF, 0x37, 0x80, 0x0E, 0x79, 0x56, 0x8C, 0x57, 0x75, 0x72, 0x0A, 0x48, 0xD8, 0x15, 0x39 /* 21.0.0 Device Master Kek Source. */
-.byte 0xC4, 0x6F, 0x0E, 0x72, 0x43, 0xCE, 0x87, 0xFC, 0x38, 0x95, 0x9B, 0xC9, 0x31, 0x44, 0x97, 0x63 /* 22.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 == 22);
+        static_assert(pkg1::KeyGeneration_Count == 20);
         if (key_generation >= pkg1::KeyGeneration_Count) {
             return false;
         }

exosphere/program/source/smc/secmon_smc_info.cpp

@@ -132,13 +132,10 @@ namespace ams::secmon::smc {
         }
 
         u32 GetMemoryMode() {
-            /* Unless development function or forced boot config memory size is enabled, we're 4 GB. */
+            /* Unless development function is enabled, we're 4 GB. */
             u32 memory_mode = pkg1::MemoryMode_4GB;
 
-            const auto &bcd = GetBootConfig().data;
+            if (const auto &bcd = GetBootConfig().data; bcd.IsDevelopmentFunctionEnabled()) {
-            const auto &sc  = GetSecmonConfiguration(); /* Exosphere extensions */
-
-            if (bcd.IsDevelopmentFunctionEnabled() || sc.IsBootConfigMemoryModeEnabled()) {
                 memory_mode = GetMemoryMode(bcd.GetMemoryMode());
             }
 
@@ -149,20 +146,18 @@ namespace ams::secmon::smc {
             pkg1::MemorySize memory_size = pkg1::MemorySize_4GB;
             util::BitPack32 value = {};
 
-            const auto &bcd = GetBootConfig().data;
+            if (const auto &bcd = GetBootConfig().data; bcd.IsDevelopmentFunctionEnabled()) {
-            const auto &sc  = GetSecmonConfiguration(); /* Exosphere extensions */
+                memory_size = GetMemorySize(GetMemoryMode(bcd.GetMemoryMode()));
 
-            if (bcd.IsDevelopmentFunctionEnabled()) {
                 value.Set<KernelConfiguration::Flags1>(bcd.GetKernelFlags1());
                 value.Set<KernelConfiguration::Flags0>(bcd.GetKernelFlags0());
             }
 
-            if (bcd.IsDevelopmentFunctionEnabled() || sc.IsBootConfigMemoryModeEnabled()) {
-                memory_size = GetMemorySize(GetMemoryMode(bcd.GetMemoryMode()));
-            }
-
             value.Set<KernelConfiguration::PhysicalMemorySize>(memory_size);
 
+            /* Exosphere extensions. */
+            const auto &sc = GetSecmonConfiguration();
+
             if (!sc.DisableUserModeExceptionHandlers()) {
                 value.Set<KernelConfiguration::EnableUserExceptionHandlers>(true);
             }
@@ -174,27 +169,6 @@ namespace ams::secmon::smc {
             return value.value;
         }
 
-        fuse::DramId GetDramIdAdjusted() {
-            const auto dram_id = fuse::GetDramId();
-            AMS_ABORT_UNLESS(dram_id < fuse::DramId_Count);
-
-            const auto fuse_mem_size = DramIdToMemorySize[dram_id];
-            const auto phys_mem_size = GetPhysicalMemorySize();
-
-            AMS_ABORT_UNLESS(fuse_mem_size <= phys_mem_size);
-
-            if (fuse_mem_size == phys_mem_size) {
-                return dram_id;
-            }
-
-            /* Adjust Dram ID to match density/ranks. */
-            if (GetSocType() == fuse::SocType_Erista) {
-                return fuse::DramId_IcosaSamsung6GB;
-            } else { /* fuse::SocType_Mariko */
-                return fuse::DramId_IowaSamsung1y8GBX;
-            }
-        }
-
         constinit u64 g_payload_address = 0;
         constinit bool g_set_true_target_firmware = false;
 
@@ -204,7 +178,7 @@ namespace ams::secmon::smc {
                     args.r[1] = GetBootConfig().signed_data.IsProgramVerificationDisabled();
                     break;
                 case ConfigItem::DramId:
-                    args.r[1] = GetDramIdAdjusted(); /* Nintendo: fuse::GetDramId() */
+                    args.r[1] = fuse::GetDramId();
                     break;
                 case ConfigItem::SecurityEngineInterruptNumber:
                     args.r[1] = SecurityEngineUserInterruptId;
@@ -497,18 +471,9 @@ namespace ams::secmon::smc {
 
     /* For exosphere's usage. */
     pkg1::MemorySize GetPhysicalMemorySize() {
-        const uintptr_t MC = secmon::MemoryRegionVirtualDeviceMemoryController.GetAddress();
+        const auto dram_id = fuse::GetDramId();
-        const u32 mem_size = reg::Read(MC + MC_EMEM_CFG) & 0x3FFF;
+        AMS_ABORT_UNLESS(dram_id < fuse::DramId_Count);
-
+        return DramIdToMemorySize[dram_id];
-        switch (mem_size >> 10) {
-            case 4:
-            default:
-                return pkg1::MemorySize_4GB;
-            case 6:
-                return pkg1::MemorySize_6GB;
-            case 8:
-                return pkg1::MemorySize_8GB;
-        }
     }
 
 }

exosphere/program/source/smc/secmon_smc_register_access.cpp

@@ -101,10 +101,10 @@ namespace ams::secmon::smc {
         #include "secmon_define_mc01_access_table.inc"
 
         constexpr const AccessTableEntry AccessTables[] = {
-            {  PmcAccessTable::ReducedAccessTable.data(),                            MemoryRegionVirtualDevicePmc.GetAddress(),                PmcAccessTable::Address,                                                             PmcAccessTable::Size, },
+            {  PmcAccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDevicePmc.GetAddress(),                PmcAccessTable::Address,                                                             PmcAccessTable::Size, },
-            {   McAccessTable::ReducedAccessTable.data(),                            MemoryRegionVirtualDeviceMemoryController.GetAddress(),    McAccessTable::Address,                                                              McAccessTable::Size, },
+            {   McAccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDeviceMemoryController.GetAddress(),    McAccessTable::Address,                                                              McAccessTable::Size, },
-            { Mc01AccessTable::ReducedAccessTable.data(), Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController0.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController0.GetAddress(), Mc01AccessTable::Size, },
+            { Mc01AccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDeviceMemoryController0.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController0.GetAddress(), Mc01AccessTable::Size, },
-            { Mc01AccessTable::ReducedAccessTable.data(), Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController1.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController1.GetAddress(), Mc01AccessTable::Size, },
+            { Mc01AccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDeviceMemoryController1.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController1.GetAddress(), Mc01AccessTable::Size, },
         };
 
         constexpr bool IsAccessAllowed(const AccessTableEntry &entry, uintptr_t address) {

fusee/fusee.mk

@@ -43,6 +43,6 @@ clean:
 	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/loader_stub -f $(CURRENT_DIRECTORY)/loader_stub/loader_stub.mk clean
 	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/program -f $(CURRENT_DIRECTORY)/program/program.mk clean
 	@rm -fr $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
-	@for i in $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR); do [ -d $$i ] && rmdir $$i 2>/dev/null || true; done
+	@for i in $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
 
 .PHONY: all clean check_lib check_loader_stub check_program

fusee/program/program.mk

@@ -84,7 +84,7 @@ DEPENDS	:=	$(OFILES:.o=.d)
 #---------------------------------------------------------------------------------
 
 $(OUTPUT).lz4	:	$(OUTPUT).bin
-	$(SILENTCMD)$(PYTHON) $(CURRENT_DIRECTORY)/lz4_compress.py $(OUTPUT).bin $(OUTPUT).lz4
+	@python $(CURRENT_DIRECTORY)/lz4_compress.py $(OUTPUT).bin $(OUTPUT).lz4
 	@echo built ... $(notdir $@)
 
 $(OUTPUT).bin	:	$(OUTPUT).elf

fusee/program/source/fusee_display.cpp

@@ -602,7 +602,7 @@ namespace ams::nxboot {
             Print("\n");
 
             if (R_SUCCEEDED(save_result)) {
-                Print("Report saved to /atmosphere/fatal_errors/report_%016" PRIx64 ".bin\n", f_ctx->report_identifier);
+                Print("Report saved to /atmosphere/fatal_errors/report_%016" PRIx64 ".bin", f_ctx->report_identifier);
             } else {
                 Print("Failed to save report to the SD card! (%08" PRIx32 ")\n", save_result.GetValue());
             }

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. */
-            0x82, 0xE2, 0x0A, 0x59, 0x67, 0xDF, 0xBF, 0x51, 0x47, 0x62, 0x11, 0xF2, 0x41, 0xD3, 0xEE, 0x13
+            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. */
-            0x2E, 0x27, 0x44, 0xEA, 0x32, 0xF8, 0x2C, 0xF0, 0x6F, 0xCA, 0xCD, 0x77, 0xAE, 0xAE, 0x1A, 0x1B
+            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. */
-            0x15, 0xAC, 0x96, 0x34, 0xF5, 0x32, 0x56, 0x68, 0xFE, 0x5B, 0x9D, 0xD7, 0xED, 0x19, 0xB7, 0x8E
+            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] = {
@@ -74,8 +74,6 @@ namespace ams::nxboot {
             { 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. */
-            { 0xF9, 0x62, 0x05, 0x99, 0xE0, 0xB9, 0xA6, 0x9B, 0x9D, 0xAA, 0xB4, 0x12, 0x0B, 0x0F, 0xF5, 0x8F }, /* 21.0.0 Device Master Key Source Source. */
-            { 0xF8, 0xF4, 0x22, 0xA4, 0x34, 0xAE, 0x0E, 0x0C, 0x4D, 0x5C, 0x5B, 0xA1, 0x1B, 0x46, 0x1C, 0x78 }, /* 22.0.0 Device Master Key Source Source. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 DeviceMasterKekSources[pkg1::OldDeviceMasterKeyCount][se::AesBlockSize] = {
@@ -96,8 +94,6 @@ namespace ams::nxboot {
             { 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. */
-            { 0x92, 0xBF, 0x37, 0x80, 0x0E, 0x79, 0x56, 0x8C, 0x57, 0x75, 0x72, 0x0A, 0x48, 0xD8, 0x15, 0x39 }, /* 21.0.0 Device Master Kek Source. */
-            { 0xC4, 0x6F, 0x0E, 0x72, 0x43, 0xCE, 0x87, 0xFC, 0x38, 0x95, 0x9B, 0xC9, 0x31, 0x44, 0x97, 0x63 }, /* 22.0.0 Device Master Kek Source. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 DeviceMasterKekSourcesDev[pkg1::OldDeviceMasterKeyCount][se::AesBlockSize] = {
@@ -118,8 +114,6 @@ namespace ams::nxboot {
             { 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. */
-            { 0x7A, 0x4C, 0x38, 0xB7, 0x03, 0x6B, 0x1E, 0x81, 0x20, 0x53, 0x14, 0x99, 0xA4, 0x21, 0x92, 0x9F }, /* 21.0.0 Device Master Kek Source. */
-            { 0xF3, 0xBC, 0xB5, 0xB5, 0x5F, 0x01, 0x50, 0x2B, 0x69, 0x69, 0x3A, 0x6B, 0xF9, 0x2C, 0x11, 0x9F }, /* 22.0.0 Device Master Kek Source. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 MasterKeySources[pkg1::KeyGeneration_Count][se::AesBlockSize] = {
@@ -143,8 +137,6 @@ namespace ams::nxboot {
             { 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. */
-            { 0xF7, 0x92, 0xC0, 0xEC, 0xF3, 0xA4, 0x8C, 0xB7, 0x0D, 0xB3, 0xF3, 0xAB, 0x10, 0x9B, 0x18, 0xBA }, /* Master key 13 encrypted with Master key 14. */
-            { 0x14, 0xCB, 0x60, 0x29, 0x3D, 0xE0, 0xFB, 0xF2, 0x5B, 0x60, 0xB6, 0xC5, 0x2E, 0x77, 0x8F, 0x98 }, /* Master key 14 encrypted with Master key 15. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 MasterKeySourcesDev[pkg1::KeyGeneration_Count][se::AesBlockSize] = {
@@ -168,8 +160,6 @@ namespace ams::nxboot {
             { 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. */
-            { 0x74, 0xB2, 0x5F, 0xA0, 0x4B, 0x74, 0x6D, 0x47, 0x5B, 0xA9, 0xF5, 0x26, 0x46, 0xD7, 0x4B, 0x6E }, /* Master key 13 encrypted with Master key 14. */
-            { 0x97, 0xB3, 0x61, 0x88, 0x5C, 0x0D, 0xA1, 0x38, 0x73, 0xA4, 0x2F, 0x1A, 0x46, 0xA1, 0x09, 0xBF }, /* Master key 14 encrypted with Master key 15. */
         };
 
         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 == 22);
+            static_assert(pkg1::KeyGeneration_Count == 20);
             if (key_generation >= pkg1::KeyGeneration_Count) {
                 return false;
             }

fusee/program/source/fusee_setup_horizon.cpp

@@ -265,10 +265,6 @@ namespace ams::nxboot {
                         return ams::TargetFirmware_19_0_0;
                     } else if (std::memcmp(package1 + 0x10, "20250206", 8) == 0) {
                         return ams::TargetFirmware_20_0_0;
-                    } else if (std::memcmp(package1 + 0x10, "20251009", 8) == 0) {
-                        return ams::TargetFirmware_21_0_0;
-                    } else if (std::memcmp(package1 + 0x10, "20260123", 8) == 0) {
-                        return ams::TargetFirmware_22_0_0;
                     }
                     break;
                 default:
@@ -413,9 +409,8 @@ namespace ams::nxboot {
                     /* If we should, save the current warmboot firmware. */
                     UpdateWarmbootPath(expected_fuses);
                     if (!IsFileExist(warmboot_path)) {
-                        /* Try to create the directory/file, allowing them to fail (if already exist). */
+                        fs::CreateDirectory("sdmc:/warmboot_mariko");
-                        static_cast<void>(fs::CreateDirectory("sdmc:/warmboot_mariko"));
+                        fs::CreateFile(warmboot_path, warmboot_src_size);
-                        static_cast<void>(fs::CreateFile(warmboot_path, warmboot_src_size));
 
                         Result result;
                         fs::FileHandle file;
@@ -545,12 +540,6 @@ namespace ams::nxboot {
                                 } else {
                                     storage_ctx.flags[0] &= ~secmon::SecureMonitorConfigurationFlag_EnableUserModePerformanceCounterAccess;
                                 }
-                            } else if (std::strcmp(entry.key, "enable_mem_mode") == 0) {
-                                if (entry.value[0] == '1') {
-                                    storage_ctx.flags[0] |= secmon::SecureMonitorConfigurationFlag_BootConfigMemoryModeEnabled;
-                                } else {
-                                    storage_ctx.flags[0] &= ~secmon::SecureMonitorConfigurationFlag_BootConfigMemoryModeEnabled;
-                                }
                             } else if (std::strcmp(entry.key, "blank_prodinfo_sysmmc") == 0) {
                                 if (!emummc_enabled) {
                                     if (entry.value[0] == '1') {

fusee/program/source/fusee_stratosphere.cpp

@@ -183,18 +183,6 @@ namespace ams::nxboot {
             FsVersion_20_0_0,
             FsVersion_20_0_0_Exfat,
 
-            FsVersion_20_1_0,
-            FsVersion_20_1_0_Exfat,
-
-            FsVersion_21_0_0,
-            FsVersion_21_0_0_Exfat,
-
-            FsVersion_21_2_0,
-            FsVersion_21_2_0_Exfat,
-
-            FsVersion_22_0_0,
-            FsVersion_22_0_0_Exfat,
-
             FsVersion_Count,
         };
 
@@ -290,18 +278,6 @@ namespace ams::nxboot {
 
             { 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 */
-
-            { 0xEE, 0x4B, 0x30, 0x12, 0xA6, 0x84, 0x02, 0x25 }, /* FsVersion_21_0_0 */
-            { 0x6E, 0x2B, 0xD9, 0xBA, 0xA3, 0xB9, 0x10, 0xF1 }, /* FsVersion_21_0_0_Exfat */
-
-            { 0xAF, 0x1D, 0xBD, 0xC7, 0x82, 0x98, 0x3C, 0xBD }, /* FsVersion_21_2_0 */
-            { 0x56, 0x25, 0x17, 0xA1, 0x92, 0xC3, 0xC8, 0xF0 }, /* FsVersion_21_2_0_Exfat */
-
-            { 0xB7, 0xA2, 0x97, 0x39, 0xB7, 0xED, 0xDE, 0xFC }, /* FsVersion_22_0_0 */
-            { 0xFB, 0x0B, 0x68, 0xDB, 0x24, 0x03, 0xD1, 0x19 }, /* FsVersion_22_0_0_Exfat */
         };
 
         const InitialProcessBinaryHeader *FindInitialProcessBinary(const pkg2::Package2Header *header, const u8 *data, ams::TargetFirmware target_firmware) {
@@ -692,39 +668,15 @@ namespace ams::nxboot {
                     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;
-                case FsVersion_21_0_0:
-                case FsVersion_21_2_0:
-                    AddPatch(fs_meta, 0x1AC9ED, NogcPatch0, sizeof(NogcPatch0));
-                    AddPatch(fs_meta, 0x1ACA05, NogcPatch0, sizeof(NogcPatch0));
-                    AddPatch(fs_meta, 0x17FBE0, NogcPatch1, sizeof(NogcPatch1));
-                    break;
-                case FsVersion_21_0_0_Exfat:
-                case FsVersion_21_2_0_Exfat:
-                    AddPatch(fs_meta, 0x1B7B4D, NogcPatch0, sizeof(NogcPatch0));
-                    AddPatch(fs_meta, 0x1B7B65, NogcPatch0, sizeof(NogcPatch0));
-                    AddPatch(fs_meta, 0x18AD40, NogcPatch1, sizeof(NogcPatch1));
-                    break;
-                case FsVersion_22_0_0:
-                    AddPatch(fs_meta, 0x1B023D, NogcPatch0, sizeof(NogcPatch0));
-                    AddPatch(fs_meta, 0x1B0255, NogcPatch0, sizeof(NogcPatch0));
-                    AddPatch(fs_meta, 0x183060, NogcPatch1, sizeof(NogcPatch1));
-                    break;
-                case FsVersion_22_0_0_Exfat:
-                    AddPatch(fs_meta, 0x1BB42D, NogcPatch0, sizeof(NogcPatch0));
-                    AddPatch(fs_meta, 0x1BB445, NogcPatch0, sizeof(NogcPatch0));
-                    AddPatch(fs_meta, 0x18E250, NogcPatch1, sizeof(NogcPatch1));
-                    break;
                 default:
                     break;
             }

libraries/.gitrepo

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

libraries/config/common.mk

@@ -297,23 +297,6 @@ FIND_SOURCE_FILES=$(foreach dir,$1,$(filter-out $(notdir $(wildcard $(dir)/*.arc
 
 ATMOSPHERE_GCH_IDENTIFIER := $(ATMOSPHERE_FULL_NAME)
 
-#---------------------------------------------------------------------------------
-# Python.  The scripts should work with Python 2 or 3, but 2 is preferred.
-#---------------------------------------------------------------------------------
-PYTHON = $(shell command -v python >/dev/null && echo python || echo python3)
-
-#---------------------------------------------------------------------------------
-# Export MAKE:
-# GCC's LTO driver invokes Make internally.  This invocation respects both $(MAKE)
-# and $(MAKEFLAGS), but only if they're in the environment.  By default, MAKEFLAGS
-# is in the environment while MAKE isn't, so GCC will always use the default
-# `make` command, yet it inherits MAKEFLAGS from the copy of Make the user
-# invoked, which might have incompatible flags.  In practice this is an issue on
-# macOS when running e.g. `gmake -j32 -Otarget`.  This behavior is arguably a bug
-# in GCC and/or Make, but we can work around it by exporting MAKE.
-#---------------------------------------------------------------------------------
-export MAKE
-
 #---------------------------------------------------------------------------------
 # Rules for compiling pre-compiled headers
 #---------------------------------------------------------------------------------

libraries/config/templates/stratosphere.mk

@@ -26,7 +26,7 @@ ATMOSPHERE_OPTIMIZATION_FLAG := -O2
 endif
 
 export DEFINES     = $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_STRATOSPHERE -D_GNU_SOURCE
-export SETTINGS    = $(ATMOSPHERE_SETTINGS) $(ATMOSPHERE_OPTIMIZATION_FLAG) -Wextra -Werror -Wno-missing-field-initializers -Wno-error=unused-result
+export SETTINGS    = $(ATMOSPHERE_SETTINGS) $(ATMOSPHERE_OPTIMIZATION_FLAG) -Wextra -Werror -Wno-missing-field-initializers
 export CFLAGS      = $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 export CXXFLAGS    = $(CFLAGS) $(ATMOSPHERE_CXXFLAGS)
 export ASFLAGS     = $(ATMOSPHERE_ASFLAGS) $(SETTINGS) $(DEFINES)

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

@@ -40,8 +40,6 @@ namespace ams::pkg1 {
         KeyGeneration_18_0_0 = 0x11,
         KeyGeneration_19_0_0 = 0x12,
         KeyGeneration_20_0_0 = 0x13,
-        KeyGeneration_21_0_0 = 0x14,
-        KeyGeneration_22_0_0 = 0x15,
 
         KeyGeneration_Count,
 

libraries/libexosphere/include/exosphere/secmon/secmon_monitor_context.hpp

@@ -30,7 +30,6 @@ namespace ams::secmon {
         SecureMonitorConfigurationFlag_ShouldUseBlankCalibrationBinary        = (1u << 5),
         SecureMonitorConfigurationFlag_AllowWritingToCalibrationBinarySysmmc  = (1u << 6),
         SecureMonitorConfigurationFlag_ForceEnableUsb30                       = (1u << 7),
-        SecureMonitorConfigurationFlag_BootConfigMemoryModeEnabled            = (1u << 8),
 
         SecureMonitorConfigurationFlag_Default = SecureMonitorConfigurationFlag_IsDevelopmentFunctionEnabledForKernel,
     };
@@ -104,7 +103,6 @@ namespace ams::secmon {
         constexpr bool ShouldUseBlankCalibrationBinary()        const { return (this->flags[0] & SecureMonitorConfigurationFlag_ShouldUseBlankCalibrationBinary)        != 0; }
         constexpr bool AllowWritingToCalibrationBinarySysmmc()  const { return (this->flags[0] & SecureMonitorConfigurationFlag_AllowWritingToCalibrationBinarySysmmc)  != 0; }
         constexpr bool IsUsb30ForceEnabled()                    const { return (this->flags[0] & SecureMonitorConfigurationFlag_ForceEnableUsb30)                       != 0; }
-        constexpr bool IsBootConfigMemoryModeEnabled()          const { return (this->flags[0] & SecureMonitorConfigurationFlag_BootConfigMemoryModeEnabled)            != 0; }
 
         constexpr bool IsDevelopmentFunctionEnabled(bool for_kern) const { return for_kern ? this->IsDevelopmentFunctionEnabledForKernel() : this->IsDevelopmentFunctionEnabledForUser(); }
     };

libraries/libexosphere/libexosphere.mk

@@ -104,7 +104,7 @@ clean:
 	@echo clean $(ATMOSPHERE_BUILD_NAME) ...
 	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
 	@rm -fr $(foreach hdr,$(GCH_DIRS),$(hdr)/$(ATMOSPHERE_GCH_IDENTIFIER))
-	@for i in $(GCH_DIRS); do [ -d $$i ] && rmdir $$i 2>/dev/null || true; done
+	@for i in $(GCH_DIRS); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
 
 $(ATMOSPHERE_LIBRARY_DIR) $(ATMOSPHERE_BUILD_DIR) $(GCH_DIRS):
 	@[ -d $@ ] || mkdir -p $@

libraries/libexosphere/source/fuse/fuse_api.cpp

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

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

@@ -116,9 +116,7 @@ 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_interrupt_manager.hpp

@@ -83,9 +83,9 @@ namespace ams::kern::arch::arm64 {
             }
 
             NOINLINE Result BindHandler(KInterruptHandler *handler, s32 irq, s32 core_id, s32 priority, bool manual_clear, bool level);
-            NOINLINE void UnbindHandler(s32 irq, s32 core);
+            NOINLINE Result UnbindHandler(s32 irq, s32 core);
 
-            NOINLINE void ClearInterrupt(s32 irq, s32 core_id);
+            NOINLINE Result ClearInterrupt(s32 irq, s32 core_id);
 
             ALWAYS_INLINE void SendInterProcessorInterrupt(s32 irq, u64 core_mask) {
                 m_interrupt_controller.SendInterProcessorInterrupt(irq, core_mask);
@@ -99,10 +99,10 @@ namespace ams::kern::arch::arm64 {
         private:
             Result BindGlobal(KInterruptHandler *handler, s32 irq, s32 core_id, s32 priority, bool manual_clear, bool level);
             Result BindLocal(KInterruptHandler *handler, s32 irq, s32 priority, bool manual_clear);
-            void UnbindGlobal(s32 irq);
+            Result UnbindGlobal(s32 irq);
-            void UnbindLocal(s32 irq);
+            Result UnbindLocal(s32 irq);
-            void ClearGlobal(s32 irq);
+            Result ClearGlobal(s32 irq);
-            void ClearLocal(s32 irq);
+            Result ClearLocal(s32 irq);
         private:
             [[nodiscard]] static ALWAYS_INLINE u32 GetInterruptsEnabledState() {
                 u64 intr_state;

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

@@ -197,9 +197,9 @@ namespace ams::kern::arch::arm64 {
                 cpu::SwitchProcess(s_ttbr0_entries[proc_idx + 1], proc_id);
             }
 
-            NOINLINE void InitializeForKernel(void *table, KVirtualAddress start, KVirtualAddress end);
+            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);
-            void Finalize();
+            Result Finalize();
 
             static void NoteUpdatedCallback(const void *pt) {
                 /* Note the update. */

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

@@ -165,7 +165,7 @@ namespace ams::kern::arch::arm64 {
             constexpr explicit KThreadContext(util::ConstantInitializeTag) : m_callee_saved(), m_lr(), m_sp(), m_fpcr(), m_fpsr(), m_callee_saved_fpu(), m_locked() { /* ... */ }
             explicit KThreadContext() { /* ... */ }
 
-            void Initialize(KVirtualAddress u_pc, KVirtualAddress k_sp, KVirtualAddress u_sp, uintptr_t arg, bool is_user, bool is_64_bit, bool is_main);
+            Result Initialize(KVirtualAddress u_pc, KVirtualAddress k_sp, KVirtualAddress u_sp, uintptr_t arg, bool is_user, bool is_64_bit, bool is_main);
 
             void SetArguments(uintptr_t arg0, uintptr_t arg1);
 

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

@@ -35,7 +35,7 @@ namespace ams::kern::arch::arm64 {
                     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, u32 value);
+                    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);
@@ -100,8 +100,8 @@ namespace ams::kern::arch::arm64 {
                 return Impl::CopyMemoryToUserAligned64Bit(dst, src, size);
             }
 
-            static bool CopyMemoryToUserSize32Bit(void *dst, u32 value) {
+            static bool CopyMemoryToUserSize32Bit(void *dst, const void *src) {
-                return Impl::CopyMemoryToUserSize32Bit(dst, value);
+                return Impl::CopyMemoryToUserSize32Bit(dst, src);
             }
 
             static s32  CopyStringToUser(void *dst, const void *src, size_t size) {

libraries/libmesosphere/include/mesosphere/kern_build_config.hpp

@@ -47,6 +47,13 @@
 /* re-enabled by toggling this define. */
 //#define MESOSPHERE_ENABLE_PROCESS_CREATION_TIME
 
+/* NOTE: This enables fast class token storage using a class member. */
+/* This saves a virtual call when doing KAutoObject->DynCast<>(), */
+/* at the cost of storing class tokens inside the class object. */
+/* However, as of (10/16/2021) KAutoObject has an unused class member */
+/* of the right side, and so this does not actually cost any space. */
+#define MESOSPHERE_ENABLE_DEVIRTUALIZED_DYNAMIC_CAST
+
 /* NOTE: This enables usage of KDebug handles as parameter for svc::GetInfo */
 /* calls which require a process parameter. This enables a debugger to obtain */
 /* address space/layout information, for example. However, it changes abi, and so */

libraries/libmesosphere/include/mesosphere/kern_k_auto_object.hpp

@@ -121,9 +121,14 @@ namespace ams::kern {
         private:
             KAutoObject *m_next_closed_object;
             ReferenceCount m_ref_count;
+            #if defined(MESOSPHERE_ENABLE_DEVIRTUALIZED_DYNAMIC_CAST)
             ClassTokenType m_class_token;
+            #endif
         public:
-            constexpr ALWAYS_INLINE explicit KAutoObject(util::ConstantInitializeTag) : m_next_closed_object(nullptr), m_ref_count(0), m_class_token(0)
+            constexpr ALWAYS_INLINE explicit KAutoObject(util::ConstantInitializeTag) : m_next_closed_object(nullptr), m_ref_count(0)
+            #if defined(MESOSPHERE_ENABLE_DEVIRTUALIZED_DYNAMIC_CAST)
+                , m_class_token(0)
+            #endif
             {
                 MESOSPHERE_ASSERT_THIS();
             }
@@ -146,11 +151,19 @@ namespace ams::kern {
             }
 
             ALWAYS_INLINE bool IsDerivedFrom(const TypeObj &rhs) const {
-                return TypeObj::IsClassTokenDerivedFrom(m_class_token, rhs.GetClassToken());
+                #if defined(MESOSPHERE_ENABLE_DEVIRTUALIZED_DYNAMIC_CAST)
+                    return TypeObj::IsClassTokenDerivedFrom(m_class_token, rhs.GetClassToken());
+                #else
+                    return this->GetTypeObj().IsDerivedFrom(rhs);
+                #endif
             }
 
             ALWAYS_INLINE bool IsDerivedFrom(const KAutoObject &rhs) const {
-                return TypeObj::IsClassTokenDerivedFrom(m_class_token, rhs.m_class_token);
+                #if defined(MESOSPHERE_ENABLE_DEVIRTUALIZED_DYNAMIC_CAST)
+                    return TypeObj::IsClassTokenDerivedFrom(m_class_token, rhs.m_class_token);
+                #else
+                    return this->IsDerivedFrom(rhs.GetTypeObj());
+                #endif
             }
 
             template<typename Derived>
@@ -205,10 +218,12 @@ namespace ams::kern {
                 KAutoObject &auto_object = *static_cast<KAutoObject *>(obj);
 
                 /* If we should, set our class token. */
+                #if defined(MESOSPHERE_ENABLE_DEVIRTUALIZED_DYNAMIC_CAST)
                 {
                     constexpr auto Token = Derived::GetStaticTypeObj().GetClassToken();
                     auto_object.m_class_token = Token;
                 }
+                #endif
 
                 /* Initialize reference count to 1. */
                 auto_object.m_ref_count = 1;

libraries/libmesosphere/include/mesosphere/kern_k_debug_base.hpp

@@ -93,9 +93,9 @@ namespace ams::kern {
             static Result ProcessDebugEvent(ams::svc::DebugEvent event, const uintptr_t *params, size_t num_params);
         public:
             static Result OnDebugEvent(ams::svc::DebugEvent event, const uintptr_t *params, size_t num_params);
-            static void OnExitProcess(KProcess *process);
+            static Result OnExitProcess(KProcess *process);
-            static void OnTerminateProcess(KProcess *process);
+            static Result OnTerminateProcess(KProcess *process);
-            static void OnExitThread(KThread *thread);
+            static Result OnExitThread(KThread *thread);
             static KEventInfo *CreateDebugEvent(ams::svc::DebugEvent event, u64 thread_id, const uintptr_t *params, size_t num_params);
     };
 

libraries/libmesosphere/include/mesosphere/kern_k_event.hpp

@@ -50,8 +50,8 @@ namespace ams::kern {
 
             KReadableEvent &GetReadableEvent() { return m_readable_event; }
 
-            void Signal();
+            Result Signal();
-            void Clear();
+            Result Clear();
 
             ALWAYS_INLINE void OnReadableEventDestroyed() { m_readable_event_destroyed = true; }
     };

libraries/libmesosphere/include/mesosphere/kern_k_handle_table.hpp

@@ -105,7 +105,7 @@ namespace ams::kern {
             constexpr ALWAYS_INLINE size_t GetCount() const { return m_count; }
             constexpr ALWAYS_INLINE size_t GetMaxCount() const { return m_max_count; }
 
-            MESOSPHERE_NOINLINE_IF_DEBUG void Finalize();
+            MESOSPHERE_NOINLINE_IF_DEBUG Result Finalize();
             MESOSPHERE_NOINLINE_IF_DEBUG bool Remove(ams::svc::Handle handle);
 
             template<typename T = KAutoObject>

libraries/libmesosphere/include/mesosphere/kern_k_interrupt_event.hpp

@@ -38,11 +38,13 @@ namespace ams::kern {
 
             Result Reset();
 
-            void Clear() {
+            Result Clear() {
                 MESOSPHERE_ASSERT_THIS();
 
-                /* Try to perform a reset, ignoring whether it succeeds. */
+                /* Try to perform a reset, succeeding unconditionally. */
-                static_cast<void>(this->Reset());
+                this->Reset();
+
+                R_SUCCEED();
             }
 
             bool IsInitialized() const { return m_is_initialized; }

libraries/libmesosphere/include/mesosphere/kern_k_page_table_base.hpp

@@ -200,7 +200,6 @@ namespace ams::kern {
             bool m_is_kernel;
             bool m_enable_aslr;
             bool m_enable_device_address_space_merge;
-            bool m_allowed_exec_device_mapping;
             KMemoryBlockSlabManager *m_memory_block_slab_manager;
             KBlockInfoManager *m_block_info_manager;
             KResourceLimit *m_resource_limit;
@@ -218,7 +217,7 @@ namespace ams::kern {
                   m_alias_code_region_end(Null<KProcessAddress>), m_code_region_start(Null<KProcessAddress>), m_code_region_end(Null<KProcessAddress>),
                   m_max_heap_size(), m_mapped_physical_memory_size(), m_mapped_unsafe_physical_memory(), m_mapped_insecure_memory(), m_mapped_ipc_server_memory(), m_alias_region_extra_size(),
                   m_general_lock(), m_map_physical_memory_lock(), m_device_map_lock(), m_impl(util::ConstantInitialize), m_memory_block_manager(util::ConstantInitialize),
-                  m_allocate_option(), m_address_space_width(), m_is_kernel(), m_enable_aslr(), m_enable_device_address_space_merge(), m_allowed_exec_device_mapping(),
+                  m_allocate_option(), m_address_space_width(), m_is_kernel(), m_enable_aslr(), m_enable_device_address_space_merge(),
                   m_memory_block_slab_manager(), m_block_info_manager(), m_resource_limit(), m_cached_physical_linear_region(), m_cached_physical_heap_region(),
                   m_heap_fill_value(), m_ipc_fill_value(), m_stack_fill_value()
             {
@@ -227,7 +226,7 @@ namespace ams::kern {
 
             explicit KPageTableBase() { /* ... */ }
 
-            NOINLINE void InitializeForKernel(bool is_64_bit, void *table, KVirtualAddress start, KVirtualAddress end);
+            NOINLINE Result InitializeForKernel(bool is_64_bit, void *table, KVirtualAddress start, KVirtualAddress end);
             NOINLINE Result InitializeForProcess(ams::svc::CreateProcessFlag flags, bool from_back, KMemoryManager::Pool pool, void *table, KProcessAddress start, KProcessAddress end, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit);
 
             void Finalize();
@@ -521,8 +520,6 @@ namespace ams::kern {
             size_t GetAliasCodeDataSize() const;
 
             u32 GetAllocateOption() const { return m_allocate_option; }
-
-            void AllowDeviceMappingOfExecPages() { m_allowed_exec_device_mapping = true; }
         public:
             static ALWAYS_INLINE KVirtualAddress GetLinearMappedVirtualAddress(KPhysicalAddress addr) {
                 return KMemoryLayout::GetLinearVirtualAddress(addr);

libraries/libmesosphere/include/mesosphere/kern_k_process.hpp

@@ -102,8 +102,8 @@ namespace ams::kern {
             IoRegionList                m_io_region_list;
             bool                        m_is_suspended;
             bool                        m_is_immortal;
-            bool                        m_is_handle_table_initialized;
             bool                        m_is_jit_debug;
+            bool                        m_is_handle_table_initialized;
             ams::svc::DebugEvent        m_jit_debug_event_type;
             ams::svc::DebugException    m_jit_debug_exception_type;
             uintptr_t                   m_jit_debug_params[4];
@@ -269,7 +269,7 @@ namespace ams::kern {
             void RemoveIoRegion(KIoRegion *io_region);
 
             Result CreateThreadLocalRegion(KProcessAddress *out);
-            void DeleteThreadLocalRegion(KProcessAddress addr);
+            Result DeleteThreadLocalRegion(KProcessAddress addr);
             void *GetThreadLocalRegionPointer(KProcessAddress addr);
 
             constexpr KProcessAddress GetProcessLocalRegionAddress() const { return m_plr_address; }

libraries/libmesosphere/include/mesosphere/kern_k_readable_event.hpp

@@ -35,14 +35,16 @@ namespace ams::kern {
 
             constexpr KEvent *GetParent() const { return m_parent; }
 
-            void Signal();
+            Result Signal();
             Result Reset();
 
-            void Clear() {
+            Result Clear() {
                 MESOSPHERE_ASSERT_THIS();
 
-                /* Try to perform a reset, ignoring whether it succeeds. */
+                /* Try to perform a reset, succeeding unconditionally. */
-                static_cast<void>(this->Reset());
+                this->Reset();
+
+                R_SUCCEED();
             }
 
             virtual bool IsSignaled() const override;

libraries/libmesosphere/include/mesosphere/kern_k_thread.hpp

@@ -105,7 +105,7 @@ namespace ams::kern {
                 util::Atomic<u8> dpc_flags;
                 u8 current_svc_id;
                 u8 reserved_2c;
-                util::Atomic<u8> exception_flags;
+                u8 exception_flags;
                 bool is_pinned;
                 u8 reserved_2f;
                 u8 reserved_30[0x10];
@@ -417,17 +417,17 @@ namespace ams::kern {
         private:
             ALWAYS_INLINE void SetExceptionFlag(ExceptionFlag flag) {
                 MESOSPHERE_ASSERT_THIS();
-                this->GetStackParameters().exception_flags.FetchOr<std::memory_order_relaxed>(flag);
+                this->GetStackParameters().exception_flags |= flag;
             }
 
             ALWAYS_INLINE void ClearExceptionFlag(ExceptionFlag flag) {
                 MESOSPHERE_ASSERT_THIS();
-                this->GetStackParameters().exception_flags.FetchAnd<std::memory_order_relaxed>(~flag);
+                this->GetStackParameters().exception_flags &= ~flag;
             }
 
             ALWAYS_INLINE bool IsExceptionFlagSet(ExceptionFlag flag) const {
                 MESOSPHERE_ASSERT_THIS();
-                return this->GetStackParameters().exception_flags.Load<std::memory_order_relaxed>() & flag;
+                return this->GetStackParameters().exception_flags & flag;
             }
         public:
             /* ALWAYS_INLINE void SetCallingSvc()      { return this->SetExceptionFlag(ExceptionFlag_IsCallingSvc); }    */
@@ -523,7 +523,7 @@ namespace ams::kern {
             Result GetCoreMask(int32_t *out_ideal_core, u64 *out_affinity_mask);
             Result SetCoreMask(int32_t ideal_core, u64 affinity_mask);
 
-            void GetPhysicalCoreMask(int32_t *out_ideal_core, u64 *out_affinity_mask);
+            Result GetPhysicalCoreMask(int32_t *out_ideal_core, u64 *out_affinity_mask);
 
             constexpr ThreadState GetState() const { return static_cast<ThreadState>(m_thread_state & ThreadState_Mask); }
             constexpr ThreadState GetRawState() const { return m_thread_state; }
@@ -717,7 +717,7 @@ namespace ams::kern {
             }
 
             void SetBasePriority(s32 priority);
-            void SetPriorityToIdle();
+            Result SetPriorityToIdle();
 
             Result Run();
             void Exit();
@@ -725,7 +725,7 @@ namespace ams::kern {
             Result Terminate();
             ThreadState RequestTerminate();
 
-            void Sleep(s64 timeout);
+            Result Sleep(s64 timeout);
 
             ALWAYS_INLINE void *GetStackTop() const { return reinterpret_cast<StackParameters *>(m_kernel_stack_top) - 1; }
             ALWAYS_INLINE void *GetKernelStackTop() const { return m_kernel_stack_top; }

libraries/libmesosphere/include/mesosphere/kern_k_thread_local_page.hpp

@@ -77,7 +77,7 @@ namespace ams::kern {
             }
         public:
             Result Initialize(KProcess *process);
-            void Finalize();
+            Result Finalize();
 
             KProcessAddress Reserve();
             void Release(KProcessAddress addr);

libraries/libmesosphere/libmesosphere.mk

@@ -86,7 +86,7 @@ clean:
 	@echo clean $(ATMOSPHERE_BUILD_NAME) ...
 	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
 	@rm -fr $(foreach hdr,$(GCH_DIRS),$(hdr)/$(ATMOSPHERE_GCH_IDENTIFIER))
-	@for i in $(GCH_DIRS); do [ -d $$i ] && rmdir $$i 2>/dev/null || true; done
+	@for i in $(GCH_DIRS); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
 
 $(ATMOSPHERE_LIBRARY_DIR) $(ATMOSPHERE_BUILD_DIR) $(GCH_DIRS):
 	@[ -d $@ ] || mkdir -p $@

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

@@ -113,11 +113,6 @@ 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 {
@@ -173,11 +168,6 @@ 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;
-                KLightLock m_lock;
+                KSpinLock m_lock;
             public:
                 constexpr KCoreBarrierInterruptHandler() : KInterruptHandler(), m_target_cores(0), m_lock() { /* ... */ }
 
@@ -123,8 +123,11 @@ namespace ams::kern::arch::arm64::cpu {
                 }
 
                 void SynchronizeCores(u64 core_mask) {
+                    /* Disable dispatch while we synchronize. */
+                    KScopedDisableDispatch dd;
+
                     /* Acquire exclusive access to ourselves. */
-                    KScopedLightLock lk(m_lock);
+                    KScopedSpinLock lk(m_lock);
 
                     /* If necessary, force synchronization with other cores. */
                     if (const u64 other_cores_mask = core_mask & ~(1ul << GetCurrentCoreId()); other_cores_mask != 0) {
@@ -215,7 +218,7 @@ namespace ams::kern::arch::arm64::cpu {
                     KThread::Register(new_thread);
 
                     /* Run the thread. */
-                    MESOSPHERE_R_ABORT_UNLESS(new_thread->Run());
+                    new_thread->Run();
                 }
 
                 virtual KInterruptTask *OnInterrupt(s32 interrupt_id) override {
@@ -508,16 +511,16 @@ namespace ams::kern::arch::arm64::cpu {
         g_cache_operation_handler.Initialize(core_id);
 
         /* Bind all handlers to the relevant interrupts. */
-        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetInterruptManager().BindHandler(std::addressof(g_cache_operation_handler),              KInterruptName_CacheOperation,     core_id, KInterruptController::PriorityLevel_High,      false, false));
+        Kernel::GetInterruptManager().BindHandler(std::addressof(g_cache_operation_handler),              KInterruptName_CacheOperation,     core_id, KInterruptController::PriorityLevel_High,      false, false);
-        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetInterruptManager().BindHandler(std::addressof(g_thread_termination_handler),           KInterruptName_ThreadTerminate,    core_id, KInterruptController::PriorityLevel_Scheduler, false, false));
+        Kernel::GetInterruptManager().BindHandler(std::addressof(g_thread_termination_handler),           KInterruptName_ThreadTerminate,    core_id, KInterruptController::PriorityLevel_Scheduler, false, false);
-        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetInterruptManager().BindHandler(std::addressof(g_core_barrier_handler),                 KInterruptName_CoreBarrier,        core_id, KInterruptController::PriorityLevel_Scheduler, false, false));
+        Kernel::GetInterruptManager().BindHandler(std::addressof(g_core_barrier_handler),                 KInterruptName_CoreBarrier,        core_id, KInterruptController::PriorityLevel_Scheduler, false, false);
 
         /* If we should, enable user access to the performance counter registers. */
         if (KTargetSystem::IsUserPmuAccessEnabled()) { SetPmUserEnrEl0(1ul); }
 
         /* If we should, enable the kernel performance counter interrupt handler. */
         #if defined(MESOSPHERE_ENABLE_PERFORMANCE_COUNTER)
-        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetInterruptManager().BindHandler(std::addressof(g_performance_counter_handler[core_id]), KInterruptName_PerformanceCounter, core_id, KInterruptController::PriorityLevel_Timer,     false, false));
+        Kernel::GetInterruptManager().BindHandler(std::addressof(g_performance_counter_handler[core_id]), KInterruptName_PerformanceCounter, core_id, KInterruptController::PriorityLevel_Timer,     false, false);
         #endif
     }
 

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

@@ -25,7 +25,7 @@ namespace ams::kern::arch::arm64 {
         m_maximum_time = static_cast<s64>(std::min<u64>(std::numeric_limits<s64>::max(), cpu::CounterTimerPhysicalTimerCompareValueRegisterAccessor().GetCompareValue()));
 
         /* Bind the interrupt task for this core. */
-        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetInterruptManager().BindHandler(this, KInterruptName_NonSecurePhysicalTimer, GetCurrentCoreId(), KInterruptController::PriorityLevel_Timer, true, true));
+        Kernel::GetInterruptManager().BindHandler(this, KInterruptName_NonSecurePhysicalTimer, GetCurrentCoreId(), KInterruptController::PriorityLevel_Timer, true, true);
     }
 
     void KHardwareTimer::Finalize() {

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

@@ -126,7 +126,7 @@ namespace ams::kern::arch::arm64 {
             if (entry.handler != nullptr) {
                 /* Set manual clear needed if relevant. */
                 if (entry.manually_cleared) {
-                    m_interrupt_controller.Disable(irq);
+                    m_interrupt_controller.SetPriorityLevel(irq, KInterruptController::PriorityLevel_Low);
                     entry.needs_clear = true;
                 }
 
@@ -242,40 +242,40 @@ namespace ams::kern::arch::arm64 {
         }
     }
 
-    void KInterruptManager::UnbindHandler(s32 irq, s32 core_id) {
+    Result KInterruptManager::UnbindHandler(s32 irq, s32 core_id) {
         MESOSPHERE_UNUSED(core_id);
 
-        MESOSPHERE_ASSERT(KInterruptController::IsGlobal(irq) || KInterruptController::IsLocal(irq));
+        R_UNLESS(KInterruptController::IsGlobal(irq) || KInterruptController::IsLocal(irq), svc::ResultOutOfRange());
 
 
         if (KInterruptController::IsGlobal(irq)) {
             KScopedInterruptDisable di;
 
             KScopedSpinLock lk(this->GetGlobalInterruptLock());
-            return this->UnbindGlobal(irq);
+            R_RETURN(this->UnbindGlobal(irq));
-        } else if (KInterruptController::IsLocal(irq)) {
+        } else {
             MESOSPHERE_ASSERT(core_id == GetCurrentCoreId());
 
             KScopedInterruptDisable di;
-            return this->UnbindLocal(irq);
+            R_RETURN(this->UnbindLocal(irq));
         }
     }
 
-    void KInterruptManager::ClearInterrupt(s32 irq, s32 core_id) {
+    Result KInterruptManager::ClearInterrupt(s32 irq, s32 core_id) {
         MESOSPHERE_UNUSED(core_id);
 
-        MESOSPHERE_ASSERT(KInterruptController::IsGlobal(irq) || KInterruptController::IsLocal(irq));
+        R_UNLESS(KInterruptController::IsGlobal(irq) || KInterruptController::IsLocal(irq), svc::ResultOutOfRange());
 
 
         if (KInterruptController::IsGlobal(irq)) {
             KScopedInterruptDisable di;
             KScopedSpinLock lk(this->GetGlobalInterruptLock());
-            return this->ClearGlobal(irq);
+            R_RETURN(this->ClearGlobal(irq));
-        } else if (KInterruptController::IsLocal(irq)) {
+        } else {
             MESOSPHERE_ASSERT(core_id == GetCurrentCoreId());
 
             KScopedInterruptDisable di;
-            return this->ClearLocal(irq);
+            R_RETURN(this->ClearLocal(irq));
         }
     }
 
@@ -332,7 +332,7 @@ namespace ams::kern::arch::arm64 {
         R_SUCCEED();
     }
 
-    void KInterruptManager::UnbindGlobal(s32 irq) {
+    Result KInterruptManager::UnbindGlobal(s32 irq) {
         for (size_t core_id = 0; core_id < cpu::NumCores; core_id++) {
             m_interrupt_controller.ClearTarget(irq, static_cast<s32>(core_id));
         }
@@ -340,35 +340,50 @@ namespace ams::kern::arch::arm64 {
         m_interrupt_controller.Disable(irq);
 
         GetGlobalInterruptEntry(irq).handler = nullptr;
+
+        R_SUCCEED();
     }
 
-    void KInterruptManager::UnbindLocal(s32 irq) {
+    Result KInterruptManager::UnbindLocal(s32 irq) {
+        auto &entry = this->GetLocalInterruptEntry(irq);
+        R_UNLESS(entry.handler != nullptr, svc::ResultInvalidState());
+
         m_interrupt_controller.SetPriorityLevel(irq, KInterruptController::PriorityLevel_Low);
         m_interrupt_controller.Disable(irq);
 
-        this->GetLocalInterruptEntry(irq).handler = nullptr;
+        entry.handler = nullptr;
+
+        R_SUCCEED();
     }
 
-    void KInterruptManager::ClearGlobal(s32 irq) {
+    Result KInterruptManager::ClearGlobal(s32 irq) {
-        /* Get the entry. */
+        /* We can't clear an entry with no handler. */
         auto &entry = GetGlobalInterruptEntry(irq);
+        R_UNLESS(entry.handler != nullptr, svc::ResultInvalidState());
 
-        /* If not auto-cleared, clear and enable. */
+        /* If auto-cleared, we can succeed immediately. */
-        if (entry.manually_cleared && entry.needs_clear) {
+        R_SUCCEED_IF(!entry.manually_cleared);
-            entry.needs_clear = false;
+        R_SUCCEED_IF(!entry.needs_clear);
-            m_interrupt_controller.Enable(irq);
+
-        }
+        /* Clear and enable. */
+        entry.needs_clear = false;
+        m_interrupt_controller.Enable(irq);
+        R_SUCCEED();
     }
 
-    void KInterruptManager::ClearLocal(s32 irq) {
+    Result KInterruptManager::ClearLocal(s32 irq) {
-        /* Get the entry. */
+        /* We can't clear an entry with no handler. */
         auto &entry = this->GetLocalInterruptEntry(irq);
+        R_UNLESS(entry.handler != nullptr, svc::ResultInvalidState());
 
-        /* If not auto-cleared, clear and enable. */
+        /* If auto-cleared, we can succeed immediately. */
-        if (entry.manually_cleared && entry.needs_clear) {
+        R_SUCCEED_IF(!entry.manually_cleared);
-            entry.needs_clear = false;
+        R_SUCCEED_IF(!entry.needs_clear);
-            m_interrupt_controller.Enable(irq);
+
-        }
+        /* Clear and set priority. */
+        entry.needs_clear = false;
+        m_interrupt_controller.SetPriorityLevel(irq, entry.priority);
+        R_SUCCEED();
     }
 
 }

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

@@ -119,13 +119,15 @@ namespace ams::kern::arch::arm64 {
         MESOSPHERE_UNUSED(core_id);
     }
 
-    void KPageTable::InitializeForKernel(void *table, KVirtualAddress start, KVirtualAddress end) {
+    Result KPageTable::InitializeForKernel(void *table, KVirtualAddress start, KVirtualAddress end) {
         /* Initialize basic fields. */
         m_asid = 0;
         m_manager = Kernel::GetSystemSystemResource().GetPageTableManagerPointer();
 
         /* Initialize the base page table. */
-        KPageTableBase::InitializeForKernel(true, table, start, end);
+        MESOSPHERE_R_ABORT_UNLESS(KPageTableBase::InitializeForKernel(true, table, start, end));
+
+        R_SUCCEED();
     }
 
     Result KPageTable::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) {
@@ -151,7 +153,7 @@ namespace ams::kern::arch::arm64 {
         R_SUCCEED();
     }
 
-    void KPageTable::Finalize() {
+    Result KPageTable::Finalize() {
         /* Only process tables should be finalized. */
         MESOSPHERE_ASSERT(!this->IsKernel());
 
@@ -269,6 +271,8 @@ namespace ams::kern::arch::arm64 {
             /* Perform inherited finalization. */
             KPageTableBase::Finalize();
         }
+
+        R_SUCCEED();
     }
 
     Result KPageTable::OperateImpl(PageLinkedList *page_list, KProcessAddress virt_addr, size_t num_pages, KPhysicalAddress phys_addr, bool is_pa_valid, const KPageProperties properties, OperationType operation, bool reuse_ll) {
@@ -938,7 +942,7 @@ namespace ams::kern::arch::arm64 {
                 /* If we should flush entries, do so. */
                 if ((apply_option & ApplyOption_FlushDataCache) != 0) {
                     if (IsHeapPhysicalAddress(next_entry.phys_addr)) {
-                        MESOSPHERE_R_ABORT_UNLESS(cpu::FlushDataCache(GetVoidPointer(GetHeapVirtualAddress(next_entry.phys_addr)), next_entry.block_size));
+                        cpu::FlushDataCache(GetVoidPointer(GetHeapVirtualAddress(next_entry.phys_addr)), next_entry.block_size);
                     }
                 }
 

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

@@ -37,7 +37,7 @@ namespace ams::kern::arch::arm64 {
             KScopedInterruptEnable ei;
 
             const uintptr_t params[2] = { GetCurrentThread().GetId(), GetInteger(GetCurrentThread().GetThreadLocalRegionAddress()) };
-            static_cast<void>(KDebug::OnDebugEvent(ams::svc::DebugEvent_CreateThread, params, util::size(params)));
+            KDebug::OnDebugEvent(ams::svc::DebugEvent_CreateThread, params, util::size(params));
         }
 
         /* Handle any pending dpc. */
@@ -116,7 +116,7 @@ namespace ams::kern::arch::arm64 {
 
     }
 
-    void KThreadContext::Initialize(KVirtualAddress u_pc, KVirtualAddress k_sp, KVirtualAddress u_sp, uintptr_t arg, bool is_user, bool is_64_bit, bool is_main) {
+    Result KThreadContext::Initialize(KVirtualAddress u_pc, KVirtualAddress k_sp, KVirtualAddress u_sp, uintptr_t arg, bool is_user, bool is_64_bit, bool is_main) {
         MESOSPHERE_ASSERT(k_sp != Null<KVirtualAddress>);
 
         /* Ensure that the stack pointers are aligned. */
@@ -157,6 +157,8 @@ namespace ams::kern::arch::arm64 {
 
         /* Lock the context, if we're a main thread. */
         m_locked = is_main;
+
+        R_SUCCEED();
     }
 
     void KThreadContext::SetArguments(uintptr_t arg0, uintptr_t arg1) {

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

@@ -306,14 +306,15 @@ _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl28CopyMemoryToUserAligned64BitEPvPK
     mov     x0, #1
     ret
 
-/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryToUserSize32Bit(void *dst, u32 value) */
+/* ams::kern::arch::arm64::UserspaceAccess::Impl::CopyMemoryToUserSize32Bit(void *dst, const void *src) */
-.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvj, "ax", %progbits
+.section    .text._ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvPKv, "ax", %progbits
-.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvj
+.global     _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvPKv
-.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvj, %function
+.type       _ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvPKv, %function
 .balign 0x10
-_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvj:
+_ZN3ams4kern4arch5arm6415UserspaceAccess4Impl25CopyMemoryToUserSize32BitEPvPKv:
-    /* Just store a u32. */
+    /* Just load and store a u32. */
-    sttr    w1, [x0]
+    ldr     w2, [x1]
+    sttr    w2, [x0]
 
     /* We're done. */
     mov     x0, #1

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

@@ -660,7 +660,8 @@ namespace ams::kern::board::nintendo::nx {
         ptm.Open(table_virt_addr, 1);
 
         /* Save the page. Note that it is a pre-condition that the page is cleared, when allocated from the system page table manager. */
-        MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(GetVoidPointer(table_virt_addr), PageDirectorySize));
+        /* NOTE: Nintendo does not check the result of StoreDataCache. */
+        cpu::StoreDataCache(GetVoidPointer(table_virt_addr), PageDirectorySize);
         g_reserved_table_phys_addr = table_phys_addr;
 
         /* Reserve an asid to correspond to no device. */
@@ -709,7 +710,7 @@ namespace ams::kern::board::nintendo::nx {
         /* Install interrupt handler. */
         #if defined(MESOSPHERE_ENABLE_MEMORY_CONTROLLER_INTERRUPT)
         {
-            MESOSPHERE_R_ABORT_UNLESS(Kernel::GetInterruptManager().BindHandler(std::addressof(g_mc_interrupt_task), KInterruptName_MemoryController, GetCurrentCoreId(), KInterruptController::PriorityLevel_High, true, true));
+            Kernel::GetInterruptManager().BindHandler(std::addressof(g_mc_interrupt_task), KInterruptName_MemoryController, GetCurrentCoreId(), KInterruptController::PriorityLevel_High, true, true);
         }
         #endif
     }
@@ -805,7 +806,7 @@ namespace ams::kern::board::nintendo::nx {
             MESOSPHERE_ASSERT(IsValidPhysicalAddress(GetPageTablePhysicalAddress(table_vaddr)));
 
             ptm.Open(table_vaddr, 1);
-            MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(GetVoidPointer(table_vaddr), PageDirectorySize));
+            cpu::StoreDataCache(GetVoidPointer(table_vaddr), PageDirectorySize);
             m_tables[i] = table_vaddr;
         }
 
@@ -1041,7 +1042,7 @@ namespace ams::kern::board::nintendo::nx {
                 if (l2_index == 0 && util::IsAligned(GetInteger(phys_addr), DeviceLargePageSize) && remaining >= DeviceLargePageSize) {
                     /* Set the large page. */
                     l1[l1_index].SetLargePage(read, write, true, phys_addr);
-                    MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(std::addressof(l1[l1_index]), sizeof(PageDirectoryEntry)));
+                    cpu::StoreDataCache(std::addressof(l1[l1_index]), sizeof(PageDirectoryEntry));
 
                     /* Synchronize. */
                     InvalidatePtc(GetPageTablePhysicalAddress(KVirtualAddress(std::addressof(l1[l1_index]))));
@@ -1061,11 +1062,11 @@ namespace ams::kern::board::nintendo::nx {
                     const KVirtualAddress table_vaddr = ptm.Allocate();
                     R_UNLESS(table_vaddr != Null<KVirtualAddress>, svc::ResultOutOfMemory());
                     MESOSPHERE_ASSERT(IsValidPhysicalAddress(GetPageTablePhysicalAddress(table_vaddr)));
-                    MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(GetVoidPointer(table_vaddr), PageTableSize));
+                    cpu::StoreDataCache(GetVoidPointer(table_vaddr), PageTableSize);
 
                     /* Set the l1 table. */
                     l1[l1_index].SetTable(true, true, true, GetPageTablePhysicalAddress(table_vaddr));
-                    MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(std::addressof(l1[l1_index]), sizeof(PageDirectoryEntry)));
+                    cpu::StoreDataCache(std::addressof(l1[l1_index]), sizeof(PageDirectoryEntry));
 
                     /* Synchronize. */
                     InvalidatePtc(GetPageTablePhysicalAddress(KVirtualAddress(std::addressof(l1[l1_index]))));
@@ -1092,7 +1093,7 @@ namespace ams::kern::board::nintendo::nx {
                     /* Add a reference to the l2 page (from the l2 entry page). */
                     ptm.Open(KVirtualAddress(l2), 1);
                 }
-                MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(std::addressof(l2[l2_index]), map_count * sizeof(PageTableEntry)));
+                cpu::StoreDataCache(std::addressof(l2[l2_index]), map_count * sizeof(PageTableEntry));
 
                 /* Invalidate the page table cache. */
                 for (size_t i = util::AlignDown(l2_index, 4); i <= util::AlignDown(l2_index + map_count - 1, 4); i += 4) {
@@ -1198,7 +1199,7 @@ namespace ams::kern::board::nintendo::nx {
                         ++num_closed;
                     }
                 }
-                MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(std::addressof(l2[l2_index]), map_count * sizeof(PageTableEntry)));
+                cpu::StoreDataCache(std::addressof(l2[l2_index]), map_count * sizeof(PageTableEntry));
 
                 /* Invalidate the page table cache. */
                 for (size_t i = util::AlignDown(l2_index, 4); i <= util::AlignDown(l2_index + map_count - 1, 4); i += 4) {
@@ -1242,7 +1243,7 @@ namespace ams::kern::board::nintendo::nx {
                 if (ptm.Close(KVirtualAddress(l2), num_closed)) {
                     /* Invalidate the l1 entry. */
                     l1[l1_index].Invalidate();
-                    MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(std::addressof(l1[l1_index]), sizeof(PageDirectoryEntry)));
+                    cpu::StoreDataCache(std::addressof(l1[l1_index]), sizeof(PageDirectoryEntry));
 
                     /* Synchronize. */
                     InvalidatePtc(GetPageTablePhysicalAddress(KVirtualAddress(std::addressof(l1[l1_index]))));
@@ -1265,7 +1266,7 @@ namespace ams::kern::board::nintendo::nx {
 
                 /* Invalidate the entry. */
                 l1[l1_index].Invalidate();
-                MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(std::addressof(l1[l1_index]), sizeof(PageDirectoryEntry)));
+                cpu::StoreDataCache(std::addressof(l1[l1_index]), sizeof(PageDirectoryEntry));
 
                 /* Synchronize. */
                 InvalidatePtc(GetPageTablePhysicalAddress(KVirtualAddress(std::addressof(l1[l1_index]))));

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

@@ -441,7 +441,7 @@ namespace ams::kern::board::nintendo::nx {
             KThread::Register(new_thread);
 
             /* Run the thread. */
-            MESOSPHERE_R_ABORT_UNLESS(new_thread->Run());
+            new_thread->Run();
         }
     }
 
@@ -524,14 +524,6 @@ 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,18 +361,10 @@ namespace ams::kern::board::nintendo::nx {
         }();
 
         /* Return (possibly) adjusted size. */
-        /* NOTE: On 20.0.0+ (and even more-so 21.0.0+) the browser requires much more memory in the applet pool in order to function. */
+        /* 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. */
-        if (kern::GetTargetFirmware() >= ams::TargetFirmware_21_0_0) {
+        const size_t ExtraSystemMemoryForAtmosphere = kern::GetTargetFirmware() >= ams::TargetFirmware_20_0_0 ? 14_MB : 40_MB;
-            constexpr size_t ExtraSystemMemoryForAtmosphere_21_0_0 = 7_MB;
+        return base_pool_size - ExtraSystemMemoryForAtmosphere - KTraceBufferSize;
-            return base_pool_size - ExtraSystemMemoryForAtmosphere_21_0_0 - KTraceBufferSize;
-        } else if (kern::GetTargetFirmware() >= ams::TargetFirmware_20_0_0) {
-            constexpr size_t ExtraSystemMemoryForAtmosphere_20_0_0 = 14_MB;
-            return base_pool_size - ExtraSystemMemoryForAtmosphere_20_0_0 - KTraceBufferSize;
-        } else {
-            constexpr size_t ExtraSystemMemoryForAtmosphere = 40_MB;
-            return base_pool_size - ExtraSystemMemoryForAtmosphere - KTraceBufferSize;
-        }
     }
 
     size_t KSystemControl::Init::GetMinimumNonSecureSystemPoolSize() {

libraries/libmesosphere/source/kern_initial_process.cpp

@@ -140,12 +140,14 @@ namespace ams::kern {
 
                         /* Add the previously reserved pages. */
                         if (src_pool == dst_pool && binary_pages != 0) {
-                            MESOSPHERE_R_ABORT_UNLESS(pg.AddBlock(KMemoryLayout::GetLinearPhysicalAddress(data), binary_pages));
+                            /* NOTE: Nintendo does not check the result of this operation. */
+                            pg.AddBlock(KMemoryLayout::GetLinearPhysicalAddress(data), binary_pages);
                         }
 
                         /* Add the previously unreserved pages. */
                         for (const auto &block : unreserve_pg) {
-                            MESOSPHERE_R_ABORT_UNLESS(pg.AddBlock(block.GetAddress(), block.GetNumPages()));
+                            /* NOTE: Nintendo does not check the result of this operation. */
+                            pg.AddBlock(block.GetAddress(), block.GetNumPages());
                         }
                     }
                     MESOSPHERE_ABORT_UNLESS(pg.GetNumPages() == static_cast<size_t>(params.code_num_pages));
@@ -285,7 +287,7 @@ namespace ams::kern {
             MESOSPHERE_INIT_ABORT_UNLESS(expected_size != 0);
 
             /* Ensure that the size we need to reserve is as we expect it to be. */
-            const u32 total_size = util::AlignUp(g_initial_process_binary_header.size, PageSize);
+            const size_t total_size = util::AlignUp(g_initial_process_binary_header.size, PageSize);
             MESOSPHERE_ABORT_UNLESS(total_size == expected_size);
             MESOSPHERE_ABORT_UNLESS(total_size <= InitialProcessBinarySizeMax);
 

libraries/libmesosphere/source/kern_k_code_memory.cpp

@@ -37,7 +37,7 @@ namespace ams::kern {
             /* Clear and store cache. */
             void * const block_address = GetVoidPointer(KMemoryLayout::GetLinearVirtualAddress(block.GetAddress()));
             std::memset(block_address, 0xFF, block.GetSize());
-            MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(block_address, block.GetSize()));
+            cpu::StoreDataCache(block_address, block.GetSize());
         }
 
         /* Set remaining tracking members. */

libraries/libmesosphere/source/kern_k_condition_variable.cpp

@@ -23,8 +23,8 @@ namespace ams::kern {
             return UserspaceAccess::CopyMemoryFromUserSize32Bit(out, GetVoidPointer(address));
         }
 
-        ALWAYS_INLINE bool WriteToUser(KProcessAddress address, u32 val) {
+        ALWAYS_INLINE bool WriteToUser(KProcessAddress address, const u32 *p) {
-            return UserspaceAccess::CopyMemoryToUserSize32Bit(GetVoidPointer(address), val);
+            return UserspaceAccess::CopyMemoryToUserSize32Bit(GetVoidPointer(address), p);
         }
 
         ALWAYS_INLINE bool UpdateLockAtomic(u32 *out, KProcessAddress address, u32 if_zero, u32 new_orr_mask) {
@@ -94,7 +94,7 @@ namespace ams::kern {
 
             /* Write the value to userspace. */
             Result result;
-            if (AMS_LIKELY(WriteToUser(addr, next_value))) {
+            if (AMS_LIKELY(WriteToUser(addr, std::addressof(next_value)))) {
                 result = ResultSuccess();
             } else {
                 result = svc::ResultInvalidCurrentMemory();
@@ -210,8 +210,8 @@ namespace ams::kern {
 
             /* If we have no waiters, clear the has waiter flag. */
             if (it == m_tree.end() || it->GetConditionVariableKey() != cv_key) {
-                constexpr u32 HasNoWaiterFlag = 0;
+                const u32 has_waiter_flag = 0;
-                WriteToUser(cv_key, HasNoWaiterFlag);
+                WriteToUser(cv_key, std::addressof(has_waiter_flag));
             }
         }
     }
@@ -252,13 +252,13 @@ namespace ams::kern {
 
                 /* Write to the cv key. */
                 {
-                    constexpr u32 HasWaiterFlag = 1;
+                    const u32 has_waiter_flag = 1;
-                    WriteToUser(key, HasWaiterFlag);
+                    WriteToUser(key, std::addressof(has_waiter_flag));
                     cpu::DataMemoryBarrierInnerShareable();
                 }
 
                 /* Write the value to userspace. */
-                if (!WriteToUser(addr, next_value)) {
+                if (!WriteToUser(addr, std::addressof(next_value))) {
                     slp.CancelSleep();
                     R_THROW(svc::ResultInvalidCurrentMemory());
                 }

libraries/libmesosphere/source/kern_k_debug_base.cpp

@@ -416,8 +416,7 @@ namespace ams::kern {
         KProcess * const target = this->GetProcessUnsafe();
 
         /* Terminate the process. */
-        /* NOTE: This result is seemingly-intentionally not checked by Nintendo. */
+        target->Terminate();
-        static_cast<void>(target->Terminate());
 
         R_SUCCEED();
     }
@@ -1134,7 +1133,7 @@ namespace ams::kern {
         R_SUCCEED();
     }
 
-    void KDebugBase::OnExitProcess(KProcess *process) {
+    Result KDebugBase::OnExitProcess(KProcess *process) {
         MESOSPHERE_ASSERT(process != nullptr);
 
         /* Check if we're attached to a debugger. */
@@ -1149,9 +1148,11 @@ namespace ams::kern {
                 debug->NotifyAvailable();
             }
         }
+
+        R_SUCCEED();
     }
 
-    void KDebugBase::OnTerminateProcess(KProcess *process) {
+    Result KDebugBase::OnTerminateProcess(KProcess *process) {
         MESOSPHERE_ASSERT(process != nullptr);
 
         /* Check if we're attached to a debugger. */
@@ -1166,17 +1167,21 @@ namespace ams::kern {
                 debug->NotifyAvailable();
             }
         }
+
+        R_SUCCEED();
     }
 
-    void KDebugBase::OnExitThread(KThread *thread) {
+    Result KDebugBase::OnExitThread(KThread *thread) {
         MESOSPHERE_ASSERT(thread != nullptr);
 
         /* Check if we're attached to a debugger. */
         if (KProcess *process = thread->GetOwnerProcess(); process != nullptr && process->IsAttachedToDebugger()) {
             /* If we are, submit the event. */
             const uintptr_t params[2] = { thread->GetId(), static_cast<uintptr_t>(thread->IsTerminationRequested() ? ams::svc::ThreadExitReason_TerminateThread : ams::svc::ThreadExitReason_ExitThread) };
-            static_cast<void>(OnDebugEvent(ams::svc::DebugEvent_ExitThread, params, util::size(params)));
+            R_TRY(OnDebugEvent(ams::svc::DebugEvent_ExitThread, params, util::size(params)));
         }
+
+        R_SUCCEED();
     }
 
 }

libraries/libmesosphere/source/kern_k_dpc_manager.cpp

@@ -167,7 +167,7 @@ namespace ams::kern {
         KThread::Register(new_thread);
 
         /* Run the thread. */
-        MESOSPHERE_R_ABORT_UNLESS(new_thread->Run());
+        new_thread->Run();
     }
 
     void KDpcManager::HandleDpc() {

libraries/libmesosphere/source/kern_k_event.cpp

@@ -38,20 +38,20 @@ namespace ams::kern {
         MESOSPHERE_ASSERT_THIS();
     }
 
-    void KEvent::Signal() {
+    Result KEvent::Signal() {
         KScopedSchedulerLock sl;
 
-        if (!m_readable_event_destroyed) {
+        R_SUCCEED_IF(m_readable_event_destroyed);
-            m_readable_event.Signal();
+
-        }
+        R_RETURN(m_readable_event.Signal());
     }
 
-    void KEvent::Clear() {
+    Result KEvent::Clear() {
         KScopedSchedulerLock sl;
 
-        if (!m_readable_event_destroyed) {
+        R_SUCCEED_IF(m_readable_event_destroyed);
-            m_readable_event.Clear();
+
-        }
+        R_RETURN(m_readable_event.Clear());
     }
 
     void KEvent::PostDestroy(uintptr_t arg) {

libraries/libmesosphere/source/kern_k_handle_table.cpp

@@ -17,7 +17,7 @@
 
 namespace ams::kern {
 
-    void KHandleTable::Finalize() {
+    Result KHandleTable::Finalize() {
         MESOSPHERE_ASSERT_THIS();
 
         /* Get the table and clear our record of it. */
@@ -35,6 +35,8 @@ namespace ams::kern {
                 obj->Close();
             }
         }
+
+        R_SUCCEED();
     }
 
     bool KHandleTable::Remove(ams::svc::Handle handle) {

libraries/libmesosphere/source/kern_k_page_table_base.cpp

@@ -88,7 +88,7 @@ namespace ams::kern {
         }
     }
 
-    void KPageTableBase::InitializeForKernel(bool is_64_bit, void *table, KVirtualAddress start, KVirtualAddress end) {
+    Result KPageTableBase::InitializeForKernel(bool is_64_bit, void *table, KVirtualAddress start, KVirtualAddress end) {
         /* Initialize our members. */
         m_address_space_width               = (is_64_bit) ? BITSIZEOF(u64) : BITSIZEOF(u32);
         m_address_space_start               = KProcessAddress(GetInteger(start));
@@ -130,7 +130,7 @@ namespace ams::kern {
         m_impl.InitializeForKernel(table, start, end);
 
         /* Initialize our memory block manager. */
-        MESOSPHERE_R_ABORT_UNLESS(m_memory_block_manager.Initialize(m_address_space_start, m_address_space_end, m_memory_block_slab_manager));
+        R_RETURN(m_memory_block_manager.Initialize(m_address_space_start, m_address_space_end, m_memory_block_slab_manager));
     }
 
     Result KPageTableBase::InitializeForProcess(ams::svc::CreateProcessFlag flags, bool from_back, KMemoryManager::Pool pool, void *table, KProcessAddress start, KProcessAddress end, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit) {
@@ -211,7 +211,6 @@ namespace ams::kern {
         /* Set other basic fields. */
         m_enable_aslr                       = (flags & ams::svc::CreateProcessFlag_EnableAslr) != 0;
         m_enable_device_address_space_merge = (flags & ams::svc::CreateProcessFlag_DisableDeviceAddressSpaceMerge) == 0;
-        m_allowed_exec_device_mapping       = false;
         m_address_space_start               = start;
         m_address_space_end                 = end;
         m_is_kernel                         = false;
@@ -1793,7 +1792,7 @@ namespace ams::kern {
         /* Ensure cache coherency, if we're setting pages as executable. */
         if (is_x) {
             for (const auto &block : pg) {
-                MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(GetVoidPointer(GetHeapVirtualAddress(block.GetAddress())), block.GetSize()));
+                cpu::StoreDataCache(GetVoidPointer(GetHeapVirtualAddress(block.GetAddress())), block.GetSize());
             }
             cpu::InvalidateEntireInstructionCache();
         }
@@ -2666,7 +2665,8 @@ namespace ams::kern {
 
                 /* Invalidate the block. */
                 if (cur_size > 0) {
-                    MESOSPHERE_R_ABORT_UNLESS(cpu::InvalidateDataCache(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), cur_size));
+                    /* NOTE: Nintendo does not check the result of invalidation. */
+                    cpu::InvalidateDataCache(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), cur_size);
                 }
 
                 /* Advance. */
@@ -2689,7 +2689,8 @@ namespace ams::kern {
 
         /* Invalidate the last block. */
         if (cur_size > 0) {
-            MESOSPHERE_R_ABORT_UNLESS(cpu::InvalidateDataCache(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), cur_size));
+            /* NOTE: Nintendo does not check the result of invalidation. */
+            cpu::InvalidateDataCache(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), cur_size);
         }
 
         R_SUCCEED();
@@ -2767,7 +2768,7 @@ namespace ams::kern {
             if (cur_size >= sizeof(u32)) {
                 const size_t copy_size = util::AlignDown(cur_size, sizeof(u32));
                 const void * copy_src  = GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr));
-                MESOSPHERE_R_ABORT_UNLESS(cpu::FlushDataCache(copy_src, copy_size));
+                cpu::FlushDataCache(copy_src, copy_size);
                 R_UNLESS(UserspaceAccess::CopyMemoryToUserAligned32Bit(buffer, copy_src, copy_size), svc::ResultInvalidPointer());
                 buffer    = reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(buffer) + copy_size);
                 cur_addr += copy_size;
@@ -2777,7 +2778,7 @@ namespace ams::kern {
             /* Copy remaining data. */
             if (cur_size > 0) {
                 const void * copy_src  = GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr));
-                MESOSPHERE_R_ABORT_UNLESS(cpu::FlushDataCache(copy_src, cur_size));
+                cpu::FlushDataCache(copy_src, cur_size);
                 R_UNLESS(UserspaceAccess::CopyMemoryToUser(buffer, copy_src, cur_size), svc::ResultInvalidPointer());
             }
 
@@ -2852,7 +2853,7 @@ namespace ams::kern {
             if (cur_size >= sizeof(u32)) {
                 const size_t copy_size = util::AlignDown(cur_size, sizeof(u32));
                 R_UNLESS(UserspaceAccess::CopyMemoryFromUserAligned32Bit(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), buffer, copy_size), svc::ResultInvalidCurrentMemory());
-                MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), copy_size));
+                cpu::StoreDataCache(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), copy_size);
 
                 buffer    = reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(buffer) + copy_size);
                 cur_addr += copy_size;
@@ -2862,7 +2863,7 @@ namespace ams::kern {
             /* Copy remaining data. */
             if (cur_size > 0) {
                 R_UNLESS(UserspaceAccess::CopyMemoryFromUser(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), buffer, cur_size), svc::ResultInvalidCurrentMemory());
-                MESOSPHERE_R_ABORT_UNLESS(cpu::StoreDataCache(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), cur_size));
+                cpu::StoreDataCache(GetVoidPointer(GetLinearMappedVirtualAddress(cur_addr)), cur_size);
             }
 
             R_SUCCEED();
@@ -3078,9 +3079,7 @@ namespace ams::kern {
         const u32 test_state = (is_aligned ? KMemoryState_FlagCanAlignedDeviceMap : KMemoryState_FlagCanDeviceMap) | (check_heap ? KMemoryState_FlagReferenceCounted : KMemoryState_None);
         size_t num_allocator_blocks;
         KMemoryState old_state;
-        const KMemoryPermission perm_mask = static_cast<KMemoryPermission>(perm | (m_allowed_exec_device_mapping ? KMemoryPermission_None : KMemoryPermission_UserExecute));
+        R_TRY(this->CheckMemoryState(std::addressof(old_state), nullptr, nullptr, std::addressof(num_allocator_blocks), address, size, test_state, test_state, perm, perm, KMemoryAttribute_IpcLocked | KMemoryAttribute_Locked, KMemoryAttribute_None, KMemoryAttribute_DeviceShared));
-        
-        R_TRY(this->CheckMemoryState(std::addressof(old_state), nullptr, nullptr, std::addressof(num_allocator_blocks), address, size, test_state, test_state, perm_mask, perm, KMemoryAttribute_IpcLocked | KMemoryAttribute_Locked, KMemoryAttribute_None, KMemoryAttribute_DeviceShared));
 
         /* Create an update allocator. */
         Result allocator_result;

libraries/libmesosphere/source/kern_k_process.cpp

@@ -185,11 +185,6 @@ namespace ams::kern {
         /* Validate that the intended kernel version isn't too high for us to support. */
         R_UNLESS(m_capabilities.GetIntendedKernelVersion() <= ams::svc::SupportedKernelVersion, svc::ResultInvalidCombination());
 
-        /* Enable mapping device pages as executable on legacy processes. */
-        if (m_capabilities.GetIntendedKernelMajorVersion() < 26) {
-            m_page_table.GetBasePageTable().AllowDeviceMappingOfExecPages();
-        }
-
         /* Create and clear the process local region. */
         R_TRY(this->CreateThreadLocalRegion(std::addressof(m_plr_address)));
         m_plr_heap_address = this->GetThreadLocalRegionPointer(m_plr_address);
@@ -409,7 +404,7 @@ namespace ams::kern {
 
     void KProcess::DoWorkerTaskImpl() {
         /* Terminate child threads. */
-        MESOSPHERE_R_ABORT_UNLESS(TerminateChildren(this, nullptr));
+        TerminateChildren(this, nullptr);
 
         /* Finalize the handle table, if we're not immortal. */
         if (!m_is_immortal && m_is_handle_table_initialized) {
@@ -425,7 +420,7 @@ namespace ams::kern {
 
     Result KProcess::StartTermination() {
         /* Finalize the handle table when we're done, if the process isn't immortal. */
-        ON_RESULT_SUCCESS {
+        ON_SCOPE_EXIT {
             if (!m_is_immortal) {
                 this->FinalizeHandleTable();
             }
@@ -476,7 +471,7 @@ namespace ams::kern {
 
         /* If we need to start termination, do so. */
         if (needs_terminate) {
-            static_cast<void>(this->StartTermination());
+            this->StartTermination();
 
             /* Note for debug that we're exiting the process. */
             MESOSPHERE_LOG("KProcess::Exit() pid=%ld name=%-12s\n", m_process_id, m_name);
@@ -512,26 +507,23 @@ namespace ams::kern {
 
         /* If we need to terminate, do so. */
         if (needs_terminate) {
-            /* If we fail to terminate, register as a worker task. */
+            /* Start termination. */
-            ON_RESULT_FAILURE {
+            if (R_SUCCEEDED(this->StartTermination())) {
+                /* Note for debug that we're terminating the process. */
+                MESOSPHERE_LOG("KProcess::Terminate() OK pid=%ld name=%-12s\n", m_process_id, m_name);
+
+                /* Call the debug callback. */
+                KDebug::OnTerminateProcess(this);
+
+                /* Finish termination. */
+                this->FinishTermination();
+            } else {
                 /* Note for debug that we're terminating the process. */
                 MESOSPHERE_LOG("KProcess::Terminate() FAIL pid=%ld name=%-12s\n", m_process_id, m_name);
 
                 /* Register the process as a work task. */
                 KWorkerTaskManager::AddTask(KWorkerTaskManager::WorkerType_ExitProcess, this);
-            };
+            }
-
-            /* Start termination. */
-            R_TRY(this->StartTermination());
-
-            /* Note for debug that we're terminating the process. */
-            MESOSPHERE_LOG("KProcess::Terminate() OK pid=%ld name=%-12s\n", m_process_id, m_name);
-
-            /* Call the debug callback. */
-            KDebug::OnTerminateProcess(this);
-
-            /* Finish termination. */
-            this->FinishTermination();
         }
 
         R_SUCCEED();
@@ -674,7 +666,7 @@ namespace ams::kern {
         R_SUCCEED();
     }
 
-    void KProcess::DeleteThreadLocalRegion(KProcessAddress addr) {
+    Result KProcess::DeleteThreadLocalRegion(KProcessAddress addr) {
         KThreadLocalPage *page_to_free = nullptr;
 
         /* Release the region. */
@@ -686,7 +678,7 @@ namespace ams::kern {
             if (it == m_partially_used_tlp_tree.end()) {
                 /* If we don't find it, it has to be in the fully used list. */
                 it = m_fully_used_tlp_tree.find_key(util::AlignDown(GetInteger(addr), PageSize));
-                MESOSPHERE_ABORT_UNLESS(it != m_fully_used_tlp_tree.end());
+                R_UNLESS(it != m_fully_used_tlp_tree.end(), svc::ResultInvalidAddress());
 
                 /* Release the region. */
                 it->Release(addr);
@@ -718,6 +710,8 @@ namespace ams::kern {
 
             KThreadLocalPage::Free(page_to_free);
         }
+
+        R_SUCCEED();
     }
 
     void *KProcess::GetThreadLocalRegionPointer(KProcessAddress addr) {
@@ -773,7 +767,7 @@ namespace ams::kern {
         MESOSPHERE_ASSERT(m_num_running_threads.Load() > 0);
 
         if (const auto prev = m_num_running_threads--; prev == 1) {
-            static_cast<void>(this->Terminate());
+            this->Terminate();
         }
     }
 
@@ -981,9 +975,6 @@ namespace ams::kern {
         /* Set the thread arguments. */
         main_thread->GetContext().SetArguments(0, thread_handle);
 
-        /* Pass the thread handle to the thread local region. */
-        static_cast<ams::svc::ThreadLocalRegion *>(main_thread->GetThreadLocalRegionHeapAddress())->thread_handle = thread_handle;
-
         /* Update our state. */
         this->ChangeState((state == State_Created) ? State_Running : State_RunningAttached);
         ON_RESULT_FAILURE_2 { this->ChangeState(state); };

libraries/libmesosphere/source/kern_k_readable_event.cpp

@@ -46,7 +46,7 @@ namespace ams::kern {
         }
     }
 
-    void KReadableEvent::Signal() {
+    Result KReadableEvent::Signal() {
         MESOSPHERE_ASSERT_THIS();
 
         KScopedSchedulerLock lk;
@@ -55,6 +55,8 @@ namespace ams::kern {
             m_is_signaled = true;
             this->NotifyAvailable();
         }
+
+        R_SUCCEED();
     }
 
     Result KReadableEvent::Reset() {

libraries/libmesosphere/source/kern_k_scheduler.cpp

@@ -65,7 +65,7 @@ namespace ams::kern {
         }
 
         /* Bind interrupt handler. */
-        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetInterruptManager().BindHandler(GetSchedulerInterruptHandler(), KInterruptName_Scheduler, m_core_id, KInterruptController::PriorityLevel_Scheduler, false, false));
+        Kernel::GetInterruptManager().BindHandler(GetSchedulerInterruptHandler(), KInterruptName_Scheduler, m_core_id, KInterruptController::PriorityLevel_Scheduler, false, false);
 
         /* Set the current thread. */
         m_current_thread = GetCurrentThreadPointer();
@@ -270,13 +270,7 @@ namespace ams::kern {
         m_current_thread = next_thread;
 
         /* Set the new Thread Local region. */
-        const auto tls_address = GetInteger(next_thread->GetThreadLocalRegionAddress());
+        cpu::SwitchThreadLocalRegion(GetInteger(next_thread->GetThreadLocalRegionAddress()));
-        cpu::SwitchThreadLocalRegion(tls_address);
-
-        /* Update the thread's cpu time differential in TLS, if relevant. */
-        if (tls_address != 0) {
-            static_cast<ams::svc::ThreadLocalRegion *>(next_thread->GetThreadLocalRegionHeapAddress())->thread_cpu_time = next_thread->GetCpuTime() - cur_tick;
-        }
     }
 
     void KScheduler::ClearPreviousThread(KThread *thread) {

libraries/libmesosphere/source/kern_k_server_session.cpp

@@ -476,8 +476,8 @@ namespace ams::kern {
 
                 /* Ensure that we clean up on failure. */
                 ON_RESULT_FAILURE {
-                    static_cast<void>(dst_page_table.CleanupForIpcServer(dst_address, size, dst_state));
+                    dst_page_table.CleanupForIpcServer(dst_address, size, dst_state);
-                    static_cast<void>(src_page_table.CleanupForIpcClient(src_address, size, dst_state));
+                    src_page_table.CleanupForIpcClient(src_address, size, dst_state);
                 };
 
                 /* Push the appropriate mapping. */
@@ -582,7 +582,7 @@ namespace ams::kern {
             /* Set up a guard to make sure that we end up in a clean state on error. */
             ON_RESULT_FAILURE {
                 /* Cleanup mappings. */
-                static_cast<void>(CleanupMap(request, std::addressof(dst_process), std::addressof(src_page_table)));
+                CleanupMap(request, std::addressof(dst_process), std::addressof(src_page_table));
 
                 /* Cleanup special data. */
                 if (src_header.GetHasSpecialHeader()) {
@@ -835,11 +835,11 @@ namespace ams::kern {
                             CleanupSpecialData(dst_process, dst_msg_ptr, dst_buffer_size);
                         }
                     } else {
-                        static_cast<void>(CleanupServerHandles(src_user ? src_message_buffer : 0, src_buffer_size, src_message_paddr));
+                        CleanupServerHandles(src_user ? src_message_buffer : 0, src_buffer_size, src_message_paddr);
                     }
 
                     /* Cleanup mappings. */
-                    static_cast<void>(CleanupMap(request, std::addressof(src_process), std::addressof(dst_page_table)));
+                    CleanupMap(request, std::addressof(src_process), std::addressof(dst_page_table));
                 };
 
                 /* Ensure that the headers fit. */
@@ -1052,7 +1052,7 @@ namespace ams::kern {
 
                     /* Unlock the client buffer. */
                     /* NOTE: Nintendo does not check the result of this. */
-                    static_cast<void>(client_pt.UnlockForIpcUserBuffer(client_message, client_buffer_size));
+                    client_pt.UnlockForIpcUserBuffer(client_message, client_buffer_size);
 
                     /* Signal the event. */
                     event->Signal();
@@ -1156,7 +1156,7 @@ namespace ams::kern {
 
                 /* Unlock the client buffer. */
                 /* NOTE: Nintendo does not check the result of this. */
-                static_cast<void>(client_page_table->UnlockForIpcUserBuffer(client_message, client_buffer_size));
+                client_page_table->UnlockForIpcUserBuffer(client_message, client_buffer_size);
 
                 /* Signal the event. */
                 event->Signal();
@@ -1284,7 +1284,7 @@ namespace ams::kern {
 
                     /* Unlock the client buffer. */
                     /* NOTE: Nintendo does not check the result of this. */
-                    static_cast<void>(client_page_table->UnlockForIpcUserBuffer(client_message, client_buffer_size));
+                    client_page_table->UnlockForIpcUserBuffer(client_message, client_buffer_size);
 
                     /* Signal the event. */
                     event->Signal();
@@ -1383,7 +1383,7 @@ namespace ams::kern {
 
                 /* Unlock the buffer. */
                 /* NOTE: Nintendo does not check the result of this. */
-                static_cast<void>(client_pt.UnlockForIpcUserBuffer(request->GetAddress(), request->GetSize()));
+                client_pt.UnlockForIpcUserBuffer(request->GetAddress(), request->GetSize());
 
                 /* Signal the event. */
                 event->Signal();

libraries/libmesosphere/source/kern_k_system_resource.cpp

@@ -42,7 +42,7 @@ namespace ams::kern {
         R_UNLESS(m_resource_size > rc_size, svc::ResultOutOfMemory());
 
         /* Initialize slab heaps. */
-        R_TRY(m_dynamic_page_manager.Initialize(m_resource_address + rc_size, m_resource_size - rc_size, PageSize));
+        m_dynamic_page_manager.Initialize(m_resource_address + rc_size, m_resource_size - rc_size, PageSize);
         m_page_table_heap.Initialize(std::addressof(m_dynamic_page_manager), 0, GetPointer<KPageTableManager::RefCount>(m_resource_address));
         m_memory_block_heap.Initialize(std::addressof(m_dynamic_page_manager), 0);
         m_block_info_heap.Initialize(std::addressof(m_dynamic_page_manager), 0);

libraries/libmesosphere/source/kern_k_thread.cpp

@@ -392,7 +392,7 @@ namespace ams::kern {
 
         /* If the thread has a local region, delete it. */
         if (m_tls_address != Null<KProcessAddress>) {
-            m_parent->DeleteThreadLocalRegion(m_tls_address);
+            MESOSPHERE_R_ABORT_UNLESS(m_parent->DeleteThreadLocalRegion(m_tls_address));
         }
 
         /* Release any waiters. */
@@ -697,7 +697,7 @@ namespace ams::kern {
         R_SUCCEED();
     }
 
-    void KThread::GetPhysicalCoreMask(int32_t *out_ideal_core, u64 *out_affinity_mask) {
+    Result KThread::GetPhysicalCoreMask(int32_t *out_ideal_core, u64 *out_affinity_mask) {
         MESOSPHERE_ASSERT_THIS();
         {
             KScopedSchedulerLock sl;
@@ -712,6 +712,8 @@ namespace ams::kern {
                 *out_affinity_mask = m_original_physical_affinity_mask.GetAffinityMask();
             }
         }
+
+        R_SUCCEED();
     }
 
     Result KThread::SetCoreMask(int32_t core_id, u64 v_affinity_mask) {
@@ -850,7 +852,7 @@ namespace ams::kern {
         }
     }
 
-    void KThread::SetPriorityToIdle() {
+    Result KThread::SetPriorityToIdle() {
         MESOSPHERE_ASSERT_THIS();
 
         KScopedSchedulerLock sl;
@@ -860,6 +862,8 @@ namespace ams::kern {
         m_priority      = IdleThreadPriority;
         m_base_priority = IdleThreadPriority;
         KScheduler::OnThreadPriorityChanged(this, old_priority);
+
+        R_SUCCEED();
     }
 
     void KThread::RequestSuspend(SuspendType type) {
@@ -1403,7 +1407,7 @@ namespace ams::kern {
         return this->GetState();
     }
 
-    void KThread::Sleep(s64 timeout) {
+    Result KThread::Sleep(s64 timeout) {
         MESOSPHERE_ASSERT_THIS();
         MESOSPHERE_ASSERT(!KScheduler::IsSchedulerLockedByCurrentThread());
         MESOSPHERE_ASSERT(this == GetCurrentThreadPointer());
@@ -1418,13 +1422,15 @@ namespace ams::kern {
             /* Check if the thread should terminate. */
             if (this->IsTerminationRequested()) {
                 slp.CancelSleep();
-                return;
+                R_THROW(svc::ResultTerminationRequested());
             }
 
             /* Wait for the sleep to end. */
             wait_queue.SetHardwareTimer(timer);
             this->BeginWait(std::addressof(wait_queue));
         }
+
+        R_SUCCEED();
     }
 
     void KThread::BeginWait(KThreadQueue *queue) {

libraries/libmesosphere/source/kern_k_thread_local_page.cpp

@@ -32,7 +32,7 @@ namespace ams::kern {
         R_RETURN(m_owner->GetPageTable().MapPages(std::addressof(m_virt_addr), 1, PageSize, page_buf->GetPhysicalAddress(), KMemoryState_ThreadLocal, KMemoryPermission_UserReadWrite));
     }
 
-    void KThreadLocalPage::Finalize() {
+    Result KThreadLocalPage::Finalize() {
         MESOSPHERE_ASSERT_THIS();
 
         /* Get the physical address of the page. */
@@ -40,10 +40,11 @@ namespace ams::kern {
         MESOSPHERE_ABORT_UNLESS(m_owner->GetPageTable().GetPhysicalAddress(std::addressof(phys_addr), this->GetAddress()));
 
         /* Unmap the page. */
-        MESOSPHERE_R_ABORT_UNLESS(m_owner->GetPageTable().UnmapPages(this->GetAddress(), 1, KMemoryState_ThreadLocal));
+        R_TRY(m_owner->GetPageTable().UnmapPages(this->GetAddress(), 1, KMemoryState_ThreadLocal));
 
         /* Free the page. */
         KPageBuffer::FreeChecked<PageSize>(KPageBuffer::FromPhysicalAddress(phys_addr));
+        R_SUCCEED();
     }
 
     KProcessAddress KThreadLocalPage::Reserve() {