git subrepo push libraries

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

.gitignore

@@ -38,6 +38,9 @@
 *.x86_64
 *.hex
 
+# Deko3d shaders
+*.dksh
+
 # Switch Executables
 *.nso
 *.nro

Makefile

@@ -64,6 +64,7 @@ dist-no-debug: all
 	mkdir -p atmosphere-$(AMSVER)/atmosphere/contents/0100000000000036
 	mkdir -p atmosphere-$(AMSVER)/atmosphere/contents/0100000000000037
 	mkdir -p atmosphere-$(AMSVER)/atmosphere/contents/010000000000003C
+	mkdir -p atmosphere-$(AMSVER)/atmosphere/contents/0100000000000042
 	mkdir -p atmosphere-$(AMSVER)/atmosphere/fatal_errors
 	mkdir -p atmosphere-$(AMSVER)/atmosphere/config_templates
 	mkdir -p atmosphere-$(AMSVER)/atmosphere/config
@@ -91,11 +92,13 @@ dist-no-debug: all
 	cp stratosphere/creport/creport.nsp atmosphere-$(AMSVER)/atmosphere/contents/0100000000000036/exefs.nsp
 	cp stratosphere/ro/ro.nsp atmosphere-$(AMSVER)/atmosphere/contents/0100000000000037/exefs.nsp
 	cp stratosphere/jpegdec/jpegdec.nsp atmosphere-$(AMSVER)/atmosphere/contents/010000000000003C/exefs.nsp
+	cp stratosphere/pgl/pgl.nsp atmosphere-$(AMSVER)/atmosphere/contents/0100000000000042/exefs.nsp
 	mkdir -p atmosphere-$(AMSVER)/atmosphere/contents/0100000000000032/flags
 	touch atmosphere-$(AMSVER)/atmosphere/contents/0100000000000032/flags/boot2.flag
 	mkdir -p atmosphere-$(AMSVER)/atmosphere/contents/0100000000000037/flags
 	touch atmosphere-$(AMSVER)/atmosphere/contents/0100000000000037/flags/boot2.flag
 	cp troposphere/reboot_to_payload/reboot_to_payload.nro atmosphere-$(AMSVER)/switch/reboot_to_payload.nro
+	cp troposphere/daybreak/daybreak.nro atmosphere-$(AMSVER)/switch/daybreak.nro
 	cd atmosphere-$(AMSVER); zip -r ../atmosphere-$(AMSVER).zip ./*; cd ../;
 	rm -r atmosphere-$(AMSVER)
 	mkdir out
@@ -141,6 +144,8 @@ dist: dist-no-debug
 	cp stratosphere/spl/spl.elf atmosphere-$(AMSVER)-debug/spl.elf
 	cp stratosphere/erpt/erpt.elf atmosphere-$(AMSVER)-debug/erpt.elf
 	cp stratosphere/jpegdec/jpegdec.elf atmosphere-$(AMSVER)-debug/jpegdec.elf
+	cp stratosphere/pgl/pgl.elf atmosphere-$(AMSVER)-debug/pgl.elf
+	cp troposphere/daybreak/daybreak.elf atmosphere-$(AMSVER)-debug/daybreak.elf
 	cd atmosphere-$(AMSVER)-debug; zip -r ../atmosphere-$(AMSVER)-debug.zip ./*; cd ../;
 	rm -r atmosphere-$(AMSVER)-debug
 	mv atmosphere-$(AMSVER)-debug.zip out/atmosphere-$(AMSVER)-debug.zip

docs/changelog.md

@@ -1,4 +1,54 @@
 # Changelog
+## 0.14.4
++ Several bugs were fixed involving the official jit sysmodule added in 10.0.0.
+  + A Process handle leak was fixed when JitPlugin NRRs were registered with the `ro` sysmodule.
+    + This prevented processes using jit from being able to exit, causing a full system freeze.
+  + The `sm` atmosphere extension to not unregister services when the server's connection is closed was special-case disabled for `jit:u`.
+    + This extension is normally desirable in order to allow more concurrent processes to exist (as only 0x40 sm connections may ever be concurrently open), but official jit sysmodule relies on the behavior.
+    + This would cause crashes on attempts to launch a program using jit services more than once per reboot.
++ General system stability improvements to enhance the user's experience.
+## 0.14.3
++ Support was added for 10.2.0.
++ General system stability improvements to enhance the user's experience.
+## 0.14.2
++ A bug was fixed that could cause a deadlock when installing mitm services.
+  + Fixing this required a breaking change to the client behavior when installing a mitm service, and so custom sysmodules which use mitm will need to be re-compiled to function properly.
++ A bug was fixed that caused atmosphere sysmodules to respond incorrectly when receiving invalid messages.
++ A bug was fixed that caused fatal auto-reboot timing to work improperly.
++ Support was added to fusee for loading binaries for `mesosphere`, atmosphère's reimplementation of the Nintendo Switch kernel.
+  + 0.14.2 does not include mesosphere, but those who are especially interested can build and test mesosphere themselves.
+  + In the future, to enable a sufficient testing period Atmosphère releases will distribute two zips for some time.
+    + One zip will use mesosphere, and the other will not.
+    + This will allow users who are interested to opt-in to mesosphere usage before it has been tested to be stable.
+  + When mesosphere is stable and well-tested, it will be enabled by default and Atmosphère's version will transition to 1.0.0.
++ General system stability improvements to enhance the user's experience.
+## 0.14.1
++ An issue was fixed in 0.14.0 that would cause a black screen on boot when the INI1's size was not aligned to 8 bytes.
++ General system stability improvements to enhance the user's experience.
+## 0.14.0
++ An API (`ams:su`) was added to allow homebrew to safely install system upgrades or downgrades.
+  + This is a re-implementation of the logic that `ns` uses to install gamecard system updates.
+  + Nintendo (and now atmosphère) uses an installation process that can recover no matter where a failure occurs, which should significantly improve the safety of custom system update installation.
++ Support was added to `exosphère` for running on Mariko hardware.
+  + **Please note**: Atmosphère still does not support Mariko, and should not be run on Mariko yet.
+    + Certain stratosphere components do not handle mariko-specific logic fully correctly yet, and may initialize or interact with hardware incorrectly.
+    + This will be fixed and support will be added over the remainder of the Summer.
++ A homebrew application (`daybreak`) was added that uses the system updater API (with thanks to @Adubbz for both design and implementation).
+  + `daybreak` is included with atmosphère, and functions as a safer/more accurate equivalent to e.g. ChoiDujourNX.
+  + Upgrades/downgrades can be installed from a folder containing the update NCAs on the SD card.
+  + Because the update logic functions identically to Nintendo's, `daybreak` will be safe to use on Mariko when the rest of atmosphère has support.
+  + **Please note**: Daybreak requires that meta (.cnmt) NCAs have the correct extension `.cnmt.nca`.
+    + This is because gamecard system update logic uses extension to determine whether to mount the content.
+    + [Several](https://gist.github.com/HookedBehemoth/df36b5970e1c5b1b512ec7bdd9043c6e) [scripts](https://gist.github.com/antiKk/279966c27fdfd9c7fe63b4ae410f89c4) have been made by community members to automatically rename folders with incorrect extensions.
++ A bug was fixed that would cause file-based emummc to throw an error (showing a hexdump) on boot.
+  + Major thanks to @hexkyz for tracking down and resolving this.
++ A number of minor issues were resolved, including:
+  + fusee now prints information to the screen when an error occurs, instead of getting stuck trying to initialize the display.
+  + A race condition in Horizon was worked around that could prevent boot under certain circumstances.
+  + A bug was fixed that would cause atmosphère modules to open ten copies of certain filesystems instead of one.
+    + This could cause object exhaustion under certain circumstances.
++ For those interested in atmosphère's future development plans, the project's [roadmap](https://github.com/Atmosphere-NX/Atmosphere/blob/ac9832c5ce7be5832f6d29f6564a9c03e7efd22f/docs/roadmap.md) was updated.
++ General system stability improvements to enhance the user's experience.
 ## 0.13.0
 + `exosphère`, atmosphère's secure monitor re-implementation, was completely re-written.
   + `exosphère` was the first component authored for the project in early 2018. It is written in C, and in a style very different from the rest of atmosphère's code.

docs/roadmap.md

@@ -1,12 +1,7 @@
 # Planned Features
 atmosphère has a number of features that are either works-in-progress or planned. Please note that while time-estimates are given, they are loose, and things may be completed sooner or later than advertised.
 
-The following descriptions were last updated on June 29th, 2020.
-
-## system updater homebrew
-* **Description**: A user homebrew making use of the new system updater api, so that users can actually use the new api in practice.
-* **Development Status**: Initial revision complete, pending re-write by Adubbz.
-* **Completion Time**: June-July 2020
+The following descriptions were last updated on July 7th, 2020.
 
 ## ams-on-mariko
 * **Description**: Atmosphere cannot run as-is on Mariko hardware. A large number of changes are needed in many components. Although secure monitor support is complete in exosphere, additional work is needed on the bootloader and stratosphere sides as well. Mariko support will also require further design thought; atmosphere's debugging design heavily relies on reboot-to-payload and (more generally) the ability to perform warmboot bootrom hax at will. This is not possible on Mariko, and will require a new design/software support for whatever solution is chosen.
@@ -20,7 +15,7 @@ The following descriptions were last updated on June 29th, 2020.
 
 ## mesosphere
 * **Description**: mesosphère is a reimplementation of the Horizon operating system's Kernel. It aims to provide an open-source reference for Nintendo's code.
-* **Development Status**: Under semi-active development by SciresM; temporarily on pause while the System Updater API is completed.
+* **Development Status**: Under active development by SciresM.
 * **Estimated Time**: Mid-to-Late 2020
 
 ## tma reimplementation
@@ -54,6 +49,10 @@ The following features were previously included under the planned features secti
 
 Please note that this is not an exhaustive list of features present in atmosphère, and only serves to indicate what from the above has been completed.
 
+## system updater homebrew
+* **Description**: A user homebrew making use of the new system updater api, so that users can actually use the new api in practice.
+* **Completion Time**: July 2020
+
 ## system updater api
 * **Description**: A planned extension api for stratosphere (tenatively `ams:su`), this will provide an interface for homebrew to safely install system upgrades or downgrades. This will allow for much more easily transitioning safely between different versions of the operating system.
 * **Completion Time**: June 2020

emummc/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/m4xw/emuMMC
 	branch = exo2
-	commit = 06ab9b895c4264ecc14d3bf9be1260e2096f6037
-	parent = dccd41f6d25498c191a157123a27724203d3bc37
+	commit = 6a814ebbe72cf5245b863b9edea9cd3801437a12
+	parent = f551ca4461a79908c37307db10cd8cacf8b98f17
 	method = rebase
 	cmdver = 0.4.1

emummc/source/FS/FS_offsets.c

@@ -47,6 +47,8 @@
 #include "offsets/910_exfat.h"
 #include "offsets/1000.h"
 #include "offsets/1000_exfat.h"
+#include "offsets/1020.h"
+#include "offsets/1020_exfat.h"
 #include "../utils/fatal.h"
 
 #define GET_OFFSET_STRUCT_NAME(vers) g_offsets##vers
@@ -104,6 +106,8 @@ DEFINE_OFFSET_STRUCT(_910);
 DEFINE_OFFSET_STRUCT(_910_EXFAT);
 DEFINE_OFFSET_STRUCT(_1000);
 DEFINE_OFFSET_STRUCT(_1000_EXFAT);
+DEFINE_OFFSET_STRUCT(_1020);
+DEFINE_OFFSET_STRUCT(_1020_EXFAT);
 
 const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
     switch (version) {
@@ -169,6 +173,10 @@ const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
             return &(GET_OFFSET_STRUCT_NAME(_1000));
         case FS_VER_10_0_0_EXFAT:
             return &(GET_OFFSET_STRUCT_NAME(_1000_EXFAT));
+        case FS_VER_10_2_0:
+            return &(GET_OFFSET_STRUCT_NAME(_1020));
+        case FS_VER_10_2_0_EXFAT:
+            return &(GET_OFFSET_STRUCT_NAME(_1020_EXFAT));
         default:
             fatal_abort(Fatal_UnknownVersion);
     }

emummc/source/FS/FS_versions.h

@@ -68,6 +68,9 @@ enum FS_VER
     FS_VER_10_0_0,
     FS_VER_10_0_0_EXFAT,
 
+    FS_VER_10_2_0,
+    FS_VER_10_2_0_EXFAT,
+
     FS_VER_MAX,
 };
 

emummc/source/FS/offsets/1020.h

@@ -0,0 +1,58 @@
+/*
+ * 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_1020_H__
+#define __FS_1020_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_1020_SDMMC_ACCESSOR_GC   0x14E0F0
+#define FS_OFFSET_1020_SDMMC_ACCESSOR_SD   0x14C200
+#define FS_OFFSET_1020_SDMMC_ACCESSOR_NAND 0x147080
+
+// Hooks
+#define FS_OFFSET_1020_SDMMC_WRAPPER_READ  0x1427E0
+#define FS_OFFSET_1020_SDMMC_WRAPPER_WRITE 0x1428C0
+#define FS_OFFSET_1020_RTLD                0x634
+#define FS_OFFSET_1020_RTLD_DESTINATION    0x9C
+
+#define FS_OFFSET_1020_CLKRST_SET_MIN_V_CLK_RATE 0x141A00
+
+// Misc funcs
+#define FS_OFFSET_1020_LOCK_MUTEX          0x28910
+#define FS_OFFSET_1020_UNLOCK_MUTEX        0x28960
+
+#define FS_OFFSET_1020_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x142740
+
+// Misc Data
+#define FS_OFFSET_1020_SD_MUTEX            0xE273E8
+#define FS_OFFSET_1020_NAND_MUTEX          0xE22DA0
+#define FS_OFFSET_1020_ACTIVE_PARTITION    0xE22DE0
+#define FS_OFFSET_1020_SDMMC_DAS_HANDLE    0xE0AB90
+
+// NOPs
+#define FS_OFFSET_1020_SD_DAS_INIT         0x15214C
+
+// Nintendo Paths
+#define FS_OFFSET_1020_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x0006BBA4, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x00078520, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x0007ED0C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0009115C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_1020_H__

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

@@ -0,0 +1,58 @@
+/*
+ * 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_1020_EXFAT_H__
+#define __FS_1020_EXFAT_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_1020_EXFAT_SDMMC_ACCESSOR_GC   0x14E0F0
+#define FS_OFFSET_1020_EXFAT_SDMMC_ACCESSOR_SD   0x14C200
+#define FS_OFFSET_1020_EXFAT_SDMMC_ACCESSOR_NAND 0x147080
+
+// Hooks
+#define FS_OFFSET_1020_EXFAT_SDMMC_WRAPPER_READ  0x1427E0
+#define FS_OFFSET_1020_EXFAT_SDMMC_WRAPPER_WRITE 0x1428C0
+#define FS_OFFSET_1020_EXFAT_RTLD                0x634
+#define FS_OFFSET_1020_EXFAT_RTLD_DESTINATION    0x9C
+
+#define FS_OFFSET_1020_EXFAT_CLKRST_SET_MIN_V_CLK_RATE 0x141A00
+
+// Misc funcs
+#define FS_OFFSET_1020_EXFAT_LOCK_MUTEX          0x28910
+#define FS_OFFSET_1020_EXFAT_UNLOCK_MUTEX        0x28960
+
+#define FS_OFFSET_1020_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x142740
+
+// Misc Data
+#define FS_OFFSET_1020_EXFAT_SD_MUTEX            0xE353E8
+#define FS_OFFSET_1020_EXFAT_NAND_MUTEX          0xE30DA0
+#define FS_OFFSET_1020_EXFAT_ACTIVE_PARTITION    0xE30DE0
+#define FS_OFFSET_1020_EXFAT_SDMMC_DAS_HANDLE    0xE18B90
+
+// NOPs
+#define FS_OFFSET_1020_EXFAT_SD_DAS_INIT         0x15214C
+
+// Nintendo Paths
+#define FS_OFFSET_1020_EXFAT_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x0006BBA4, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x00078520, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x0007ED0C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0009115C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_1020_EXFAT_H__

exosphere/loader_stub/Makefile

@@ -24,23 +24,9 @@ export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
 			$(foreach dir,$(DATA),$(CURDIR)/$(dir)) \
             $(TOPDIR)/../program
 
-CFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.c)) $(notdir $(wildcard $(dir)/*.board.*.c)) $(notdir $(wildcard $(dir)/*.os.*.c)), \
-                                                      $(notdir $(wildcard $(dir)/*.c))))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).c)))
-
-CPPFILES    :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.cpp)) $(notdir $(wildcard $(dir)/*.board.*.cpp)) $(notdir $(wildcard $(dir)/*.os.*.cpp)), \
-                                                      $(notdir $(wildcard $(dir)/*.cpp))))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).cpp)))
-
-SFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.s)) $(notdir $(wildcard $(dir)/*.board.*.s)) $(notdir $(wildcard $(dir)/*.os.*.s)), \
-                                                      $(notdir $(wildcard $(dir)/*.s))))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).s)))
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
 
 BINFILES    := program.lz4 boot_code.lz4
 

exosphere/loader_stub/source/secmon_loader_error.cpp

@@ -19,10 +19,12 @@
 namespace ams::diag {
 
     NORETURN void AbortImpl(const char *file, int line, const char *func, const char *expr, u64 value, const char *format, ...) {
+        AMS_UNUSED(file, line, func, expr, value, format);
         ams::secmon::loader::ErrorReboot();
     }
 
     NORETURN void AbortImpl(const char *file, int line, const char *func, const char *expr, u64 value) {
+        AMS_UNUSED(file, line, func, expr, value);
         ams::secmon::loader::ErrorReboot();
     }
 

exosphere/program/Makefile

@@ -25,23 +25,9 @@ export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
 			$(TOPDIR)/sc7fw \
 			$(TOPDIR)/rebootstub
 
-CFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.c)) $(notdir $(wildcard $(dir)/*.board.*.c)) $(notdir $(wildcard $(dir)/*.os.*.c)), \
-                                                      $(notdir $(wildcard $(dir)/*.c))))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).c)))
-
-CPPFILES    :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.cpp)) $(notdir $(wildcard $(dir)/*.board.*.cpp)) $(notdir $(wildcard $(dir)/*.os.*.cpp)), \
-                                                      $(notdir $(wildcard $(dir)/*.cpp))))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).cpp)))
-
-SFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.s)) $(notdir $(wildcard $(dir)/*.board.*.s)) $(notdir $(wildcard $(dir)/*.os.*.s)), \
-                                                      $(notdir $(wildcard $(dir)/*.s))))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).s)))
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
 
 BINFILES    := sc7fw.bin rebootstub.bin
 

exosphere/program/rebootstub/Makefile

@@ -23,23 +23,9 @@ export DEPSDIR  :=  $(CURDIR)/$(BUILD)
 export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
 			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
 
-CFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.c)) $(notdir $(wildcard $(dir)/*.board.*.c)) $(notdir $(wildcard $(dir)/*.os.*.c)), \
-                                                      $(notdir $(wildcard $(dir)/*.c))))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).c)))
-
-CPPFILES    :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.cpp)) $(notdir $(wildcard $(dir)/*.board.*.cpp)) $(notdir $(wildcard $(dir)/*.os.*.cpp)), \
-                                                      $(notdir $(wildcard $(dir)/*.cpp))))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).cpp)))
-
-SFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.s)) $(notdir $(wildcard $(dir)/*.board.*.s)) $(notdir $(wildcard $(dir)/*.os.*.s)), \
-                                                      $(notdir $(wildcard $(dir)/*.s))))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).s)))
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
 
 #---------------------------------------------------------------------------------
 # use CXX for linking C++ projects, CC for standard C

exosphere/program/sc7fw/Makefile

@@ -23,23 +23,9 @@ export DEPSDIR  :=  $(CURDIR)/$(BUILD)
 export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
 			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
 
-CFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.c)) $(notdir $(wildcard $(dir)/*.board.*.c)) $(notdir $(wildcard $(dir)/*.os.*.c)), \
-                                                      $(notdir $(wildcard $(dir)/*.c))))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).c)))
-
-CPPFILES    :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.cpp)) $(notdir $(wildcard $(dir)/*.board.*.cpp)) $(notdir $(wildcard $(dir)/*.os.*.cpp)), \
-                                                      $(notdir $(wildcard $(dir)/*.cpp))))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).cpp)))
-
-SFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.s)) $(notdir $(wildcard $(dir)/*.board.*.s)) $(notdir $(wildcard $(dir)/*.os.*.s)), \
-                                                      $(notdir $(wildcard $(dir)/*.s))))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).s)))
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
 
 #---------------------------------------------------------------------------------
 # use CXX for linking C++ projects, CC for standard C

exosphere/program/sc7fw/source/sc7fw_main.cpp

@@ -90,7 +90,7 @@ namespace ams::sc7fw {
             reg::ReadWrite(PMC + APBDEV_PMC_DPD_ENABLE, PMC_REG_BITS_ENUM(DPD_ENABLE_ON, ENABLE));
 
             /* Wait forever until we're asleep. */
-            while (true) { /* ... */ }
+            AMS_INFINITE_LOOP();
         }
 
     }
@@ -102,7 +102,9 @@ namespace ams::sc7fw {
     NORETURN void ExceptionHandler() {
         /* Write enable to MAIN_RESET. */
         reg::Write(PMC + APBDEV_PMC_CNTRL, PMC_REG_BITS_ENUM(CNTRL_MAIN_RESET, ENABLE));
-        while (true) { /* ... */ }
+
+        /* Wait forever until we're reset. */
+        AMS_INFINITE_LOOP();
     }
 
 }

exosphere/program/source/boot/secmon_boot_setup.cpp

@@ -48,7 +48,12 @@ namespace ams::secmon::boot {
             const auto pmc = MemoryRegionVirtualDevicePmc.GetAddress();
 
             /* Set the physical address of the warmboot binary to scratch 1. */
-            reg::Write(pmc + APBDEV_PMC_SCRATCH1, static_cast<u32>(MemoryRegionPhysicalDramSecureDataStoreWarmbootFirmware.GetAddress()));
+            if (GetSocType() == fuse::SocType_Mariko) {
+                reg::Write(pmc + APBDEV_PMC_SECURE_SCRATCH119, static_cast<u32>(MemoryRegionPhysicalDramSecureDataStoreWarmbootFirmware.GetAddress()));
+            } else /* if (GetSocType() == fuse::SocType_Erista) */ {
+                reg::Write(pmc + APBDEV_PMC_SCRATCH1, static_cast<u32>(MemoryRegionPhysicalDramSecureDataStoreWarmbootFirmware.GetAddress()));
+            }
+
 
             /* Configure logging by setting bits 18-19 of scratch 20. */
             reg::ReadWrite(pmc + APBDEV_PMC_SCRATCH20, REG_BITS_VALUE(18, 2, 0));
@@ -66,6 +71,7 @@ namespace ams::secmon::boot {
             /* The warmboot key as a parameter. The latter is a better solution, but it would be nice to take */
             /* care of it here. Perhaps we should read the number of anti-downgrade fuses burnt, and translate that */
             /* to the warmboot key? To be decided during the process of implementing ams-on-mariko support. */
+            reg::Write(pmc + APBDEV_PMC_SECURE_SCRATCH32, 0x129);
         }
 
         constinit const u8 DeviceMasterKeySourceKekSource[se::AesBlockSize] = {
@@ -79,6 +85,8 @@ namespace ams::secmon::boot {
             if constexpr (false) {
                 /* TODO: Consider implementing this as a reference. */
             }
+
+            AMS_UNUSED(is_prod);
         }
 
         /* NOTE: These are just latest-master-kek encrypted with BEK. */
@@ -92,6 +100,10 @@ namespace ams::secmon::boot {
             0xF9, 0x37, 0xCF, 0x9A, 0xBD, 0x86, 0xBB, 0xA9, 0x9C, 0x9E, 0x03, 0xC4, 0xFC, 0xBC, 0x3B, 0xCE
         };
 
+        constinit const u8 MasterKeySource[se::AesBlockSize] = {
+            0xD8, 0xA2, 0x41, 0x0A, 0xC6, 0xC5, 0x90, 0x01, 0xC6, 0x1D, 0x6A, 0x26, 0x7C, 0x51, 0x3F, 0x3C
+        };
+
         void DeriveMasterKekAndDeviceKeyMariko(bool is_prod) {
             /* Clear all keyslots other than KEK and SBK in SE1. */
             for (int i = 0; i < pkg1::AesKeySlot_Count; ++i) {
@@ -123,6 +135,14 @@ namespace ams::secmon::boot {
             }
         }
 
+        void DeriveMasterKey() {
+            if (GetSocType() == fuse::SocType_Mariko) {
+                se::SetEncryptedAesKey128(pkg1::AesKeySlot_Master, pkg1::AesKeySlot_MasterKek, MasterKeySource, se::AesBlockSize);
+            } else /* if (GetSocType() == fuse::SocType_Erista) */ {
+                /* Nothing to do here; erista bootloader will have derived master key already. */
+            }
+        }
+
         void SetupRandomKey(int slot, se::KeySlotLockFlags flags) {
             /* Create an aligned buffer to hold the key. */
             constexpr size_t KeySize = se::AesBlockSize;
@@ -312,6 +332,9 @@ namespace ams::secmon::boot {
             /* Derive the master keys. */
             DeriveAllMasterKeys(is_prod, work_block);
 
+            /* Lock the master key as a kek. */
+            se::LockAesKeySlot(pkg1::AesKeySlot_Master, se::KeySlotLockFlags_AllLockKek);
+
             /* Derive the device master keys. */
             DeriveAllDeviceMasterKeys(is_prod, work_block);
 
@@ -357,7 +380,10 @@ namespace ams::secmon::boot {
             /* Lock the device key as only usable as a kek. */
             se::LockAesKeySlot(pkg1::AesKeySlot_Device, se::KeySlotLockFlags_AllLockKek);
 
-            /* Derive all keys. */
+            /* Derive the master key. */
+            DeriveMasterKey();
+
+            /* Derive all other keys. */
             DeriveAllKeys(is_prod);
         }
 
@@ -382,6 +408,7 @@ namespace ams::secmon::boot {
 
         constexpr void UnmapDramImpl(u64 *l1, u64 *l2, u64 *l3) {
             /* Unmap the L1 entry corresponding to to the Dram entries. */
+            AMS_UNUSED(l2, l3);
             InvalidateL1Entries(l1, MemoryRegionDram.GetAddress(), MemoryRegionDram.GetSize());
         }
 

exosphere/program/source/secmon_error.cpp

@@ -16,10 +16,24 @@
 #include <exosphere.hpp>
 #include "secmon_error.hpp"
 
-namespace {
+namespace ams {
 
-    constexpr bool SaveSystemStateForDebug = false;
+    namespace {
 
+        constexpr bool SaveSystemStateForDebug = false;
+        constexpr bool LogSystemStateForDebug = false;
+
+        void LogU64(u64 value) {
+            char buffer[2 * sizeof(value)];
+            for (size_t i = 0; i < sizeof(value); ++i) {
+                buffer[sizeof(buffer) - 1 - (2 * i) - 0] = "0123456789ABCDEF"[(value >> 0) & 0xF];
+                buffer[sizeof(buffer) - 1 - (2 * i) - 1] = "0123456789ABCDEF"[(value >> 4) & 0xF];
+                value >>= 8;
+            }
+            log::SendText(buffer, sizeof(buffer));
+        }
+
+    }
 }
 
 namespace ams::diag {
@@ -98,6 +112,57 @@ namespace ams::secmon {
             util::WaitMicroSeconds(1000);
         }
 
+        ALWAYS_INLINE void LogSystemStateForDebugErrorReboot(u64 lr, u64 sp) {
+            log::SendText("*** Error Reboot ***\n", 21);
+            log::Flush();
+
+            u64 temp_reg;
+
+            __asm__ __volatile__("mrs %0, esr_el3" : "=r"(temp_reg) :: "memory");
+            log::SendText("ESR_EL3: ", 9);
+            LogU64(temp_reg);
+            log::SendText("\n", 1);
+            log::Flush();
+
+            __asm__ __volatile__("mrs %0, elr_el3" : "=r"(temp_reg) :: "memory");
+            log::SendText("ELR_EL3: ", 9);
+            LogU64(temp_reg);
+            log::SendText("\n", 1);
+            log::Flush();
+
+            __asm__ __volatile__("mrs %0, far_el3" : "=r"(temp_reg) :: "memory");
+            log::SendText("FAR_EL3: ", 9);
+            LogU64(temp_reg);
+            log::SendText("\n", 1);
+            log::Flush();
+
+            log::SendText("LR:      ", 9);
+            LogU64(lr);
+            log::SendText("\n", 1);
+            log::Flush();
+
+            log::SendText("SP:      ", 9);
+            LogU64(sp);
+            log::SendText("\n", 1);
+            log::Flush();
+
+            log::SendText("Stack:\n", 7);
+            log::Flush();
+
+            char buf[2];
+            for (int i = 0; i < 0x100; ++i) {
+                const u8 byte = *(volatile u8 *)(sp + i);
+                buf[0] = "0123456789ABCDEF"[(byte >> 4) & 0xF];
+                buf[1] = "0123456789ABCDEF"[(byte >> 0) & 0xF];
+                log::SendText(buf, 2);
+                log::Flush();
+                if (util::IsAligned(i + 1, 0x10)) {
+                    log::SendText("\n", 1);
+                    log::Flush();
+                }
+            }
+        }
+
     }
 
     void SetError(pkg1::ErrorInfo info) {
@@ -114,6 +179,14 @@ namespace ams::secmon {
             SaveSystemStateForDebugErrorReboot();
         }
 
+        if constexpr (LogSystemStateForDebug) {
+            u64 lr, sp;
+            __asm__ __volatile__("mov %0, lr" : "=r"(lr) :: "memory");
+            __asm__ __volatile__("mov %0, sp" : "=r"(sp) :: "memory");
+
+            LogSystemStateForDebugErrorReboot(lr, sp);
+        }
+
         /* Lockout the security engine. */
         se::Lockout();
 

exosphere/program/source/secmon_map.cpp

@@ -41,6 +41,7 @@ namespace ams::secmon {
 
         constexpr void UnmapBootCodeImpl(u64 *l1, u64 *l2, u64 *l3, uintptr_t boot_code, size_t boot_code_size) {
             /* Unmap the L3 entries corresponding to the boot code. */
+            AMS_UNUSED(l1, l2);
             InvalidateL3Entries(l3, boot_code, boot_code_size);
         }
 

exosphere/program/source/secmon_setup.cpp

@@ -51,27 +51,27 @@ namespace ams::secmon {
 
         constinit bool g_is_cold_boot = true;
 
-        constinit const se::StickyBits ExpectedSeStickyBits = {
+        constinit se::StickyBits ExpectedSeStickyBits = {
             .se_security            = (1 << 0), /* SE_HARD_SETTING */
             .tzram_security         = 0,
             .crypto_security_perkey = (1 << pkg1::AesKeySlot_UserEnd) - 1,
             .crypto_keytable_access = {
-                (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  0: User    keyslot. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
-                (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  1: User    keyslot. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
-                (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  2: User    keyslot. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
-                (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  3: User    keyslot. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
-                (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  4: User    keyslot. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
-                (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  5: User    keyslot. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
-                (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /*  6: Unused  keyslot. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
-                (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /*  7: Unused  keyslot. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
-                (0 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  8: Temp    keyslot. UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. KEYUSE, UIVREAD, OIVREAD, KEYREAD disabled. */
-                (0 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  9: SmcTemp keyslot. UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. KEYUSE, UIVREAD, OIVREAD, KEYREAD disabled. */
-                (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 10: Wrap1   keyslot. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
-                (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 11: Wrap2   keyslot. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
-                (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 12: DMaster keyslot. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
-                (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 13: Master  keyslot. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
-                (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 14: Unused  keyslot. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
-                (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 13: Device  keyslot. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
+                (0 << 7) | (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  0: User    keyslot. KEY. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
+                (0 << 7) | (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  1: User    keyslot. KEY. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
+                (0 << 7) | (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  2: User    keyslot. KEY. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
+                (0 << 7) | (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  3: User    keyslot. KEY. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
+                (0 << 7) | (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  4: User    keyslot. KEY. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
+                (0 << 7) | (1 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  5: User    keyslot. KEY. KEYUSE, UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. UIVREAD, OIVREAD, KEYREAD disabled. */
+                (1 << 7) | (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /*  6: Unused  keyslot. KEK. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
+                (1 << 7) | (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /*  7: Unused  keyslot. KEK. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
+                (0 << 7) | (0 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  8: Temp    keyslot. KEY. UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. KEYUSE, UIVREAD, OIVREAD, KEYREAD disabled. */
+                (0 << 7) | (0 << 6) | (1 << 5) | (0 << 4) | (1 << 3) | (0 << 2) | (1 << 1) | (0 << 0), /*  9: SmcTemp keyslot. KEY. UIVUPDATE, OIVUPDATE, KEYUPDATE enabled. KEYUSE, UIVREAD, OIVREAD, KEYREAD disabled. */
+                (1 << 7) | (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 10: Wrap1   keyslot. KEK. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
+                (0 << 7) | (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 11: Wrap2   keyslot. KEY. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
+                (1 << 7) | (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 12: DMaster keyslot. KEK. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
+                (1 << 7) | (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 13: Master  keyslot. KEK. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
+                (1 << 7) | (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 14: Unused  keyslot. KEK. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
+                (1 << 7) | (0 << 6) | (0 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (0 << 1) | (0 << 0), /* 13: Device  keyslot. KEK. KEYUSE, UIVUPDATE, UIVREAD, OIVUPDATE, OIVREAD, KEYUPDATE, KEYREAD disabled. */
             },
             .rsa_security_perkey = 0,
             .rsa_keytable_access = {
@@ -139,6 +139,16 @@ namespace ams::secmon {
         }
 
         void VerifySecurityEngineStickyBits() {
+            /* On mariko, an extra sticky bit is set. */
+            if (GetSocType() == fuse::SocType_Mariko) {
+                ExpectedSeStickyBits.se_security |= (1 << 5);
+            } else /* if (GetSocType() == fuse::SocType_Erista) */ {
+                /* Erista does not support DST_KEYTABLE_ONLY, and so all keys will have the bit clear. */
+                for (size_t i = 0; i < util::size(ExpectedSeStickyBits.crypto_keytable_access); ++i) {
+                    ExpectedSeStickyBits.crypto_keytable_access[i] &= ~(1 << 7);
+                }
+            }
+
             if (!se::ValidateStickyBits(ExpectedSeStickyBits)) {
                 SetError(pkg1::ErrorInfo_InvalidSecurityEngineStickyBits);
                 AMS_ABORT("Invalid sticky bits");
@@ -938,12 +948,16 @@ namespace ams::secmon {
             return reg::Read(MC + MC_SECURITY_CFG3) == 0;
         }
 
+        void SetupLogForBoot() {
+            log::Initialize();
+            log::SendText("OHAYO\n", 6);
+            log::Flush();
+        }
+
         void LogExitLp0() {
             /* NOTE: Nintendo only does this on dev, but we will always do it. */
             if (true /* !pkg1::IsProduction() */) {
-                log::Initialize();
-                log::SendText("OHAYO\n", 6);
-                log::Flush();
+                SetupLogForBoot();
             }
         }
 
@@ -969,7 +983,7 @@ namespace ams::secmon {
         InitializeConfigurationContext();
 
         /* Initialize uart for logging. */
-        log::Initialize();
+        SetupLogForBoot();
 
         /* Initialize the security engine. */
         se::Initialize();
@@ -1017,12 +1031,16 @@ namespace ams::secmon {
 
         /* Overwrite keys that we want to be random with random contents. */
         se::InitializeRandom();
+        se::ConfigureAutomaticContextSave();
         se::SetRandomKey(pkg1::AesKeySlot_Temporary);
         se::GenerateSrk();
         se::SetRandomKey(pkg1::AesKeySlot_TzramSaveKek);
 
         /* Initialize pmc secure scratch. */
-        pmc::InitializeRandomScratch();
+        if (GetSocType() == fuse::SocType_Erista) {
+            pmc::InitializeRandomScratch();
+        }
+        pmc::LockSecureRegister(pmc::SecureRegister_Srk);
 
         /* Setup secure registers. */
         SetupSecureRegisters();

exosphere/program/source/smc/secmon_smc_info.cpp

@@ -262,6 +262,11 @@ namespace ams::secmon::smc {
                     /* Get whether this unit should allow writing to the calibration partition. */
                     args.r[1] = (GetEmummcConfiguration().IsEmummcActive() || GetSecmonConfiguration().AllowWritingToCalibrationBinarySysmmc());
                     break;
+                case ConfigItem::ExosphereEmummcType:
+                    /* Get what kind of emummc this unit has active. */
+                    /* NOTE: This may return values other than 1 in the future. */
+                    args.r[1] = (GetEmummcConfiguration().IsEmummcActive() ? 1 : 0);
+                    break;
                 default:
                     return SmcResult::InvalidArgument;
             }

exosphere/program/source/smc/secmon_smc_info.hpp

@@ -47,6 +47,7 @@ namespace ams::secmon::smc {
         ExosphereHasRcmBugPatch = 65004,
         ExosphereBlankProdInfo  = 65005,
         ExosphereAllowCalWrites = 65006,
+        ExosphereEmummcType     = 65007,
     };
 
     SmcResult SmcGetConfigUser(SmcArguments &args);

exosphere/program/source/smc/secmon_smc_memory_access.cpp

@@ -69,6 +69,7 @@ namespace ams::secmon::smc {
 
     SmcResult SmcWriteAddress(SmcArguments &args) {
         /* NOTE: This smc was deprecated in Atmosphère 0.13.0. */
+        AMS_UNUSED(args);
         return SmcResult::NotImplemented;
     }
 

exosphere/program/source/smc/secmon_smc_power_management.cpp

@@ -492,6 +492,8 @@ namespace ams::secmon::smc {
     }
 
     SmcResult SmcPowerOffCpu(SmcArguments &args) {
+        AMS_UNUSED(args);
+
         /* Get the current core id. */
         const auto core_id = hw::GetCurrentCoreId();
 

exosphere/program/source/smc/secmon_smc_register_access.cpp

@@ -155,10 +155,27 @@ namespace ams::secmon::smc {
         /* Find the access table. */
         const AccessTableEntry * const entry = GetAccessTableEntry(address);
 
-        /* If we have a table, perform the write. */
+        /* Translate our entry into an address to access. */
+        uintptr_t virtual_address = 0;
         if (entry != nullptr) {
             /* Get the address to read or write. */
-            const uintptr_t virtual_address = entry->virtual_address + (address - entry->address);
+            virtual_address = entry->virtual_address + (address - entry->address);
+        } else {
+            /* For no clearly discernable reason, SmcReadWriteRegister returns success despite not doing the read/write */
+            /* when accessing the SMMU controls for the BPMP and for APB-DMA. */
+            /* This is "probably" to fuck with hackers who got access to the SMC and are trying to get control of the */
+            /* BPMP to exploit jamais vu, deja vu, or other related DMA/wake-from-sleep vulnerabilities. */
+            constexpr uintptr_t MC = MemoryRegionPhysicalDeviceMemoryController.GetAddress();
+            SMC_R_UNLESS((address == (MC + MC_SMMU_AVPC_ASID) || address == (MC + MC_SMMU_PPCS1_ASID)), InvalidArgument);
+
+            /* For backwards compatibility, we'll allow access to these devices on 1.0.0. */
+            if (GetTargetFirmware() < TargetFirmware_2_0_0) {
+                virtual_address = MemoryRegionVirtualDeviceMemoryController.GetAddress() + (address - MC);
+            }
+        }
+
+        /* Perform the read or write, if we should. */
+        if (virtual_address != 0) {
             u32 out = 0;
 
             if (mask != ~static_cast<u32>(0)) {
@@ -169,13 +186,6 @@ namespace ams::secmon::smc {
             }
 
             args.r[1] = out;
-        } else {
-            /* For no clearly discernable reason, SmcReadWriteRegister returns success despite not doing the read/write */
-            /* when accessing the SMMU controls for the BPMP and for APB-DMA. */
-            /* This is "probably" to fuck with hackers who got access to the SMC and are trying to get control of the */
-            /* BPMP to exploit jamais vu, deja vu, or other related DMA/wake-from-sleep vulnerabilities. */
-            constexpr uintptr_t MC = MemoryRegionPhysicalDeviceMemoryController.GetAddress();
-            SMC_R_UNLESS((address == (MC + MC_SMMU_AVPC_ASID) || address == (MC + MC_SMMU_PPCS1_ASID)), InvalidArgument);
         }
 
         return SmcResult::Success;

exosphere/program/source/smc/secmon_smc_rsa.cpp

@@ -75,6 +75,7 @@ namespace ams::secmon::smc {
                 u8 msg[se::RsaSize];
             public:
                 void Set(const void *m, size_t m_size) {
+                    AMS_UNUSED(m_size);
                     std::memcpy(this->msg, m, sizeof(this->msg));
                 }
 

exosphere/program/split_program.py

@@ -3,7 +3,11 @@ import sys, lz4
 from struct import unpack as up
 
 def lz4_compress(data):
-    return lz4.block.compress(data, 'high_compression', store_size=False)
+    try:
+        import lz4.block as block
+    except ImportError:
+        block = lz4.LZ4_compress
+    return block.compress(data, 'high_compression', store_size=False)
 
 def split_binary(data):
     A, B, START, BOOT_CODE_START, BOOT_CODE_END, PROGRAM_START, C, D = up('<QQQQQQQQ', data[:0x40])
@@ -19,7 +23,7 @@ def split_binary(data):
 
 def main(argc, argv):
     if argc != 3:
-        print 'Usage: %s in outdir' % argv[0]
+        print('Usage: %s in outdir' % argv[0])
         return 1
     with open(argv[1], 'rb') as f:
         data = f.read()
@@ -30,4 +34,4 @@ def main(argc, argv):
     return 0
 
 if __name__ == '__main__':
-    sys.exit(main(len(sys.argv), sys.argv))
+    sys.exit(main(len(sys.argv), sys.argv))

exosphere/warmboot/Makefile

@@ -23,23 +23,9 @@ export DEPSDIR  :=  $(CURDIR)/$(BUILD)
 export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
 			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
 
-CFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.c)) $(notdir $(wildcard $(dir)/*.board.*.c)) $(notdir $(wildcard $(dir)/*.os.*.c)), \
-                                                      $(notdir $(wildcard $(dir)/*.c))))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).c)))
-
-CPPFILES    :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.cpp)) $(notdir $(wildcard $(dir)/*.board.*.cpp)) $(notdir $(wildcard $(dir)/*.os.*.cpp)), \
-                                                      $(notdir $(wildcard $(dir)/*.cpp))))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).cpp)))
-
-SFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.s)) $(notdir $(wildcard $(dir)/*.board.*.s)) $(notdir $(wildcard $(dir)/*.os.*.s)), \
-                                                      $(notdir $(wildcard $(dir)/*.s))))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).s)))
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
 
 #---------------------------------------------------------------------------------
 # use CXX for linking C++ projects, CC for standard C

exosphere/warmboot/source/warmboot_main.cpp

@@ -90,7 +90,9 @@ namespace ams::warmboot {
     NORETURN void ExceptionHandler() {
         /* Write enable to MAIN_RESET. */
         reg::Write(PMC + APBDEV_PMC_CNTRL, PMC_REG_BITS_ENUM(CNTRL_MAIN_RESET, ENABLE));
-        while (true) { /* ... */ }
+
+        /* Wait forever until we're reset. */
+        AMS_INFINITE_LOOP();
     }
 
 }

fusee/fusee-mtc/src/lib/log.h

@@ -17,7 +17,7 @@
 #ifndef FUSEE_LOG_H
 #define FUSEE_LOG_H
 
-#define PRINT_MESSAGE_MAX_LENGTH 512
+#define PRINT_MESSAGE_MAX_LENGTH 1024
 
 #include <stdarg.h>
 

fusee/fusee-mtc/src/utils.c

@@ -17,17 +17,26 @@
 #include <stdbool.h>
 #include <stdarg.h>
 #include "utils.h"
+#include "display/video_fb.h"
 #include "lib/log.h"
 
 __attribute__ ((noreturn)) void generic_panic(void) {
-    print(SCREEN_LOG_LEVEL_ERROR, "Panic raised!");
-    
     while (true) {
         /* Lock. */
     }
 }
 
 __attribute__((noreturn)) void fatal_error(const char *fmt, ...) {
+    /* Forcefully initialize the screen if logging is disabled. */
+    if (log_get_log_level() == SCREEN_LOG_LEVEL_NONE) {
+        /* Zero-fill the framebuffer and register it as printk provider. */
+        video_init((void *)0xC0000000);
+        
+        /* Override the global logging level. */
+        log_set_log_level(SCREEN_LOG_LEVEL_ERROR);
+    }
+    
+    /* Display fatal error. */
     va_list args;
     print(SCREEN_LOG_LEVEL_ERROR, "Fatal error: ");
     va_start(args, fmt);

fusee/fusee-primary/src/exception_handlers.c

@@ -19,9 +19,10 @@
 #include "exception_handlers.h"
 #include "utils.h"
 #include "lib/log.h"
+#include "lib/vsprintf.h"
 
 #define CODE_DUMP_SIZE      0x30
-#define STACK_DUMP_SIZE     0x60
+#define STACK_DUMP_SIZE     0x30
 
 extern const uint32_t exception_handler_table[];
 
@@ -34,6 +35,40 @@ static const char *register_names[] = {
     "SP", "LR", "PC", "CPSR",
 };
 
+/* Adapted from https://gist.github.com/ccbrown/9722406 */
+static void hexdump(const void* data, size_t size, uintptr_t addrbase, char* strbuf) {
+    const uint8_t *d = (const uint8_t *)data;
+    char ascii[17] = {0};
+    ascii[16] = '\0';
+
+    for (size_t i = 0; i < size; i++) {
+        if (i % 16 == 0) {
+            strbuf += sprintf(strbuf, "%0*" PRIXPTR ": | ", 2 * sizeof(addrbase), addrbase + i);
+        }
+        strbuf += sprintf(strbuf, "%02X ", d[i]);
+        if (d[i] >= ' ' && d[i] <= '~') {
+            ascii[i % 16] = d[i];
+        } else {
+            ascii[i % 16] = '.';
+        }
+        if ((i+1) % 8 == 0 || i+1 == size) {
+            strbuf += sprintf(strbuf, " ");
+            if ((i+1) % 16 == 0) {
+                strbuf += sprintf(strbuf, "|  %s \n", ascii);
+            } else if (i+1 == size) {
+                ascii[(i+1) % 16] = '\0';
+                if ((i+1) % 16 <= 8) {
+                    strbuf += sprintf(strbuf, " ");
+                }
+                for (size_t j = (i+1) % 16; j < 16; j++) {
+                    strbuf += sprintf(strbuf, "   ");
+                }
+                strbuf += sprintf(strbuf, "|  %s \n", ascii);
+            }
+        }
+    }
+}
+
 void setup_exception_handlers(void) {
     volatile uint32_t *bpmp_exception_handler_table = (volatile uint32_t *)0x6000F200;
     for (int i = 0; i < 8; i++) {
@@ -44,38 +79,40 @@ void setup_exception_handlers(void) {
 }
 
 void exception_handler_main(uint32_t *registers, unsigned int exception_type) {
-    uint8_t code_dump[CODE_DUMP_SIZE];
-    uint8_t stack_dump[STACK_DUMP_SIZE];
-    size_t  code_dump_size;
-    size_t  stack_dump_size;
+    char exception_log[0x400] = {0};
+    uint8_t code_dump[CODE_DUMP_SIZE] = {0};
+    uint8_t stack_dump[STACK_DUMP_SIZE] = {0};
+    size_t code_dump_size = 0;
+    size_t stack_dump_size = 0;
 
     uint32_t pc = registers[15];
     uint32_t cpsr = registers[16];
-
     uint32_t instr_addr = pc + ((cpsr & 0x20) ? 2 : 4) - CODE_DUMP_SIZE;
 
-    print(SCREEN_LOG_LEVEL_ERROR, "\nSomething went wrong...\n");
-
+    sprintf(exception_log, "An exception occured!\n");
+    
     code_dump_size = safecpy(code_dump, (const void *)instr_addr, CODE_DUMP_SIZE);
     stack_dump_size = safecpy(stack_dump, (const void *)registers[13], STACK_DUMP_SIZE);
 
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\nException type: %s\n",
-            exception_names[exception_type]);
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\nRegisters:\n\n");
+    sprintf(exception_log + strlen(exception_log), "\nException type: %s\n", exception_names[exception_type]);
+    sprintf(exception_log + strlen(exception_log), "\nRegisters:\n");
 
     /* Print r0 to pc. */
     for (int i = 0; i < 16; i += 2) {
-        print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "%-7s%08"PRIX32"       %-7s%08"PRIX32"\n",
+        sprintf(exception_log + strlen(exception_log), "%-7s%08"PRIX32"       %-7s%08"PRIX32"\n",
                 register_names[i], registers[i], register_names[i+1], registers[i+1]);
     }
 
     /* Print cpsr. */
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "%-7s%08"PRIX32"\n", register_names[16], registers[16]);
-
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\nCode dump:\n");
-    hexdump(code_dump, code_dump_size, instr_addr);
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\nStack dump:\n");
-    hexdump(stack_dump, stack_dump_size, registers[13]);
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\n");
-    fatal_error("An exception occured!\n");
+    sprintf(exception_log + strlen(exception_log), "%-7s%08"PRIX32"\n", register_names[16], registers[16]);
+    
+    /* Print code and stack regions. */
+    sprintf(exception_log + strlen(exception_log), "\nCode dump:\n");    
+    hexdump(code_dump, code_dump_size, instr_addr, exception_log + strlen(exception_log));
+    sprintf(exception_log + strlen(exception_log), "\nStack dump:\n");
+    hexdump(stack_dump, stack_dump_size, registers[13], exception_log + strlen(exception_log));
+    sprintf(exception_log + strlen(exception_log), "\n");
+    
+    /* Throw fatal error with the full exception log. */
+    fatal_error(exception_log);
 }

fusee/fusee-primary/src/lib/log.h

@@ -17,7 +17,7 @@
 #ifndef FUSEE_LOG_H
 #define FUSEE_LOG_H
 
-#define PRINT_MESSAGE_MAX_LENGTH 512
+#define PRINT_MESSAGE_MAX_LENGTH 1024
 
 #include <stdarg.h>
 

fusee/fusee-primary/src/panic.c

@@ -42,6 +42,10 @@ static const char *get_error_desc_str(uint32_t error_desc) {
             return "SError";
         case 0x301:
             return "Bad SVC";
+        case 0xF00:
+	        return "Kernel Panic";
+        case 0xFFD:
+	        return "Stack overflow";
         case 0xFFE:
             return "std::abort() called";
         default:

fusee/fusee-primary/src/stage2.c

@@ -106,7 +106,7 @@ void load_stage2(const char *bct0) {
     }
 
     if (strlen(config.path) + 1 + sizeof(stage2_args_t) > CHAINLOADER_ARG_DATA_MAX_SIZE) {
-        print(SCREEN_LOG_LEVEL_ERROR, "Stage2's path name is too big!\n");
+        fatal_error("Stage2's path name is too big!\n");
     }
 
     if (!check_32bit_address_loadable(config.entrypoint)) {

fusee/fusee-primary/src/utils.c

@@ -26,6 +26,7 @@
 #include "car.h"
 #include "btn.h"
 #include "lib/log.h"
+#include "lib/vsprintf.h"
 #include "display/video_fb.h"
 
 #include <inttypes.h>
@@ -112,11 +113,11 @@ __attribute__((noreturn)) void fatal_error(const char *fmt, ...) {
         /* Turn on the backlight after initializing the lfb */
         /* to avoid flickering. */
         display_backlight(true);
-        
-        /* Override the global logging level. */
-        log_set_log_level(SCREEN_LOG_LEVEL_ERROR);
     }
     
+    /* Override the global logging level. */
+    log_set_log_level(SCREEN_LOG_LEVEL_ERROR);
+    
     /* Display fatal error. */
     va_list args;
     print(SCREEN_LOG_LEVEL_ERROR, "Fatal error: ");
@@ -137,37 +138,3 @@ __attribute__((noinline)) bool overlaps(uint64_t as, uint64_t ae, uint64_t bs, u
         return true;
     return false;
 }
-
-/* Adapted from https://gist.github.com/ccbrown/9722406 */
-void hexdump(const void* data, size_t size, uintptr_t addrbase) {
-    const uint8_t *d = (const uint8_t *)data;
-    char ascii[17];
-    ascii[16] = '\0';
-
-    for (size_t i = 0; i < size; i++) {
-        if (i % 16 == 0) {
-            print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "%0*" PRIXPTR ": | ", 2 * sizeof(addrbase), addrbase + i);
-        }
-        print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "%02X ", d[i]);
-        if (d[i] >= ' ' && d[i] <= '~') {
-            ascii[i % 16] = d[i];
-        } else {
-            ascii[i % 16] = '.';
-        }
-        if ((i+1) % 8 == 0 || i+1 == size) {
-            print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, " ");
-            if ((i+1) % 16 == 0) {
-                print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "|  %s \n", ascii);
-            } else if (i+1 == size) {
-                ascii[(i+1) % 16] = '\0';
-                if ((i+1) % 16 <= 8) {
-                    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, " ");
-                }
-                for (size_t j = (i+1) % 16; j < 16; j++) {
-                    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "   ");
-                }
-                print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "|  %s \n", ascii);
-            }
-        }
-    }
-}

fusee/fusee-primary/src/utils.h

@@ -117,15 +117,12 @@ static inline bool check_32bit_address_range_in_program(uintptr_t addr, size_t s
     overlaps_a(start, end, __start__, __end__);
 }
 
-void hexdump(const void* data, size_t size, uintptr_t addrbase);
-
 __attribute__((noreturn)) void watchdog_reboot(void);
 __attribute__((noreturn)) void pmc_reboot(uint32_t scratch0);
 __attribute__((noreturn)) void reboot_to_self(void);
 __attribute__((noreturn)) void wait_for_button_and_reboot(void);
 
 __attribute__((noreturn)) void generic_panic(void);
-
 __attribute__((noreturn)) void fatal_error(const char *fmt, ...);
 
 #endif

fusee/fusee-secondary/Makefile

@@ -89,7 +89,7 @@ export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
 			$(foreach dir,$(DATA),$(CURDIR)/$(dir)) \
 			$(AMS)/exosphere $(AMS)/exosphere/warmboot $(AMS)/exosphere/program/rebootstub \
 			$(AMS)/thermosphere $(AMS)/fusee/fusee-primary $(AMS)/sept/sept-primary \
-			$(AMS)/sept/sept-secondary $(AMS)/emummc $(AMS)/mesosphere/kernel_ldr $(KIPDIRS)
+			$(AMS)/sept/sept-secondary $(AMS)/emummc $(AMS)/mesosphere $(AMS)/mesosphere/kernel_ldr $(KIPDIRS)
 
 export DEPSDIR	:=	$(CURDIR)/$(BUILD)
 
@@ -100,7 +100,7 @@ KIPFILES 	:=	loader.kip ncm.kip pm.kip sm.kip ams_mitm.kip spl.kip boot.kip
 BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*))) fusee-primary.bin \
 				exosphere.bin warmboot.bin rebootstub.bin thermosphere.bin splash_screen.bmp \
 				sept-primary.bin sept-secondary_00.enc sept-secondary_01.enc emummc.kip \
-				sept-secondary_dev_00.enc sept-secondary_dev_01.enc kernel_ldr.bin $(KIPFILES)
+				sept-secondary_dev_00.enc sept-secondary_dev_01.enc mesosphere.bin kernel_ldr.bin $(KIPFILES)
 
 #---------------------------------------------------------------------------------
 # use CXX for linking C++ projects, CC for standard C

fusee/fusee-secondary/src/car.h

@@ -13,7 +13,7 @@
  * 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 FUSEE_CAR_H
 #define FUSEE_CAR_H
 
@@ -37,23 +37,27 @@
 
 /* Clock and reset devices. */
 typedef enum {
-    CARDEVICE_UARTA = ((0 << 5) | 0x6),
-    CARDEVICE_UARTB = ((0 << 5) | 0x7),
-    CARDEVICE_UARTC = ((1 << 5) | 0x17),
-    CARDEVICE_I2C1 = ((0 << 5) | 0xC),
-    CARDEVICE_I2C5 = ((1 << 5) | 0xF),
-    CARDEVICE_TZRAM = ((3 << 5) | 0x1E),
-    CARDEVICE_SE = ((3 << 5) | 0x1F),
-    CARDEVICE_HOST1X = ((0 << 5) | 0x1C),
-    CARDEVICE_TSEC = ((2 << 5) | 0x13),
-    CARDEVICE_SOR_SAFE = ((6 << 5) | 0x1E),
-    CARDEVICE_SOR0 = ((5 << 5) | 0x16),
-    CARDEVICE_SOR1 = ((5 << 5) | 0x17),
-    CARDEVICE_KFUSE = ((1 << 5) | 0x8),
-    CARDEVICE_CL_DVFS = ((4 << 5) | 0x1B),
+    CARDEVICE_BPMP      = ((0 << 5) | 0x1),
+    CARDEVICE_UARTA     = ((0 << 5) | 0x6),
+    CARDEVICE_UARTB     = ((0 << 5) | 0x7),
+    CARDEVICE_I2C1      = ((0 << 5) | 0xC),
+    CARDEVICE_USBD      = ((0 << 5) | 0x16),
+    CARDEVICE_HOST1X    = ((0 << 5) | 0x1C),
+    CARDEVICE_AHBDMA    = ((1 << 5) | 0x1),
+    CARDEVICE_APBDMA    = ((1 << 5) | 0x2),
+    CARDEVICE_KFUSE     = ((1 << 5) | 0x8),
+    CARDEVICE_I2C5      = ((1 << 5) | 0xF),
+    CARDEVICE_UARTC     = ((1 << 5) | 0x17),
+    CARDEVICE_USB2      = ((1 << 5) | 0x1A),
     CARDEVICE_CORESIGHT = ((2 << 5) | 0x9),
-    CARDEVICE_ACTMON = ((3 << 5) | 0x17),
-    CARDEVICE_BPMP = ((0 << 5) | 0x1)
+    CARDEVICE_TSEC      = ((2 << 5) | 0x13),
+    CARDEVICE_ACTMON    = ((3 << 5) | 0x17),
+    CARDEVICE_TZRAM     = ((3 << 5) | 0x1E),
+    CARDEVICE_SE        = ((3 << 5) | 0x1F),
+    CARDEVICE_CL_DVFS   = ((4 << 5) | 0x1B),
+    CARDEVICE_SOR0      = ((5 << 5) | 0x16),
+    CARDEVICE_SOR1      = ((5 << 5) | 0x17),
+    CARDEVICE_SOR_SAFE  = ((6 << 5) | 0x1E),
 } CarDevice;
 
 /* Clock/Reset Controller (CLK_RST_CONTROLLER_) regs */
@@ -97,31 +101,31 @@ typedef struct {
     uint32_t pllc_out;
     uint32_t pllc_misc0;
     uint32_t pllc_misc1;
-    
+
     /* PLLM 0x90-0x9c */
     uint32_t pllm_base;
     uint32_t pllm_out;
     uint32_t pllm_misc1;
     uint32_t pllm_misc2;
-    
+
     /* PLLP 0xa0-0xac */
     uint32_t pllp_base;
     uint32_t pllp_outa;
     uint32_t pllp_outb;
     uint32_t pllp_misc;
-    
+
     /* PLLA 0xb0-0xbc */
     uint32_t plla_base;
     uint32_t plla_out;
     uint32_t plla_misc0;
     uint32_t plla_misc1;
-    
+
     /* PLLU 0xc0-0xcc */
     uint32_t pllu_base;
     uint32_t pllu_out;
     uint32_t pllu_misc1;
     uint32_t pllu_misc2;
-    
+
     /* PLLD 0xd0-0xdc */
     uint32_t plld_base;
     uint32_t plld_out;
@@ -131,13 +135,13 @@ typedef struct {
     /* PLLX 0xe0-0xe4 */
     uint32_t pllx_base;
     uint32_t pllx_misc;
-    
+
     /* PLLE 0xe8-0xf4 */
     uint32_t plle_base;
     uint32_t plle_misc;
     uint32_t plle_ss_cntl1;
     uint32_t plle_ss_cntl2;
-    
+
     uint32_t lvl2_clk_gate_ovra;            /* _LVL2_CLK_GATE_OVRA_0,   0xf8 */
     uint32_t lvl2_clk_gate_ovrb;            /* _LVL2_CLK_GATE_OVRB_0,   0xfc */
 
@@ -188,7 +192,7 @@ typedef struct {
     uint32_t _0x1e0[5];
     uint32_t clk_source_tsec;               /* _CLK_SOURCE_TSEC_0,      0x1f4 */
     uint32_t _0x1f8;
-    
+
     uint32_t clk_spare2;                    /* _CLK_SPARE2_0,       0x1fc */
     uint32_t _0x200[32];
 
@@ -257,7 +261,7 @@ typedef struct {
     uint32_t lvl2_clk_gate_ovrc;        /* _LVL2_CLK_GATE_OVRC,     0x3a0 */
     uint32_t lvl2_clk_gate_ovrd;        /* _LVL2_CLK_GATE_OVRD,     0x3a4 */
     uint32_t _0x3a8[2];
-    
+
     uint32_t _0x3b0;
     uint32_t clk_source_mselect;        /* _CLK_SOURCE_MSELECT_0,       0x3b4 */
     uint32_t clk_source_tsensor;        /* _CLK_SOURCE_TSENSOR_0,       0x3b8 */
@@ -371,13 +375,13 @@ typedef struct {
     uint32_t spare_reg0;            /* _SPARE_REG0_0, 0x55c */
     uint32_t audio_sync_clk_dmic1;  /* _AUDIO_SYNC_CLK_DMIC1_0, 0x560 */
     uint32_t audio_sync_clk_dmic2;  /* _AUDIO_SYNC_CLK_DMIC2_0, 0x564 */
-    
+
     uint32_t _0x568[2];
     uint32_t plld2_ss_cfg;          /* _PLLD2_SS_CFG,           0x570 */
     uint32_t plld2_ss_ctrl1;        /* _PLLD2_SS_CTRL1_0,       0x574 */
     uint32_t plld2_ss_ctrl2;        /* _PLLD2_SS_CTRL2_0,       0x578 */
     uint32_t _0x57c[5];
-    
+
     uint32_t plldp_base;            /* _PLLDP_BASE, 0x590*/
     uint32_t plldp_misc;            /* _PLLDP_MISC, 0x594 */
     uint32_t plldp_ss_cfg;          /* _PLLDP_SS_CFG, 0x598 */
@@ -399,7 +403,7 @@ typedef struct {
     uint32_t pllx_misc4;            /* _PLLX_MISC_4_0, 0x5f0 */
     uint32_t pllx_misc5;            /* _PLLX_MISC_5_0, 0x5f4 */
     uint32_t _0x5f8[2];
-    
+
     uint32_t clk_source_xusb_core_host;             /* _CLK_SOURCE_XUSB_CORE_HOST_0,    0x600 */
     uint32_t clk_source_xusb_falcon;                /* _CLK_SOURCE_XUSB_FALCON_0,    0x604 */
     uint32_t clk_source_xusb_fs;                    /* _CLK_SOURCE_XUSB_FS_0,    0x608 */
@@ -428,7 +432,7 @@ typedef struct {
     uint32_t clk_source_uart_fst_mipi_cal;          /* _CLK_SOURCE_UART_FST_MIPI_CAL_0,    0x66c */
     uint32_t _0x670[2];
     uint32_t clk_source_vic;                        /* _CLK_SOURCE_VIC_0,    0x678 */
-    
+
     uint32_t pllp_outc;                             /* _PLLP_OUTC_0, 0x67c */
     uint32_t pllp_misc1;                            /* _PLLP_MISC1_0, 0x680 */
     uint32_t _0x684[2];
@@ -439,14 +443,14 @@ typedef struct {
     uint32_t clk_source_nvdec;                      /* _CLK_SOURCE_NVDEC_0,    0x698 */
     uint32_t clk_source_nvjpg;                      /* _CLK_SOURCE_NVJPG_0,    0x69c */
     uint32_t clk_source_nvenc;                      /* _CLK_SOURCE_NVENC_0,    0x6a0 */
-    
+
     uint32_t plla1_base;                            /* _PLLA1_BASE_0, 0x6a4 */
     uint32_t plla1_misc0;                           /* _PLLA1_MISC_0_0, 0x6a8 */
     uint32_t plla1_misc1;                           /* _PLLA1_MISC_1_0, 0x6ac */
     uint32_t plla1_misc2;                           /* _PLLA1_MISC_2_0, 0x6b0 */
     uint32_t plla1_misc3;                           /* _PLLA1_MISC_3_0, 0x6b4 */
     uint32_t audio_sync_clk_dmic3;                  /* _AUDIO_SYNC_CLK_DMIC3_0, 0x6b8 */
-    
+
     uint32_t clk_source_dmic3;                      /* _CLK_SOURCE_DMIC3_0,    0x6bc */
     uint32_t clk_source_ape;                        /* _CLK_SOURCE_APE_0,    0x6c0 */
     uint32_t clk_source_qspi;                       /* _CLK_SOURCE_QSPI_0,    0x6c4 */
@@ -455,11 +459,11 @@ typedef struct {
     uint32_t clk_source_pex_sata_usb_rx_byp;        /* _CLK_SOURCE_PEX_SATA_USB_RX_BYP_0,    0x6d0 */
     uint32_t clk_source_maud;                       /* _CLK_SOURCE_MAUD_0,    0x6d4 */
     uint32_t clk_source_tsecb;                      /* _CLK_SOURCE_TSECB_0,    0x6d8 */
-    
+
     uint32_t clk_cpug_misc1;                        /* _CLK_CPUG_MISC1_0, 0x6dc */
     uint32_t aclk_burst_policy;                     /* _ACLK_BURST_POLICY_0, 0x6e0 */
     uint32_t super_aclk_divider;                    /* _SUPER_ACLK_DIVIDER_0, 0x6e4 */
-    
+
     uint32_t nvenc_super_clk_divider;               /* _NVENC_SUPER_CLK_DIVIDER_0, 0x6e8 */
     uint32_t vi_super_clk_divider;                  /* _VI_SUPER_CLK_DIVIDER_0, 0x6ec */
     uint32_t vic_super_clk_divider;                 /* _VIC_SUPER_CLK_DIVIDER_0, 0x6f0 */
@@ -470,7 +474,7 @@ typedef struct {
     uint32_t se_super_clk_divider;                  /* _SE_SUPER_CLK_DIVIDER_0, 0x704 */
     uint32_t tsec_super_clk_divider;                /* _TSEC_SUPER_CLK_DIVIDER_0, 0x708 */
     uint32_t tsecb_super_clk_divider;               /* _TSECB_SUPER_CLK_DIVIDER_0, 0x70c */
-    
+
     uint32_t clk_source_uartape;                    /* _CLK_SOURCE_UARTAPE_0, 0x710 */
     uint32_t clk_cpug_misc2;                        /* _CLK_CPUG_MISC2_0, 0x714 */
     uint32_t clk_source_dbgapb;                     /* _CLK_SOURCE_DBGAPB_0, 0x718 */
@@ -484,7 +488,7 @@ typedef struct {
     uint32_t sdmmc4_pllc4_out0_shaper_ctrl;         /* _SDMMC4_PLLC4_OUT0_SHAPER_CTRL_0, 0x738 */
     uint32_t sdmmc4_pllc4_out1_shaper_ctrl;         /* _SDMMC4_PLLC4_OUT1_SHAPER_CTRL_0, 0x73c */
     uint32_t sdmmc4_pllc4_out2_shaper_ctrl;         /* _SDMMC4_PLLC4_OUT2_SHAPER_CTRL_0, 0x740 */
-    uint32_t sdmmc4_div_clk_shaper_ctrl;            /* _SDMMC4_DIV_CLK_SHAPER_CTRL_0, 0x744 */    
+    uint32_t sdmmc4_div_clk_shaper_ctrl;            /* _SDMMC4_DIV_CLK_SHAPER_CTRL_0, 0x744 */
 } tegra_car_t;
 
 static inline volatile tegra_car_t *car_get_regs(void) {

fusee/fusee-secondary/src/device_partition.c

@@ -18,67 +18,9 @@
 #include <string.h>
 #include "device_partition.h"
 
-int device_partition_read_data(device_partition_t *devpart, void *dst, uint64_t sector, uint64_t num_sectors)
-{
-    int rc;
-    if (!devpart->initialized) {
-        rc = devpart->initializer(devpart);
-        if (rc != 0) {
-            return rc;
-        }
-    }
-    if ((devpart->read_cipher != NULL) && (devpart->crypto_mode != DevicePartitionCryptoMode_None)) {
-        for (uint64_t i = 0; i < num_sectors; i += devpart->crypto_work_buffer_num_sectors) {
-            uint64_t n = (i + devpart->crypto_work_buffer_num_sectors > num_sectors) ? (num_sectors - i) : devpart->crypto_work_buffer_num_sectors;
-            rc = devpart->reader(devpart, devpart->crypto_work_buffer, sector + i, n);
-            if (rc != 0) {
-                return rc;
-            }
-            rc = devpart->read_cipher(devpart, sector + i, n);
-            if (rc != 0) {
-                return rc;
-            }
-            memcpy(dst + (size_t)(devpart->sector_size * i), devpart->crypto_work_buffer, (size_t)(devpart->sector_size * n)); 
-        }
-        return 0;
-    } else {
-        return devpart->reader(devpart, dst, sector, num_sectors);
-    }
-}
-
-int device_partition_write_data(device_partition_t *devpart, const void *src, uint64_t sector, uint64_t num_sectors)
-{
-    int rc;
-    if (!devpart->initialized) {
-        rc = devpart->initializer(devpart);
-        if (rc != 0) {
-            return rc;
-        }
-    }
-    if ((devpart->write_cipher != NULL) && (devpart->crypto_mode != DevicePartitionCryptoMode_None)) {
-        for (uint64_t i = 0; i < num_sectors; i += devpart->crypto_work_buffer_num_sectors) {
-            uint64_t n = (i + devpart->crypto_work_buffer_num_sectors > num_sectors) ? (num_sectors - i) : devpart->crypto_work_buffer_num_sectors;
-            memcpy(devpart->crypto_work_buffer, src + (size_t)(devpart->sector_size * i), (size_t)(devpart->sector_size * n)); 
-            rc = devpart->write_cipher(devpart, sector + i, n);
-            if (rc != 0) {
-                return rc;
-            }
-            rc = devpart->writer(devpart, devpart->crypto_work_buffer, sector + i, n);
-            if (rc != 0) {
-                return rc;
-            }
-        }
-        return 0;
-    } else {
-        return devpart->writer(devpart, src, sector, num_sectors);
-    }
-}
-
-int emu_device_partition_read_data(device_partition_t *devpart, void *dst, uint64_t sector, uint64_t num_sectors, const char *origin_path, int num_parts, uint64_t part_limit)
-{
+int device_partition_read_data(device_partition_t *devpart, void *dst, uint64_t sector, uint64_t num_sectors) {
     int rc = 0;
     uint64_t target_sector = sector;
-    char target_path[0x300 + 1] = {0};
     
     /* Perform initialization steps, if necessary. */
     if (!devpart->initialized) {
@@ -88,33 +30,37 @@ int emu_device_partition_read_data(device_partition_t *devpart, void *dst, uint6
         }
     }
     
-    /* Prepare the right file path if using file mode. */
-    if (devpart->emu_use_file && (origin_path != NULL)) {
-        /* Handle data in multiple parts, if necessary. */
-        if (num_parts > 0) {
-            int target_part = 0;
-            uint64_t data_offset = sector * devpart->sector_size;
+    /* Handle emulation. */
+    if (devpart->is_emulated) {
+        /* Prepare the right file path if using file mode. */
+        if (devpart->emu_use_file) {
+            int num_parts = devpart->emu_num_parts;
+            uint64_t part_limit = devpart->emu_part_limit;
             
-            if (data_offset >= part_limit) {
-                uint64_t data_offset_aligned = (data_offset + (part_limit - 1)) & ~(part_limit - 1);
-                target_part = (data_offset_aligned == data_offset) ? (data_offset / part_limit) : (data_offset_aligned / part_limit) - 1;
-                target_sector = (data_offset - (target_part * part_limit)) / devpart->sector_size;
-                
-                /* Target part is invalid. */
-                if (target_part > num_parts) {
-                    return -1;
+            /* Handle data in multiple parts, if necessary. */
+            if (num_parts > 0) {
+                int target_part = 0;
+                char target_path[0x300 + 1] = {0};
+                uint64_t data_offset = sector * devpart->sector_size;
+            
+                if (data_offset >= part_limit) {
+                    uint64_t data_offset_aligned = (data_offset + (part_limit - 1)) & ~(part_limit - 1);
+                    target_part = (data_offset_aligned == data_offset) ? (data_offset / part_limit) : (data_offset_aligned / part_limit) - 1;
+                    target_sector = (data_offset - (target_part * part_limit)) / devpart->sector_size;
+                    
+                    /* Target part is invalid. */
+                    if (target_part > num_parts) {
+                        return -1;
+                    }
                 }
+                
+                /* Treat the path as a folder with each part inside. */
+                snprintf(target_path, sizeof(target_path) - 1, "%s/%02d", devpart->emu_root_path, target_part);
+                
+                /* Update the target file path. */
+                strcpy(devpart->emu_file_path, target_path);
             }
-            
-            /* Treat the path as a folder with each part inside. */
-            snprintf(target_path, sizeof(target_path) - 1, "%s/%02d", origin_path, target_part);
-        } else {
-            /* If there are no parts, copy the origin path directly. */
-            strcpy(target_path, origin_path);
         }
-        
-        /* Update the target file path. */
-        devpart->emu_file_path = target_path;
     }
     
     /* Read the partition data. */
@@ -147,11 +93,9 @@ int emu_device_partition_read_data(device_partition_t *devpart, void *dst, uint6
     return rc;
 }
 
-int emu_device_partition_write_data(device_partition_t *devpart, const void *src, uint64_t sector, uint64_t num_sectors, const char *origin_path, int num_parts, uint64_t part_limit)
-{
+int device_partition_write_data(device_partition_t *devpart, const void *src, uint64_t sector, uint64_t num_sectors) {
     int rc = 0;
     uint64_t target_sector = sector;
-    char target_path[0x300 + 1] = {0};
     
     /* Perform initialization steps, if necessary. */
     if (!devpart->initialized) {
@@ -161,33 +105,37 @@ int emu_device_partition_write_data(device_partition_t *devpart, const void *src
         }
     }
     
-    /* Prepare the right file path if using file mode. */
-    if (devpart->emu_use_file && (origin_path != NULL)) {
-        /* Handle data in multiple parts, if necessary. */
-        if (num_parts > 0) {
-            int target_part = 0;
-            uint64_t data_offset = sector * devpart->sector_size;
+    /* Handle emulation. */
+    if (devpart->is_emulated) {
+        /* Prepare the right file path if using file mode. */
+        if (devpart->emu_use_file) {
+            int num_parts = devpart->emu_num_parts;
+            uint64_t part_limit = devpart->emu_part_limit;
             
-            if (data_offset >= part_limit) {
-                uint64_t data_offset_aligned = (data_offset + (part_limit - 1)) & ~(part_limit - 1);
-                target_part = (data_offset_aligned == data_offset) ? (data_offset / part_limit) : (data_offset_aligned / part_limit) - 1;
-                target_sector = (data_offset - (target_part * part_limit)) / devpart->sector_size;
-                
-                /* Target part is invalid. */
-                if (target_part > num_parts) {
-                    return -1;
+            /* Handle data in multiple parts, if necessary. */
+            if (num_parts > 0) {
+                int target_part = 0;
+                char target_path[0x300 + 1] = {0};
+                uint64_t data_offset = sector * devpart->sector_size;
+            
+                if (data_offset >= part_limit) {
+                    uint64_t data_offset_aligned = (data_offset + (part_limit - 1)) & ~(part_limit - 1);
+                    target_part = (data_offset_aligned == data_offset) ? (data_offset / part_limit) : (data_offset_aligned / part_limit) - 1;
+                    target_sector = (data_offset - (target_part * part_limit)) / devpart->sector_size;
+                    
+                    /* Target part is invalid. */
+                    if (target_part > num_parts) {
+                        return -1;
+                    }
                 }
+                
+                /* Treat the path as a folder with each part inside. */
+                snprintf(target_path, sizeof(target_path) - 1, "%s/%02d", devpart->emu_root_path, target_part);
+                
+                /* Update the target file path. */
+                strcpy(devpart->emu_file_path, target_path);
             }
-            
-            /* Treat the path as a folder with each part inside. */
-            snprintf(target_path, sizeof(target_path) - 1, "%s/%02d", origin_path, target_part);
-        } else {
-            /* If there are no parts, copy the origin path directly. */
-            strcpy(target_path, origin_path);
         }
-        
-        /* Update the target file path. */
-        devpart->emu_file_path = target_path;
     }
     
     /* Write the partition data. */

fusee/fusee-secondary/src/device_partition.h

@@ -67,13 +67,16 @@ typedef struct device_partition_t {
     uint8_t __attribute__((aligned(16))) iv[DEVPART_IV_MAX_SIZE]; /* IV. */
     bool initialized;
 
-    char *emu_file_path;     /* Emulated device file path. */
+    /* Emulation only. */
+    bool is_emulated;
     bool emu_use_file;
+    char emu_root_path[0x100 + 1];
+    char emu_file_path[0x300 + 1];
+    int emu_num_parts;
+    uint64_t emu_part_limit;
 } device_partition_t;
 
 int device_partition_read_data(device_partition_t *devpart, void *dst, uint64_t sector, uint64_t num_sectors);
 int device_partition_write_data(device_partition_t *devpart, const void *src, uint64_t sector, uint64_t num_sectors);
-int emu_device_partition_read_data(device_partition_t *devpart, void *dst, uint64_t sector, uint64_t num_sectors, const char *origin_path, int num_parts, uint64_t part_limit);
-int emu_device_partition_write_data(device_partition_t *devpart, const void *src, uint64_t sector, uint64_t num_sectors, const char *origin_path, int num_parts, uint64_t part_limit);
 
 #endif

fusee/fusee-secondary/src/emu_dev.c

@@ -1,489 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
- 
-#include <errno.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <fcntl.h>
-#include <sys/iosupport.h>
-#include <sys/param.h>
-#include <unistd.h>
-
-#include "emu_dev.h"
-#include "utils.h"
-
-static int       emudev_open(struct _reent *r, void *fileStruct, const char *path, int flags, int mode);
-static int       emudev_close(struct _reent *r, void *fd);
-static ssize_t   emudev_write(struct _reent *r, void *fd, const char *ptr, size_t len);
-static ssize_t   emudev_read(struct _reent *r, void *fd, char *ptr, size_t len);
-static off_t     emudev_seek(struct _reent *r, void *fd, off_t pos, int whence);
-static int       emudev_fstat(struct _reent *r, void *fd, struct stat *st);
-static int       emudev_stat(struct _reent *r, const char *file, struct stat *st);
-static int       emudev_fsync(struct _reent *r, void *fd);
-
-typedef struct emudev_device_t {
-    devoptab_t devoptab;
-
-    char origin_path[0x300+1];
-    int num_parts;
-    uint64_t part_limit;
-    uint8_t *tmp_sector;
-    device_partition_t devpart;
-    char name[32+1];
-    char root_path[34+1];
-    bool setup, registered;
-} emudev_device_t;
-
-typedef struct emudev_file_t {
-    emudev_device_t *device;
-    int open_flags;
-    uint64_t offset;
-} emudev_file_t;
-
-static emudev_device_t g_emudev_devices[EMUDEV_MAX_DEVICES] = {0};
-
-static devoptab_t g_emudev_devoptab = {
-  .structSize   = sizeof(emudev_file_t),
-  .open_r       = emudev_open,
-  .close_r      = emudev_close,
-  .write_r      = emudev_write,
-  .read_r       = emudev_read,
-  .seek_r       = emudev_seek,
-  .fstat_r      = emudev_fstat,
-  .stat_r       = emudev_stat,
-  .fsync_r      = emudev_fsync,
-  .deviceData   = NULL,
-};
-
-static emudev_device_t *emudev_find_device(const char *name) {
-    for (size_t i = 0; i < EMUDEV_MAX_DEVICES; i++) {
-        if (g_emudev_devices[i].setup && strcmp(g_emudev_devices[i].name, name) == 0) {
-            return &g_emudev_devices[i];
-        }
-    }
-
-    return NULL;
-}
-
-int emudev_mount_device(const char *name, const device_partition_t *devpart, const char *origin_path, int num_parts, uint64_t part_limit) {
-    emudev_device_t *device = NULL;
-
-    if (name[0] == '\0' || devpart == NULL) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    if (strlen(name) > 32) {
-        errno = ENAMETOOLONG;
-        return -1;
-    }
-    if (emudev_find_device(name) != NULL) {
-        errno = EEXIST; /* Device already exists */
-        return -1;
-    }
-
-    /* Find an unused slot. */
-    for (size_t i = 0; i < EMUDEV_MAX_DEVICES; i++) {
-        if (!g_emudev_devices[i].setup) {
-            device = &g_emudev_devices[i];
-            break;
-        }
-    }
-    if (device == NULL) {
-        errno = ENOMEM;
-        return -1;
-    }
-
-    memset(device, 0, sizeof(emudev_device_t));
-    device->devoptab = g_emudev_devoptab;
-    device->devpart = *devpart;
-    strcpy(device->name, name);
-    strcpy(device->root_path, name);
-    strcat(device->root_path, ":/");
-    
-    /* Copy the file path for file mode. */
-    if (devpart->emu_use_file)
-        strcpy(device->origin_path, origin_path);
-    
-    device->num_parts = num_parts;
-    device->part_limit = part_limit;
-    
-    device->devoptab.name = device->name;
-    device->devoptab.deviceData = device;
-    
-    /* Initialize immediately. */
-    int rc = device->devpart.initializer(&device->devpart);
-    if (rc != 0) {
-        errno = rc;
-        return -1;
-    }
-
-    /* Allocate memory for our intermediate sector. */
-    device->tmp_sector = (uint8_t *)malloc(devpart->sector_size);
-    if (device->tmp_sector == NULL) {
-        errno = ENOMEM;
-        return -1;
-    }
-
-    device->setup = true;
-    device->registered = false;
-
-    return 0;
-}
-
-int emudev_register_device(const char *name) {
-    emudev_device_t *device = emudev_find_device(name);
-    if (device == NULL) {
-        errno = ENOENT;
-        return -1;
-    }
-
-    if (device->registered) {
-        /* Do nothing if the device is already registered. */
-        return 0;
-    }
-
-    if (AddDevice(&device->devoptab) == -1) {
-        errno = ENOMEM;
-        return -1;
-    } else {
-        device->registered = true;
-        return 0;
-    }
-}
-
-int emudev_unregister_device(const char *name) {
-    emudev_device_t *device = emudev_find_device(name);
-    char drname[40];
-
-    if (device == NULL) {
-        errno = ENOENT;
-        return -1;
-    }
-
-    if (!device->registered) {
-        /* Do nothing if the device is not registered. */
-        return 0;
-    }
-
-    strcpy(drname, name);
-    strcat(drname, ":");
-
-    if (RemoveDevice(drname) == -1) {
-        errno = ENOENT;
-        return -1;
-    } else {
-        device->registered = false;
-        return 0;
-    }
-}
-
-int emudev_unmount_device(const char *name) {
-    int rc;
-    emudev_device_t *device = emudev_find_device(name);
-
-    if (device == NULL) {
-        errno = ENOENT;
-        return -1;
-    }
-
-    rc = emudev_unregister_device(name);
-    if (rc == -1) {
-        return -1;
-    }
-    
-    free(device->tmp_sector);
-    device->devpart.finalizer(&device->devpart);
-    memset(device, 0, sizeof(emudev_device_t));
-
-    return 0;
-}
-
-int emudev_unmount_all(void) {
-    for (size_t i = 0; i < EMUDEV_MAX_DEVICES; i++) {
-        int rc = emudev_unmount_device(g_emudev_devices[i].name);
-        if (rc != 0) {
-            return rc;
-        }
-    }
-
-    return 0;
-}
-
-static int emudev_open(struct _reent *r, void *fileStruct, const char *path, int flags, int mode) {
-    (void)mode;
-    emudev_file_t *f = (emudev_file_t *)fileStruct;
-    emudev_device_t *device = (emudev_device_t *)(r->deviceData);
-
-    /* Only allow "device:/". */
-    if (strcmp(path, device->root_path) != 0) {
-        r->_errno = ENOENT;
-        return -1;
-    }
-
-    /* Forbid some flags that we explicitly don't support.*/
-    if (flags & (O_APPEND | O_TRUNC | O_EXCL)) {
-        r->_errno = EINVAL;
-        return -1;
-    }
-
-    memset(f, 0, sizeof(emudev_file_t));
-    f->device = device;
-    f->open_flags = flags;
-    return 0;
-}
-
-static int emudev_close(struct _reent *r, void *fd) {
-    (void)r;
-    emudev_file_t *f = (emudev_file_t *)fd;
-    memset(f, 0, sizeof(emudev_file_t));
-
-    return 0;
-}
-
-static ssize_t emudev_write(struct _reent *r, void *fd, const char *ptr, size_t len) {
-    emudev_file_t *f = (emudev_file_t *)fd;
-    emudev_device_t *device = f->device;
-    size_t sector_size = device->devpart.sector_size;
-    uint64_t sector_begin = f->offset / sector_size;
-    uint64_t sector_end = (f->offset + len + sector_size - 1) / sector_size;
-    uint64_t sector_end_aligned;
-    uint64_t current_sector = sector_begin;
-    const uint8_t *data = (const uint8_t *)ptr;
-
-    int no = 0;
-
-    if (sector_end >= device->devpart.num_sectors) {
-        len = (size_t)(sector_size * device->devpart.num_sectors - f->offset);
-        sector_end = device->devpart.num_sectors;
-    }
-
-    sector_end_aligned = sector_end - ((f->offset + len) % sector_size != 0 ? 1 : 0);
-
-    if (len == 0) {
-        return 0;
-    }
-
-    /* Unaligned at the start, we need to read the sector and incorporate the data. */
-    if (f->offset % sector_size != 0) {
-        size_t nb = (size_t)(len <= (sector_size - (f->offset % sector_size)) ? len : sector_size - (f->offset % sector_size));
-        no = emu_device_partition_read_data(&device->devpart, device->tmp_sector, sector_begin, 1, device->origin_path, device->num_parts, device->part_limit);
-        if (no != 0) {
-            r->_errno = no;
-            return -1;
-        }
-    
-        memcpy(device->tmp_sector + (f->offset % sector_size), data, nb);
-
-        no = emu_device_partition_write_data(&device->devpart, device->tmp_sector, sector_begin, 1, device->origin_path, device->num_parts, device->part_limit);
-        if (no != 0) {
-            r->_errno = no;
-            return -1;
-        }
-
-        /* Advance */
-        data += sector_size - (f->offset % sector_size);
-        current_sector++;
-    }
-
-    /* Check if we're already done (otherwise this causes a bug in handling the last sector of the range). */
-    if (current_sector == sector_end) {
-        f->offset += len;
-        return len;
-    }
-
-    /* Write all of the sector-aligned data. */
-    if (current_sector != sector_end_aligned) {
-        no = emu_device_partition_write_data(&device->devpart, data, current_sector, sector_end_aligned - current_sector, device->origin_path, device->num_parts, device->part_limit);
-        if (no != 0) {
-            r->_errno = no;
-            return -1;
-        }
-    }
-
-    data += sector_size * (sector_end_aligned - current_sector);
-    current_sector = sector_end_aligned;
-
-    /* Unaligned at the end, we need to read the sector and incorporate the data. */
-    if (sector_end != sector_end_aligned) {        
-        no = emu_device_partition_read_data(&device->devpart, device->tmp_sector, sector_end_aligned, 1, device->origin_path, device->num_parts, device->part_limit);
-        if (no != 0) {
-            r->_errno = no;
-            return -1;
-        }
-    
-        memcpy(device->tmp_sector, data, (size_t)((f->offset + len) % sector_size));
-        
-        no = emu_device_partition_write_data(&device->devpart, device->tmp_sector, sector_end_aligned, 1, device->origin_path, device->num_parts, device->part_limit);
-        if (no != 0) {
-            r->_errno = no;
-            return -1;
-        }
-
-        /* Advance */
-        data += sector_size - ((f->offset + len) % sector_size);
-        current_sector++;
-    }
-
-    f->offset += len;
-    return len;
-}
-
-static ssize_t emudev_read(struct _reent *r, void *fd, char *ptr, size_t len) {
-    emudev_file_t *f = (emudev_file_t *)fd;
-    emudev_device_t *device = f->device;
-    size_t sector_size = device->devpart.sector_size;
-    uint64_t sector_begin = f->offset / sector_size;
-    uint64_t sector_end = (f->offset + len + sector_size - 1) / sector_size;
-    uint64_t sector_end_aligned;
-    uint64_t current_sector = sector_begin;
-    uint8_t *data = (uint8_t *)ptr;
-
-    int no = 0;
-
-    if (sector_end >= device->devpart.num_sectors) {
-        len = (size_t)(sector_size * device->devpart.num_sectors - f->offset);
-        sector_end = device->devpart.num_sectors;
-    }
-
-    sector_end_aligned = sector_end - ((f->offset + len) % sector_size != 0 ? 1 : 0);
-
-    if (len == 0) {
-        return 0;
-    }
-
-    /* Unaligned at the start, we need to read the sector and incorporate the data. */
-    if (f->offset % sector_size != 0) {
-        size_t nb = (size_t)(len <= (sector_size - (f->offset % sector_size)) ? len : sector_size - (f->offset % sector_size));
-        no = emu_device_partition_read_data(&device->devpart, device->tmp_sector, sector_begin, 1, device->origin_path, device->num_parts, device->part_limit);
-        if (no != 0) {
-            r->_errno = no;
-            return -1;
-        }
-    
-        memcpy(data, device->tmp_sector + (f->offset % sector_size), nb);
-
-        /* Advance */
-        data += sector_size - (f->offset % sector_size);
-        current_sector++;
-    }
-
-    /* Check if we're already done (otherwise this causes a bug in handling the last sector of the range). */
-    if (current_sector == sector_end) {
-        f->offset += len;
-        return len;
-    }
-
-    /* Read all of the sector-aligned data. */
-    if (current_sector != sector_end_aligned) {        
-        no = emu_device_partition_read_data(&device->devpart, data, current_sector, sector_end_aligned - current_sector, device->origin_path, device->num_parts, device->part_limit);
-        if (no != 0) {
-            r->_errno = no;
-            return -1;
-        }
-    }
-
-    data += sector_size * (sector_end_aligned - current_sector);
-    current_sector = sector_end_aligned;
-
-    /* Unaligned at the end, we need to read the sector and incorporate the data. */
-    if (sector_end != sector_end_aligned) {
-        no = emu_device_partition_read_data(&device->devpart, device->tmp_sector, sector_end_aligned, 1, device->origin_path, device->num_parts, device->part_limit);
-        if (no != 0) {
-            r->_errno = no;
-            return -1;
-        }
-
-        memcpy(data, device->tmp_sector, (size_t)((f->offset + len) % sector_size));
-
-        /* Advance */
-        data += sector_size - ((f->offset + len) % sector_size);
-        current_sector++;
-    }
-
-    f->offset += len;
-    return len;
-}
-
-static off_t emudev_seek(struct _reent *r, void *fd, off_t pos, int whence) {
-    emudev_file_t *f = (emudev_file_t *)fd;
-    emudev_device_t *device = f->device;
-    uint64_t off;
-
-    switch (whence) {
-        case SEEK_SET:
-            off = 0;
-            break;
-        case SEEK_CUR:
-            off = f->offset;
-            break;
-        case SEEK_END:
-            off = device->devpart.num_sectors * device->devpart.sector_size;
-            break;
-        default:
-            r->_errno = EINVAL;
-            return -1;
-    }
-
-    if (pos < 0 && pos + off < 0) {
-        /* don't allow seek to before the beginning of the file */
-        r->_errno = EINVAL;
-        return -1;
-    }
-
-    f->offset = (uint64_t)(pos + off);
-    return (off_t)(pos + off);
-}
-
-static void emudev_stat_impl(emudev_device_t *device, struct stat *st) {
-    memset(st, 0, sizeof(struct stat));
-    st->st_size = (off_t)(device->devpart.num_sectors * device->devpart.sector_size);
-    st->st_nlink = 1;
-
-    st->st_blksize = device->devpart.sector_size;
-    st->st_blocks = st->st_size / st->st_blksize;
-
-    st->st_mode = S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
-}
-
-static int emudev_fstat(struct _reent *r, void *fd, struct stat *st) {
-    (void)r;
-    emudev_file_t *f = (emudev_file_t *)fd;
-    emudev_device_t *device = f->device;
-    emudev_stat_impl(device, st);
-
-    return 0;
-}
-
-static int emudev_stat(struct _reent *r, const char *file, struct stat *st) {
-    emudev_device_t *device = (emudev_device_t *)(r->deviceData);
-    if (strcmp(file, device->root_path) != 0) {
-        r->_errno = ENOENT;
-        return -1;
-    }
-
-    emudev_stat_impl(device, st);
-    return 0;
-}
-
-static int emudev_fsync(struct _reent *r, void *fd) {
-    /* Nothing to do. */
-    (void)r;
-    (void)fd;
-    return 0;
-}

fusee/fusee-secondary/src/emummc_cfg.h

@@ -85,6 +85,9 @@ typedef enum {
     FS_VER_10_0_0,
     FS_VER_10_0_0_EXFAT,
 
+    FS_VER_10_2_0,
+    FS_VER_10_2_0_EXFAT,
+
     FS_VER_MAX,
 } emummc_fs_ver_t;
 

fusee/fusee-secondary/src/exception_handlers.c

@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
  
+#include <stdio.h>
 #include <inttypes.h>
 
 #include "exception_handlers.h"
@@ -22,7 +23,7 @@
 #include "lib/log.h"
 
 #define CODE_DUMP_SIZE      0x30
-#define STACK_DUMP_SIZE     0x60
+#define STACK_DUMP_SIZE     0x30
 
 extern const uint32_t exception_handler_table[];
 
@@ -35,6 +36,40 @@ static const char *register_names[] = {
     "SP", "LR", "PC", "CPSR",
 };
 
+/* Adapted from https://gist.github.com/ccbrown/9722406 */
+static void hexdump(const void* data, size_t size, uintptr_t addrbase, char* strbuf) {
+    const uint8_t *d = (const uint8_t *)data;
+    char ascii[17] = {0};
+    ascii[16] = '\0';
+
+    for (size_t i = 0; i < size; i++) {
+        if (i % 16 == 0) {
+            strbuf += sprintf(strbuf, "%0*" PRIXPTR ": | ", 2 * sizeof(addrbase), addrbase + i);
+        }
+        strbuf += sprintf(strbuf, "%02X ", d[i]);
+        if (d[i] >= ' ' && d[i] <= '~') {
+            ascii[i % 16] = d[i];
+        } else {
+            ascii[i % 16] = '.';
+        }
+        if ((i+1) % 8 == 0 || i+1 == size) {
+            strbuf += sprintf(strbuf, " ");
+            if ((i+1) % 16 == 0) {
+                strbuf += sprintf(strbuf, "|  %s \n", ascii);
+            } else if (i+1 == size) {
+                ascii[(i+1) % 16] = '\0';
+                if ((i+1) % 16 <= 8) {
+                    strbuf += sprintf(strbuf, " ");
+                }
+                for (size_t j = (i+1) % 16; j < 16; j++) {
+                    strbuf += sprintf(strbuf, "   ");
+                }
+                strbuf += sprintf(strbuf, "|  %s \n", ascii);
+            }
+        }
+    }
+}
+
 void setup_exception_handlers(void) {
     volatile uint32_t *bpmp_exception_handler_table = (volatile uint32_t *)0x6000F200;
     for (int i = 0; i < 8; i++) {
@@ -45,38 +80,40 @@ void setup_exception_handlers(void) {
 }
 
 void exception_handler_main(uint32_t *registers, unsigned int exception_type) {
-    uint8_t code_dump[CODE_DUMP_SIZE];
-    uint8_t stack_dump[STACK_DUMP_SIZE];
-    size_t  code_dump_size;
-    size_t  stack_dump_size;
+    char exception_log[0x400] = {0};
+    uint8_t code_dump[CODE_DUMP_SIZE] = {0};
+    uint8_t stack_dump[STACK_DUMP_SIZE] = {0};
+    size_t code_dump_size = 0;
+    size_t stack_dump_size = 0;
 
     uint32_t pc = registers[15];
     uint32_t cpsr = registers[16];
-
     uint32_t instr_addr = pc + ((cpsr & 0x20) ? 2 : 4) - CODE_DUMP_SIZE;
 
-    print(SCREEN_LOG_LEVEL_ERROR, "\nSomething went wrong...\n");
-
+    sprintf(exception_log, "An exception occured!\n");
+    
     code_dump_size = safecpy(code_dump, (const void *)instr_addr, CODE_DUMP_SIZE);
     stack_dump_size = safecpy(stack_dump, (const void *)registers[13], STACK_DUMP_SIZE);
 
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\nException type: %s\n",
-            exception_names[exception_type]);
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\nRegisters:\n\n");
+    sprintf(exception_log + strlen(exception_log), "\nException type: %s\n", exception_names[exception_type]);
+    sprintf(exception_log + strlen(exception_log), "\nRegisters:\n");
 
     /* Print r0 to pc. */
     for (int i = 0; i < 16; i += 2) {
-        print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "%-7s%08"PRIX32"       %-7s%08"PRIX32"\n",
+        sprintf(exception_log + strlen(exception_log), "%-7s%08"PRIX32"       %-7s%08"PRIX32"\n",
                 register_names[i], registers[i], register_names[i+1], registers[i+1]);
     }
 
     /* Print cpsr. */
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "%-7s%08"PRIX32"\n", register_names[16], registers[16]);
-
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\nCode dump:\n");
-    hexdump(code_dump, code_dump_size, instr_addr);
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\nStack dump:\n");
-    hexdump(stack_dump, stack_dump_size, registers[13]);
-    print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\n");
-    fatal_error("An exception occurred!\n");
+    sprintf(exception_log + strlen(exception_log), "%-7s%08"PRIX32"\n", register_names[16], registers[16]);
+    
+    /* Print code and stack regions. */
+    sprintf(exception_log + strlen(exception_log), "\nCode dump:\n");    
+    hexdump(code_dump, code_dump_size, instr_addr, exception_log + strlen(exception_log));
+    sprintf(exception_log + strlen(exception_log), "\nStack dump:\n");
+    hexdump(stack_dump, stack_dump_size, registers[13], exception_log + strlen(exception_log));
+    sprintf(exception_log + strlen(exception_log), "\n");
+    
+    /* Throw fatal error with the full exception log. */
+    fatal_error(exception_log);
 }

fusee/fusee-secondary/src/fs_dev.c

@@ -302,7 +302,6 @@ int fsdev_register_keys(const char *name, unsigned int target_firmware, BisParti
     return 0;
 }
 
-
 int fsdev_unmount_all(void) {
     for (size_t i = 0; i < FF_VOLUMES; i++) {
         int ret = fsdev_unmount_device(g_fsdev_devices[i].name);

fusee/fusee-secondary/src/gpt.c

@@ -112,42 +112,3 @@ int gpt_iterate_through_entries(FILE *disk, size_t sector_size, gpt_entry_iterat
 
     return 0;
 }
-
-int gpt_iterate_through_emu_entries(FILE *disk, size_t sector_size, gpt_emu_entry_iterator_t callback, void *param, const char *origin_path, int num_parts, uint64_t part_limit) {
-    efi_header_t hdr;
-    efi_entry_t entry;
-    size_t offset = 2 * 512; /* Sector #2. */
-    size_t delta;
-
-    /* Get the header. */
-    if (gpt_get_header(&hdr, disk, sector_size) == -1) {
-        return -1;
-    }
-
-    /* Seek to the entry table. */
-    if (fseek(disk, sector_size * hdr.entries_first_lba - offset, SEEK_CUR) != 0) {
-        return -1;
-    }
-
-    offset = sector_size * hdr.entries_first_lba;
-    delta = hdr.entry_size - sizeof(efi_entry_t);
-
-    /* Iterate through the entries. */
-    for (uint32_t i = 0; i < hdr.entry_count; i++) {
-        if (!fread(&entry, sizeof(efi_entry_t), 1, disk)) {
-            return -1;
-        }
-
-        if (callback(&entry, param, offset, disk, origin_path, num_parts, part_limit) != 0) {
-            return -1;
-        }
-
-        if (delta != 0 && fseek(disk, delta, SEEK_CUR) != 0) {
-            return -1;
-        }
-
-        offset += hdr.entry_size;
-    }
-
-    return 0;
-}

fusee/fusee-secondary/src/gpt.h

@@ -56,6 +56,5 @@ typedef int (*gpt_emu_entry_iterator_t)(const efi_entry_t *entry, void *param, s
 
 int gpt_get_header(efi_header_t *out, FILE *disk, size_t sector_size);
 int gpt_iterate_through_entries(FILE *disk, size_t sector_size, gpt_entry_iterator_t callback, void *param);
-int gpt_iterate_through_emu_entries(FILE *disk, size_t sector_size, gpt_emu_entry_iterator_t callback, void *param, const char *origin_path, int num_parts, uint64_t part_limit);
 
 #endif

fusee/fusee-secondary/src/ips.c

@@ -420,6 +420,9 @@ static const uint8_t g_fs_hashes[FS_VER_MAX][0x8] = {
 
     "\x3E\xEB\xD9\xB7\xBC\xD1\xB5\xE0", /* FS_VER_10_0_0 */
     "\x81\x7E\xA2\xB0\xB7\x02\xC1\xF3", /* FS_VER_10_0_0_EXFAT */
+
+    "\xA9\x52\xB6\x57\xAD\xF9\xC2\xBA", /* FS_VER_10_2_0 */
+    "\x16\x0D\x3E\x10\x4E\xAD\x61\x76", /* FS_VER_10_2_0_EXFAT */
 };
 
 kip1_header_t *apply_kip_ips_patches(kip1_header_t *kip, size_t kip_size, emummc_fs_ver_t *out_fs_ver) {

fusee/fusee-secondary/src/kernel_patches.c

@@ -971,12 +971,6 @@ void package2_patch_kernel(void *_kernel, size_t *kernel_size, bool is_sd_kernel
         const uint32_t kernel_ldr_offset = *((volatile uint64_t *)((uintptr_t)_kernel + kernel_info->embedded_ini_ptr + 8));
         memcpy((void *)((uintptr_t)_kernel + kernel_ldr_offset), kernel_ldr_bin, kernel_ldr_bin_size);
 
-        /* Set target firmware for our kernel loader. */
-        uint32_t *kldr_u32 = (uint32_t *)((uintptr_t)_kernel + kernel_ldr_offset);
-        if (kldr_u32[1] == 0x30444C4D) {
-            kldr_u32[2] = target_firmware;
-        }
-
         /* Update size. */
         *kernel_size = kernel_ldr_offset + kernel_ldr_bin_size;
 

fusee/fusee-secondary/src/lib/log.h

@@ -17,7 +17,7 @@
 #ifndef FUSEE_LOG_H
 #define FUSEE_LOG_H
 
-#define PRINT_MESSAGE_MAX_LENGTH 512
+#define PRINT_MESSAGE_MAX_LENGTH 1024
 
 #include <stdarg.h>
 

fusee/fusee-secondary/src/nxboot.c

@@ -24,6 +24,7 @@
 #include "nxboot.h"
 #include "nxfs.h"
 #include "bct.h"
+#include "car.h"
 #include "di.h"
 #include "mc.h"
 #include "se.h"
@@ -64,7 +65,6 @@
 #undef u32
 
 extern const uint8_t warmboot_bin[];
-extern const uint32_t warmboot_bin_size;
 
 static const uint8_t retail_pkc_modulus[0x100] = {
     0xF7, 0x86, 0x47, 0xAB, 0x71, 0x89, 0x81, 0xB5, 0xCF, 0x0C, 0xB0, 0xE8, 0x48, 0xA7, 0xFD, 0xAD,
@@ -236,6 +236,9 @@ static uint32_t nxboot_get_specific_target_firmware(uint32_t target_firmware){
     #define CHECK_NCA(NCA_ID, VERSION) do { if (is_nca_present(NCA_ID)) { return ATMOSPHERE_TARGET_FIRMWARE_##VERSION; } } while(0)
 
     if (target_firmware >= ATMOSPHERE_TARGET_FIRMWARE_10_0_0) {
+        CHECK_NCA("26325de4db3909e0ef2379787c7e671d", 10_2_0);
+        CHECK_NCA("5077973537f6735b564dd7475b779f87", 10_1_1); /* Exclusive to China. */
+        CHECK_NCA("fd1faed0ca750700d254c0915b93d506", 10_1_0);
         CHECK_NCA("34728c771299443420820d8ae490ea41", 10_0_4);
         CHECK_NCA("5b1df84f88c3334335bbb45d8522cbb4", 10_0_3);
         CHECK_NCA("e951bc9dedcd54f65ffd83d4d050f9e0", 10_0_2);
@@ -632,6 +635,8 @@ uint32_t nxboot_main(void) {
     void *warmboot_memaddr;
     void *package1loader;
     size_t package1loader_size;
+    void *mesosphere;
+    size_t mesosphere_size;
     void *emummc;
     size_t emummc_size;
     uint32_t available_revision;
@@ -649,7 +654,7 @@ uint32_t nxboot_main(void) {
     } else {
         emummc_size = get_file_size("atmosphere/emummc.kip");
         if (emummc_size != 0) {
-            /* Allocate memory for the TSEC firmware. */
+            /* Allocate memory for the emummc KIP. */
             emummc = memalign(0x100, emummc_size);
 
             if (emummc == NULL) {
@@ -927,6 +932,28 @@ uint32_t nxboot_main(void) {
             pmc->scratch1 = (uint32_t)warmboot_memaddr;
     }
 
+    /* Configure mesosphere. */
+    /* TODO: Support non-SD/embedded mesosphere. */
+    {
+        size_t sd_meso_size = get_file_size("atmosphere/mesosphere.bin");
+        if (sd_meso_size != 0) {
+            if (sd_meso_size > PACKAGE2_SIZE_MAX) {
+                fatal_error("Error: atmosphere/mesosphere.bin is too large!\n");
+            }
+            mesosphere = malloc(sd_meso_size);
+            if (mesosphere == NULL) {
+                fatal_error("Error: failed to allocate mesosphere!\n");
+            }
+            if (read_from_file(mesosphere, sd_meso_size, "atmosphere/mesosphere.bin") != sd_meso_size) {
+                fatal_error("Error: failed to read atmosphere/mesosphere.bin!\n");
+            }
+            mesosphere_size = sd_meso_size;
+        } else {
+            mesosphere = NULL;
+            mesosphere_size = 0;
+        }
+    }
+
     print(SCREEN_LOG_LEVEL_INFO, "[NXBOOT] Rebuilding package2...\n");
 
     /* Parse stratosphere config. */
@@ -935,7 +962,7 @@ uint32_t nxboot_main(void) {
     print(SCREEN_LOG_LEVEL_INFO, u8"[NXBOOT] Configured Stratosphere...\n");
 
     /* Patch package2, adding Thermosphère + custom KIPs. */
-    package2_rebuild_and_copy(package2, MAILBOX_EXOSPHERE_CONFIGURATION->target_firmware, emummc, emummc_size);
+    package2_rebuild_and_copy(package2, MAILBOX_EXOSPHERE_CONFIGURATION->target_firmware, mesosphere, mesosphere_size, emummc, emummc_size);
 
     /* Set detected FS version. */
     MAILBOX_EXOSPHERE_CONFIGURATION->emummc_cfg.base_cfg.fs_version = stratosphere_get_fs_version();
@@ -990,6 +1017,12 @@ uint32_t nxboot_main(void) {
     /* Wait for the splash screen to have been displayed for as long as it should be. */
     splash_screen_wait_delay();
 
+    /* Set reset for USBD, USB2, AHBDMA, and APBDMA. */
+    rst_enable(CARDEVICE_USBD);
+    rst_enable(CARDEVICE_USB2);
+    rst_enable(CARDEVICE_AHBDMA);
+    rst_enable(CARDEVICE_APBDMA);
+
     /* Return the memory address for booting CPU0. */
     return (uint32_t)exosphere_memaddr;
 }

fusee/fusee-secondary/src/nxfs.c

@@ -36,7 +36,6 @@ static bool g_emmc_device_initialized = false;
 
 static bool g_fsdev_ready = false;
 static bool g_rawdev_ready = false;
-static bool g_emudev_ready = false;
 
 static bool g_is_emummc = false;
 
@@ -356,87 +355,6 @@ static int nxfs_mount_partition_gpt_callback(const efi_entry_t *entry, void *par
     return 0;
 }
 
-static int nxfs_mount_emu_partition_gpt_callback(const efi_entry_t *entry, void *param, size_t entry_offset, FILE *disk, const char *origin_path, int num_parts, uint64_t part_limit) {
-    (void)entry_offset;
-    (void)disk;
-    device_partition_t *parent = (device_partition_t *)param;
-    device_partition_t devpart = *parent;
-    char name_buffer[128];
-    const uint16_t *utf16name = entry->name;
-    uint32_t name_len;
-    int rc;
-
-    static const struct {
-        const char *partition_name;
-        const char *mount_point;
-        bool is_fat;
-        bool is_encrypted;
-        bool register_immediately;
-    } known_partitions[] = {
-        {"PRODINFO", "prodinfo", false, true, false},
-        {"PRODINFOF", "prodinfof", true, true, false},
-        {"BCPKG2-1-Normal-Main", "bcpkg21", false, false, true},
-        {"BCPKG2-2-Normal-Sub", "bcpkg22", false, false, false},
-        {"BCPKG2-3-SafeMode-Main", "bcpkg23", false, false, false},
-        {"BCPKG2-4-SafeMode-Sub", "bcpkg24", false, false, false},
-        {"BCPKG2-5-Repair-Main", "bcpkg25", false, false, false},
-        {"BCPKG2-6-Repair-Sub", "bcpkg26", false, false, false},
-        {"SAFE", "safe", true, true, false},
-        {"SYSTEM", "system", true, true, true},
-        {"USER", "user", true, true, false},
-    };
-
-    /* Convert the partition name to ASCII, for comparison. */
-    for (name_len = 0; name_len < sizeof(entry->name) && *utf16name != 0; name_len++) {
-        name_buffer[name_len] = (char)*utf16name++;
-    }
-    name_buffer[name_len] = '\0';
-
-    /* Mount the partition, if we know about it. */
-    for (size_t i = 0; i < sizeof(known_partitions)/sizeof(known_partitions[0]); i++) {
-        if (strcmp(name_buffer, known_partitions[i].partition_name) == 0) {
-            devpart.start_sector += entry->first_lba;
-            devpart.num_sectors = (entry->last_lba + 1) - entry->first_lba;
-            if (parent->num_sectors < devpart.num_sectors) {
-                errno = EINVAL;
-                return -1;
-            }
-
-            if (known_partitions[i].is_encrypted) {
-                devpart.read_cipher = nxfs_bis_crypto_decrypt;
-                devpart.write_cipher = nxfs_bis_crypto_encrypt;
-                devpart.crypto_mode = DevicePartitionCryptoMode_Xts;
-            }
-
-            if (known_partitions[i].is_fat) {
-                rc = fsdev_mount_device(known_partitions[i].mount_point, &devpart, false);
-                if (rc == -1) {
-                    return -1;
-                }
-                if (known_partitions[i].register_immediately) {
-                    rc = fsdev_register_device(known_partitions[i].mount_point);
-                    if (rc == -1) {
-                        return -1;
-                    }
-                }
-            } else {
-                rc = emudev_mount_device(known_partitions[i].mount_point, &devpart, origin_path, num_parts, part_limit);
-                if (rc == -1) {
-                    return -1;
-                }
-                if (known_partitions[i].register_immediately) {
-                    rc = emudev_register_device(known_partitions[i].mount_point);
-                    if (rc == -1) {
-                        return -1;
-                    }
-                }
-            }
-        }
-    }
-
-    return 0;
-}
-
 int nxfs_mount_sd() {
     device_partition_t model;
     int rc;
@@ -446,6 +364,7 @@ int nxfs_mount_sd() {
     model.device_struct = &g_sd_mmcpart;
     model.start_sector = 0;
     model.num_sectors = 1u << 30; /* arbitrary numbers of sectors. TODO: find the size of the SD in sectors. */
+    model.is_emulated = false;
 
     /* Mount the SD card device. */
     rc = fsdev_mount_device("sdmc", &model, true);
@@ -479,6 +398,7 @@ int nxfs_mount_emmc() {
     model.device_struct = &g_emmc_boot0_mmcpart;
     model.start_sector = 0;
     model.num_sectors = 0x184000 / model.sector_size;
+    model.is_emulated = false;
 
     /* Mount boot0 device. */
     rc = rawdev_mount_device("boot0", &model, true);
@@ -499,6 +419,7 @@ int nxfs_mount_emmc() {
     model.device_struct = &g_emmc_boot1_mmcpart;
     model.start_sector = 0;
     model.num_sectors = 0x80000 / model.sector_size;
+    model.is_emulated = false;
 
     /* Mount boot1 device. */
     rc = rawdev_mount_device("boot1", &model, false);
@@ -514,6 +435,7 @@ int nxfs_mount_emmc() {
     model.device_struct = &g_emmc_user_mmcpart;
     model.start_sector = 0;
     model.num_sectors = (256ull << 30) / model.sector_size;
+    model.is_emulated = false;
 
     /* Mount raw NAND device. */
     rc = rawdev_mount_device("rawnand", &model, false);
@@ -558,10 +480,11 @@ int nxfs_mount_emummc_partition(uint64_t emummc_start_sector) {
     model = g_emummc_devpart_template;
     model.start_sector = emummc_start_sector + (0x400000 * 0 / model.sector_size);
     model.num_sectors = 0x400000 / model.sector_size;
+    model.is_emulated = true;
     model.emu_use_file = false;
 
     /* Mount emulated boot0 device. */
-    rc = emudev_mount_device("boot0", &model, NULL, 0, 0);
+    rc = rawdev_mount_device("boot0", &model, true);
 
     /* Failed to mount boot0 device. */
     if (rc == -1) {
@@ -569,7 +492,7 @@ int nxfs_mount_emummc_partition(uint64_t emummc_start_sector) {
     }
 
     /* Register emulated boot0 device. */
-    rc = emudev_register_device("boot0");
+    rc = rawdev_register_device("boot0");
 
     /* Failed to register boot0 device. */
     if (rc == -1) {
@@ -580,10 +503,11 @@ int nxfs_mount_emummc_partition(uint64_t emummc_start_sector) {
     model = g_emummc_devpart_template;
     model.start_sector = emummc_start_sector + (0x400000 * 1 / model.sector_size);
     model.num_sectors = 0x400000 / model.sector_size;
+    model.is_emulated = true;
     model.emu_use_file = false;
 
     /* Mount emulated boot1 device. */
-    rc = emudev_mount_device("boot1", &model, NULL, 0, 0);
+    rc = rawdev_mount_device("boot1", &model, false);
 
     /* Failed to mount boot1. */
     if (rc == -1) {
@@ -596,10 +520,11 @@ int nxfs_mount_emummc_partition(uint64_t emummc_start_sector) {
     model = g_emummc_devpart_template;
     model.start_sector = emummc_start_sector + (0x400000 * 2 / model.sector_size);
     model.num_sectors = (256ull << 30) / model.sector_size;
+    model.is_emulated = true;
     model.emu_use_file = false;
 
     /* Mount emulated raw NAND device. */
-    rc = emudev_mount_device("rawnand", &model, NULL, 0, 0);
+    rc = rawdev_mount_device("rawnand", &model, false);
 
     /* Failed to mount raw NAND. */
     if (rc == -1) {
@@ -607,7 +532,7 @@ int nxfs_mount_emummc_partition(uint64_t emummc_start_sector) {
     }
 
     /* Register emulated raw NAND device. */
-    rc = emudev_register_device("rawnand");
+    rc = rawdev_register_device("rawnand");
 
     /* Failed to register raw NAND device. */
     if (rc == -1) {
@@ -623,14 +548,14 @@ int nxfs_mount_emummc_partition(uint64_t emummc_start_sector) {
     }
 
     /* Iterate the GPT and mount each emulated raw NAND partition. */
-    rc = gpt_iterate_through_emu_entries(rawnand, model.sector_size, nxfs_mount_emu_partition_gpt_callback, &model, NULL, 0, 0);
+    rc = gpt_iterate_through_entries(rawnand, model.sector_size, nxfs_mount_partition_gpt_callback, &model);
 
     /* Close emulated raw NAND device. */
     fclose(rawnand);
 
     /* All emulated devices are ready. */
     if (rc == 0) {
-        g_emudev_ready = true;
+        g_rawdev_ready = true;
         g_is_emummc = true;
     }
 
@@ -641,10 +566,9 @@ int nxfs_mount_emummc_file(const char *emummc_path, int num_parts, uint64_t part
     device_partition_t model;
     int rc;
     FILE *rawnand;
-    bool is_exfat;
     char emummc_boot0_path[0x300 + 1] = {0};
     char emummc_boot1_path[0x300 + 1] = {0};
-
+    
     /* Check if the SD card is EXFAT formatted. */
     rc = fsdev_is_exfat("sdmc");
 
@@ -652,29 +576,20 @@ int nxfs_mount_emummc_file(const char *emummc_path, int num_parts, uint64_t part
     if (rc == -1) {
         return -1;
     }
-
-    /* Set EXFAT status. */
-    is_exfat = (rc == 1);
-
-    /* Reject single part in FAT32. */
-    /* NOTE: This check has no effect in the current design. */
-    if (!is_exfat && (num_parts < 1)) {
-        return -2;
-    }
-
+    
     /* We want a folder with the archive bit set. */
     rc = fsdev_get_attr(emummc_path);
 
     /* Failed to get file DOS attributes. */
     if (rc == -1) {
-        return -3;
+        return -2;
     }
-
+    
     /* Our path is not a directory. */
     if (!(rc & AM_DIR)) {
-        return -4;
+        return -3;
     }
-
+    
     /* Check if the archive bit is not set. */
     if (!(rc & AM_ARC)) {
         /* Try to set the archive bit. */
@@ -682,102 +597,117 @@ int nxfs_mount_emummc_file(const char *emummc_path, int num_parts, uint64_t part
 
         /* Failed to set file DOS attributes. */
         if (rc == -1) {
-            return -5;
+            return -4;
         }
     }
-
+    
+    /* Prepare boot0 file path. */
+    snprintf(emummc_boot0_path, sizeof(emummc_boot0_path) - 1, "%s/%s", emummc_path, "boot0");
+    
     /* Setup an emulation template for boot0. */
     model = g_emummc_devpart_template;
     model.start_sector = 0;
     model.num_sectors = 0x400000 / model.sector_size;
+    model.is_emulated = true;
     model.emu_use_file = true;
-
-    /* Prepare boot0 file path. */
-    snprintf(emummc_boot0_path, sizeof(emummc_boot0_path) - 1, "%s/%s", emummc_path, "boot0");
+    model.emu_num_parts = 0;
+    model.emu_part_limit = 0;
+    strcpy(model.emu_root_path, emummc_path);
+    strcpy(model.emu_file_path, emummc_boot0_path);
 
     /* Mount emulated boot0 device. */
-    rc = emudev_mount_device("boot0", &model, emummc_boot0_path, 0, 0);
+    rc = rawdev_mount_device("boot0", &model, true);
 
     /* Failed to mount boot0 device. */
     if (rc == -1) {
-        return -6;
+        return -5;
     }
-
+    
     /* Register emulated boot0 device. */
-    rc = emudev_register_device("boot0");
+    rc = rawdev_register_device("boot0");
 
     /* Failed to register boot0 device. */
     if (rc == -1) {
-        return -7;
+        return -6;
     }
-
+    
+    /* Prepare boot1 file path. */
+    snprintf(emummc_boot1_path, sizeof(emummc_boot1_path) - 1, "%s/%s", emummc_path, "boot1");
+    
     /* Setup an emulation template for boot1. */
     model = g_emummc_devpart_template;
     model.start_sector = 0;
     model.num_sectors = 0x400000 / model.sector_size;
+    model.is_emulated = true;
     model.emu_use_file = true;
-
-    /* Prepare boot1 file path. */
-    snprintf(emummc_boot1_path, sizeof(emummc_boot1_path) - 1, "%s/%s", emummc_path, "boot1");
-
+    model.emu_num_parts = 0;
+    model.emu_part_limit = 0;
+    strcpy(model.emu_root_path, emummc_path);
+    strcpy(model.emu_file_path, emummc_boot1_path);
+    
     /* Mount emulated boot1 device. */
-    rc = emudev_mount_device("boot1", &model, emummc_boot1_path, 0, 0);
+    rc = rawdev_mount_device("boot1", &model, false);
 
     /* Failed to mount boot1. */
     if (rc == -1) {
-        return -8;
+        return -7;
     }
-
+    
     /* Register emulated boot1 device. */
-    rc = emudev_register_device("boot1");
+    rc = rawdev_register_device("boot1");
 
     /* Failed to register boot1 device. */
     if (rc == -1) {
-        return -9;
+        return -8;
     }
-
+    
     /* Setup a template for raw NAND. */
     model = g_emummc_devpart_template;
     model.start_sector = 0;
     model.num_sectors = (256ull << 30) / model.sector_size;
+    model.is_emulated = true;
     model.emu_use_file = true;
+    model.emu_num_parts = num_parts;
+    model.emu_part_limit = part_limit;
+    strcpy(model.emu_root_path, emummc_path);
+    strcpy(model.emu_file_path, emummc_path);
 
     /* Mount emulated raw NAND device from single or multiple parts. */
-    rc = emudev_mount_device("rawnand", &model, emummc_path, num_parts, part_limit);
+    rc = rawdev_mount_device("rawnand", &model, false);
 
     /* Failed to mount raw NAND. */
     if (rc == -1) {
-        return -10;
+        return -9;
     }
-
+    
     /* Register emulated raw NAND device. */
-    rc = emudev_register_device("rawnand");
+    rc = rawdev_register_device("rawnand");
 
     /* Failed to register raw NAND device. */
     if (rc == -1) {
-        return -11;
+        return -10;
     }
-
+    
     /* Open emulated raw NAND device. */
     rawnand = fopen("rawnand:/", "rb");
 
     /* Failed to open emulated raw NAND device. */
     if (rawnand == NULL) {
-        return -12;
+        return -11;
     }
-
+    
     /* Iterate the GPT and mount each emulated raw NAND partition. */
-    rc = gpt_iterate_through_emu_entries(rawnand, model.sector_size, nxfs_mount_emu_partition_gpt_callback, &model, emummc_path, num_parts, part_limit);
+    rc = gpt_iterate_through_entries(rawnand, model.sector_size, nxfs_mount_partition_gpt_callback, &model);
 
     /* Close emulated raw NAND device. */
     fclose(rawnand);
 
     /* All emulated devices are ready. */
     if (rc == 0) {
-        g_emudev_ready = true;
+        g_rawdev_ready = true;
         g_is_emummc = true;
     }
-
+    
     return rc;
 }
 
@@ -805,18 +735,6 @@ int nxfs_unmount_emmc() {
     return rc;
 }
 
-int nxfs_unmount_emummc() {
-    int rc = 0;
-
-    /* Unmount all emulated devices. */
-    if (g_emudev_ready) {
-        rc = emudev_unmount_all();
-        g_emudev_ready = false;
-    }
-
-    return rc;
-}
-
 int nxfs_init() {
     int rc;
 
@@ -832,5 +750,5 @@ int nxfs_init() {
 }
 
 int nxfs_end() {
-    return ((nxfs_unmount_sd() || nxfs_unmount_emmc() || nxfs_unmount_emummc()) ? -1 : 0);
+    return ((nxfs_unmount_sd() || nxfs_unmount_emmc()) ? -1 : 0);
 }

fusee/fusee-secondary/src/nxfs.h

@@ -19,7 +19,6 @@
 
 #include "fs_dev.h"
 #include "raw_dev.h"
-#include "emu_dev.h"
 
 int nxfs_init();
 int nxfs_end();

fusee/fusee-secondary/src/package2.c

@@ -44,7 +44,7 @@ static inline size_t align_to_4(size_t s) {
     return ((s + 3) >> 2) << 2;
 }
 
-void package2_rebuild_and_copy(package2_header_t *package2, uint32_t target_firmware, void *emummc, size_t emummc_size) {
+void package2_rebuild_and_copy(package2_header_t *package2, uint32_t target_firmware, void *mesosphere, size_t mesosphere_size, void *emummc, size_t emummc_size) {
     package2_header_t *rebuilt_package2;
     size_t rebuilt_package2_size;
     void *kernel;
@@ -95,10 +95,28 @@ void package2_rebuild_and_copy(package2_header_t *package2, uint32_t target_firm
         fatal_error("Error: inappropriate kernel embedded ini context");
     }
 
+    /* Use mesosphere instead of Nintendo's kernel when present. */
+    const bool is_mesosphere = mesosphere != NULL && mesosphere_size != 0;
+    if (is_mesosphere) {
+        kernel = mesosphere;
+        kernel_size = mesosphere_size;
+
+        /* Patch mesosphere to use our rebuilt ini. */
+        *(volatile uint64_t *)((uintptr_t)mesosphere + 8) = (uint64_t)mesosphere_size;
+
+        /* Place the kernel section at the correct location. */
+        package2->metadata.section_offsets[PACKAGE2_SECTION_KERNEL] = 0x60000;
+        package2->metadata.entrypoint                               = 0x60000;
+
+        print(SCREEN_LOG_LEVEL_DEBUG, "Using Mesosphere...\n");
+    }
+
     print(SCREEN_LOG_LEVEL_DEBUG, "Rebuilding the INI1 section...\n");
     if (target_firmware < ATMOSPHERE_TARGET_FIRMWARE_8_0_0) {
         package2_get_src_section((void *)&orig_ini1, package2, PACKAGE2_SECTION_INI1);
-    } else {
+    }
+
+    if (target_firmware >= ATMOSPHERE_TARGET_FIRMWARE_8_0_0 || is_mesosphere) {
         /* On 8.0.0, place INI1 right after kernelldr for our sanity. */
         package2->metadata.section_offsets[PACKAGE2_SECTION_INI1] = package2->metadata.section_offsets[PACKAGE2_SECTION_KERNEL] + kernel_size;
     }

fusee/fusee-secondary/src/package2.h

@@ -94,6 +94,6 @@ static inline uint8_t package2_meta_get_header_version(const package2_meta_t *me
     return (uint8_t)((metadata->ctr_dwords[1] ^ (metadata->ctr_dwords[1] >> 16) ^ (metadata->ctr_dwords[1] >> 24)) & 0xFF);
 }
 
-void package2_rebuild_and_copy(package2_header_t *package2, uint32_t target_firmware, void *emummc, size_t emummc_size);
+void package2_rebuild_and_copy(package2_header_t *package2, uint32_t target_firmware, void *mesosphere, size_t mesosphere_size, void *emummc, size_t emummc_size);
 
 #endif

fusee/fusee-secondary/src/raw_dev.c

@@ -77,9 +77,6 @@ static rawdev_device_t *rawdev_find_device(const char *name) {
 
 int rawdev_mount_device(const char *name, const device_partition_t *devpart, bool initialize_immediately) {
     rawdev_device_t *device = NULL;
-    char drname[40];
-    strcpy(drname, name);
-    strcat(drname, ":");
 
     if (name[0] == '\0' || devpart == NULL) {
         errno = EINVAL;
@@ -205,6 +202,19 @@ int rawdev_unmount_device(const char *name) {
     return 0;
 }
 
+int rawdev_register_keys(const char *name, unsigned int target_firmware, BisPartition part) {
+    rawdev_device_t *device = rawdev_find_device(name);
+
+    if (device == NULL) {
+        errno = ENOENT;
+        return -1;
+    }
+
+    derive_bis_key(device->devpart.keys, part, target_firmware);
+
+    return 0;
+}
+
 int rawdev_unmount_all(void) {
     for (size_t i = 0; i < RAWDEV_MAX_DEVICES; i++) {
         int rc = rawdev_unmount_device(g_rawdev_devices[i].name);

fusee/fusee-secondary/src/raw_dev.h

@@ -21,6 +21,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include "device_partition.h"
+#include "key_derivation.h"
 
 #define RAWDEV_MAX_DEVICES 16
 
@@ -29,6 +30,8 @@ int rawdev_register_device(const char *name);
 int rawdev_unregister_device(const char *name);
 int rawdev_unmount_device(const char *name);        /* also unregisters. */
 
+int rawdev_register_keys(const char *name, unsigned int target_firmware, BisPartition part);
+
 int rawdev_unmount_all(void);
 
 #endif

fusee/fusee-secondary/src/stratosphere.c

@@ -51,7 +51,6 @@ static bool g_stratosphere_boot_enabled = true;
 static bool g_stratosphere_ncm_enabled = false;
 
 extern const uint8_t loader_kip[], pm_kip[], sm_kip[], spl_kip[], boot_kip[], ncm_kip[], ams_mitm_kip[];
-extern const uint32_t loader_kip_size, pm_kip_size, sm_kip_size, spl_kip_size, boot_kip_size, ncm_kip_size, ams_mitm_kip_size;
 
 static emummc_fs_ver_t g_fs_ver = FS_VER_1_0_0;
 

fusee/fusee-secondary/src/utils.c

@@ -157,12 +157,18 @@ __attribute__ ((noreturn)) void generic_panic(void) {
 }
 
 __attribute__((noreturn)) void fatal_error(const char *fmt, ...) {
+    /* Override the global logging level. */
+    log_set_log_level(SCREEN_LOG_LEVEL_ERROR);
+        
+    /* Display fatal error. */
     va_list args;
     print(SCREEN_LOG_LEVEL_ERROR, "Fatal error: ");
     va_start(args, fmt);
     vprint(SCREEN_LOG_LEVEL_ERROR, fmt, args);
     va_end(args);
     print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\n Press POWER to reboot.\n");
+    
+    /* Wait for button and reboot. */
     wait_for_button_and_reboot();
 }
 
@@ -174,37 +180,3 @@ __attribute__((noinline)) bool overlaps(uint64_t as, uint64_t ae, uint64_t bs, u
         return true;
     return false;
 }
-
-/* Adapted from https://gist.github.com/ccbrown/9722406 */
-void hexdump(const void* data, size_t size, uintptr_t addrbase) {
-    const uint8_t *d = (const uint8_t *)data;
-    char ascii[17];
-    ascii[16] = '\0';
-
-    for (size_t i = 0; i < size; i++) {
-        if (i % 16 == 0) {
-            printf("%0*" PRIXPTR ": | ", 2 * sizeof(addrbase), addrbase + i);
-        }
-        printf("%02X ", d[i]);
-        if (d[i] >= ' ' && d[i] <= '~') {
-            ascii[i % 16] = d[i];
-        } else {
-            ascii[i % 16] = '.';
-        }
-        if ((i+1) % 8 == 0 || i+1 == size) {
-            printf(" ");
-            if ((i+1) % 16 == 0) {
-                printf("|  %s \n", ascii);
-            } else if (i+1 == size) {
-                ascii[(i+1) % 16] = '\0';
-                if ((i+1) % 16 <= 8) {
-                    printf(" ");
-                }
-                for (size_t j = (i+1) % 16; j < 16; j++) {
-                    printf("   ");
-                }
-                printf("|  %s \n", ascii);
-            }
-        }
-    }
-}

fusee/fusee-secondary/src/utils.h

@@ -118,8 +118,6 @@ static inline bool check_32bit_address_range_in_program(uintptr_t addr, size_t s
     overlaps_a(start, end, __start__, __end__);
 }
 
-void hexdump(const void* data, size_t size, uintptr_t addrbase);
-
 __attribute__((noreturn)) void watchdog_reboot(void);
 __attribute__((noreturn)) void pmc_reboot(uint32_t scratch0);
 __attribute__((noreturn)) void reboot_to_fusee_primary(void);
@@ -129,8 +127,6 @@ __attribute__((noreturn)) void wait_for_button_and_reboot(void);
 void wait_for_button(void);
 
 __attribute__((noreturn)) void generic_panic(void);
-
 __attribute__((noreturn)) void fatal_error(const char *fmt, ...);
 
-
 #endif

libraries/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/Atmosphere-NX/Atmosphere-libs
 	branch = master
-	commit = 89f8944f8025c0557a18e64ceca7f65ab3090d82
-	parent = 29f1eb807066bdb551f8b1f7352c97e5ac62d436
+	commit = f6dac1e67793233cc916f317cf517244dd348a5e
+	parent = 909a1767a6080bab7ea6032c00e1ff4cec993af0
 	method = merge
 	cmdver = 0.4.1

libraries/Makefile

@@ -1,4 +1,4 @@
-ATMOSPHERE_LIBRARIES := libmesosphere libstratosphere
+ATMOSPHERE_LIBRARIES := libmesosphere libstratosphere libexosphere
 
 TOPTARGETS := all clean
 

libraries/config/arch/arm64/arch.mk

@@ -5,7 +5,7 @@ endif
 include $(DEVKITPRO)/devkitA64/base_rules
 
 export ATMOSPHERE_DEFINES  += -DATMOSPHERE_ARCH_ARM64
-export ATMOSPHERE_SETTINGS += -march=armv8-a+crc+crypto -mtp=soft
+export ATMOSPHERE_SETTINGS += -mtp=soft
 export ATMOSPHERE_CFLAGS   +=
 export ATMOSPHERE_CXXFLAGS +=
 export ATMOSPHERE_ASFLAGS  +=

libraries/config/arch/arm64/cpu/cortex_a57/cpu.mk

@@ -1,5 +1,5 @@
 export ATMOSPHERE_DEFINES  += -DATMOSPHERE_CPU_ARM_CORTEX_A57
-export ATMOSPHERE_SETTINGS += -mtune=cortex-a57
+export ATMOSPHERE_SETTINGS += -march=armv8-a+crc+crypto -mtune=cortex-a57
 export ATMOSPHERE_CFLAGS   +=
 export ATMOSPHERE_CXXFLAGS +=
 export ATMOSPHERE_ASFLAGS  +=

libraries/config/common.mk

@@ -10,7 +10,7 @@ ifeq ($(strip $(ATMOSPHERE_BOARD)),)
 export ATMOSPHERE_BOARD := nx-hac-001
 
 ifeq ($(strip $(ATMOSPHERE_CPU)),)
-export ATMOSPHERE_CPU   := arm-cortex-a57
+export ATMOSPHERE_CPU            := arm-cortex-a57
 endif
 
 endif
@@ -19,7 +19,7 @@ export ATMOSPHERE_DEFINES  := -DATMOSPHERE
 export ATMOSPHERE_SETTINGS := -fPIE -g
 export ATMOSPHERE_CFLAGS   := -Wall -ffunction-sections -fdata-sections -fno-strict-aliasing -fwrapv  \
                               -fno-asynchronous-unwind-tables -fno-unwind-tables -fno-stack-protector \
-                              -Wno-format-truncation
+                              -Wno-format-truncation -Wno-format-zero-length -Wno-stringop-truncation
 
 export ATMOSPHERE_CXXFLAGS := -fno-rtti -fno-exceptions -std=gnu++20
 export ATMOSPHERE_ASFLAGS  :=
@@ -28,40 +28,44 @@ export ATMOSPHERE_ASFLAGS  :=
 ifeq ($(ATMOSPHERE_BOARD),nx-hac-001)
 
 ifeq ($(ATMOSPHERE_CPU),arm-cortex-a57)
-export ATMOSPHERE_ARCH_DIR   := arch/arm64
-export ATMOSPHERE_BOARD_DIR  := board/nintendo/nx
-export ATMOSPHERE_OS_DIR     := os/horizon
+export ATMOSPHERE_ARCH_DIR   := arm64
+export ATMOSPHERE_BOARD_DIR  := nintendo/nx
+export ATMOSPHERE_OS_DIR     := horizon
 
 export ATMOSPHERE_ARCH_NAME  := arm64
 export ATMOSPHERE_BOARD_NAME := nintendo_nx
 export ATMOSPHERE_OS_NAME    := horizon
+
+export ATMOSPHERE_CPU_EXTENSIONS := arm_crypto_extension aarch64_crypto_extension
 else ifeq ($(ATMOSPHERE_CPU),arm7tdmi)
-export ATMOSPHERE_ARCH_DIR   := arch/arm
-export ATMOSPHERE_BOARD_DIR  := board/nintendo/nx_bpmp
-export ATMOSPHERE_OS_DIR     := os/horizon
+export ATMOSPHERE_ARCH_DIR   := arm
+export ATMOSPHERE_BOARD_DIR  := nintendo/nx_bpmp
+export ATMOSPHERE_OS_DIR     := horizon
 
 export ATMOSPHERE_ARCH_NAME  := arm
 export ATMOSPHERE_BOARD_NAME := nintendo_nx
 export ATMOSPHERE_OS_NAME    := horizon
+
+export ATMOSPHERE_CPU_EXTENSIONS :=
 endif
 
 endif
 
 ifeq ($(ATMOSPHERE_CPU),arm-cortex-a57)
-export ATMOSPHERE_CPU_DIR    := arch/arm64/cpu/cortex_a57
+export ATMOSPHERE_CPU_DIR    := cortex_a57
 export ATMOSPHERE_CPU_NAME   := arm_cortex_a57
 endif
 
 ifeq ($(ATMOSPHERE_CPU),arm7tdmi)
-export ATMOSPHERE_CPU_DIR    := arch/arm/cpu/arm7tdmi
+export ATMOSPHERE_CPU_DIR    := arm7tdmi
 export ATMOSPHERE_CPU_NAME   := arm7tdmi
 endif
 
 
-export ATMOSPHERE_ARCH_MAKE_DIR  := $(ATMOSPHERE_CONFIG_MAKE_DIR)/$(ATMOSPHERE_ARCH_DIR)
-export ATMOSPHERE_BOARD_MAKE_DIR := $(ATMOSPHERE_CONFIG_MAKE_DIR)/$(ATMOSPHERE_BOARD_DIR)
-export ATMOSPHERE_OS_MAKE_DIR    := $(ATMOSPHERE_CONFIG_MAKE_DIR)/$(ATMOSPHERE_OS_DIR)
-export ATMOSPHERE_CPU_MAKE_DIR   := $(ATMOSPHERE_CONFIG_MAKE_DIR)/$(ATMOSPHERE_CPU_DIR)
+export ATMOSPHERE_ARCH_MAKE_DIR  := $(ATMOSPHERE_CONFIG_MAKE_DIR)/arch/$(ATMOSPHERE_ARCH_DIR)
+export ATMOSPHERE_BOARD_MAKE_DIR := $(ATMOSPHERE_CONFIG_MAKE_DIR)/board/$(ATMOSPHERE_BOARD_DIR)
+export ATMOSPHERE_OS_MAKE_DIR    := $(ATMOSPHERE_CONFIG_MAKE_DIR)/os/$(ATMOSPHERE_OS_DIR)
+export ATMOSPHERE_CPU_MAKE_DIR   := $(ATMOSPHERE_ARCH_MAKE_DIR)/cpu/$(ATMOSPHERE_CPU_DIR)
 
 export ATMOSPHERE_LIBRARY_DIR := lib_$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)
 export ATMOSPHERE_BUILD_DIR := build_$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)
@@ -102,12 +106,32 @@ BUILD        := build
 DATA         := data
 INCLUDES     := include
 
-GENERAL_SOURCE_DIRS=$1 $(foreach d,$(filter-out $1/arch $1/board $1,$(wildcard $1/*)),$(if $(wildcard $d/.),$(call DIR_WILDCARD,$d) $d,))
-SPECIFIC_SOURCE_DIRS=$(if $(wildcard $1/$2/.*),$1/$2 $(call DIR_WILDCARD,$1/$2),)
-ALL_SOURCE_DIRS=$(call GENERAL_SOURCE_DIRS,$1) $(call SPECIFIC_SOURCE_DIRS,$1,$(ATMOSPHERE_ARCH_DIR)) $(call SPECIFIC_SOURCE_DIRS,$1,$(ATMOSPHERE_BOARD_DIR)) $(call SPECIFIC_SOURCE_DIRS,$1,$(ATMOSPHERE_OS_DIR))
+GENERAL_SOURCE_DIRS=$1 $(foreach d,$(filter-out $1/arch $1/board $1/os $1/cpu $1,$(wildcard $1/*)),$(if $(wildcard $d/.),$(call DIR_WILDCARD,$d) $d,))
+SPECIFIC_SOURCE_DIRS=$(if $(wildcard $1/$2/$3/.*),$1/$2/$3 $(call DIR_WILDCARD,$1/$2/$3),$(if $(wildcard $1/$2/generic/.*), $1/$2/generic $(call DIR_WILDCARD,$1/$2/generic),))
+UNFILTERED_SOURCE_DIRS=$1 $(foreach d,$(wildcard $1/*),$(if $(wildcard $d/.),$(call DIR_WILDCARD,$d) $d,))
+
+ALL_SOURCE_DIRS=$(call GENERAL_SOURCE_DIRS,$1) \
+                $(call SPECIFIC_SOURCE_DIRS,$1,arch,$(ATMOSPHERE_ARCH_DIR)) \
+                $(call SPECIFIC_SOURCE_DIRS,$1,board,$(ATMOSPHERE_BOARD_DIR)) \
+                $(call SPECIFIC_SOURCE_DIRS,$1,os,$(ATMOSPHERE_OS_DIR)) \
+                $(call SPECIFIC_SOURCE_DIRS,$1,cpu,$(ATMOSPHERE_ARCH_DIR)/$(ATMOSPHERE_CPU_DIR))
 
 SOURCES      ?= $(call ALL_SOURCE_DIRS,source)
 
+FIND_SPECIFIC_SOURCE_FILES= $(notdir $(wildcard $1/*.$2.$3.$4)) $(filter-out $(subst .$2.$3.,.$2.generic.,$(notdir $(wildcard $1/*.$2.$3.$4))),$(notdir $(wildcard $1/*.$2.generic.$4)))
+
+FIND_SPECIFIC_SOURCE_FILES_EX=$(foreach ext,$3,$(notdir $(wildcard $1/*.$2.$(ext).$4))) $(filter-out $(foreach ext,$3,$(subst .$2.$(ext).,.$2.generic.,$(notdir $(wildcard $1/*.$2.$(ext).$4)))),$(notdir $(wildcard $1/*.$2.generic.$4)))
+
+FIND_SOURCE_FILES=$(foreach dir,$1,$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.$2)) \
+                                                    $(notdir $(wildcard $(dir)/*.board.*.$2)) \
+                                                    $(notdir $(wildcard $(dir)/*.os.*.$2)) \
+                                                    $(notdir $(wildcard $(dir)/.cpu.*.$2)), \
+                                                $(notdir $(wildcard $(dir)/*.$2)))) \
+                  $(foreach dir,$1,$(call FIND_SPECIFIC_SOURCE_FILES,$(dir),arch,$(ATMOSPHERE_ARCH_NAME),$2)) \
+                  $(foreach dir,$1,$(call FIND_SPECIFIC_SOURCE_FILES,$(dir),board,$(ATMOSPHERE_BOARD_NAME),$2)) \
+                  $(foreach dir,$1,$(call FIND_SPECIFIC_SOURCE_FILES,$(dir),os,$(ATMOSPHERE_OS_NAME),$2)) \
+                  $(foreach dir,$1,$(call FIND_SPECIFIC_SOURCE_FILES_EX,$(dir),cpu,$(ATMOSPHERE_CPU_NAME) $(ATMOSPHERE_CPU_EXTENSIONS),$2))
+
 #---------------------------------------------------------------------------------
 # Rules for compiling pre-compiled headers
 #---------------------------------------------------------------------------------

libraries/config/templates/exosphere.mk

@@ -8,7 +8,7 @@ include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../common.mk
 #---------------------------------------------------------------------------------
 ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),arm64)
 DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_EXOSPHERE
-SETTINGS    := $(ATMOSPHERE_SETTINGS) -mgeneral-regs-only -ffixed-x18 -Os -Werror -fno-non-call-exceptions
+SETTINGS    := $(ATMOSPHERE_SETTINGS) -mgeneral-regs-only -ffixed-x18 -Os -Wextra -Werror -fno-non-call-exceptions
 CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit
 ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS)

libraries/config/templates/mesosphere.mk

@@ -7,12 +7,12 @@ include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../common.mk
 # options for code generation
 #---------------------------------------------------------------------------------
 export DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_MESOSPHERE
-export SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2 -mgeneral-regs-only -ffixed-x18 -Werror -fno-non-call-exceptions
+export SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2 -mgeneral-regs-only -ffixed-x18 -Wextra -Werror -fno-non-call-exceptions
 export CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 export CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit
-export ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS) $(DEFINES)
+export ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 
-export LDFLAGS	=	-specs=$(TOPDIR)/$(notdir $(TOPDIR)).specs -nostdlib -nostartfiles -g $(SETTINGS) -Wl,-Map,$(notdir $*.map) -Wl,-z,relro,-z,now
+export LDFLAGS	=	-specs=$(TOPDIR)/$(notdir $(TOPDIR)).specs -fno-asynchronous-unwind-tables -fno-unwind-tables -nostdlib -nostartfiles -g $(SETTINGS) -Wl,-Map,$(notdir $*.map) -Wl,-z,relro,-z,now
 
 export CXXWRAPS := -Wl,--wrap,__cxa_pure_virtual \
 			-Wl,--wrap,__cxa_throw \

libraries/libexosphere/arm.mk

@@ -14,7 +14,7 @@ include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../config/common.mk
 #---------------------------------------------------------------------------------
 
 DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_EXOSPHERE
-SETTINGS    := $(ATMOSPHERE_SETTINGS) -Os -Werror -flto -fno-non-call-exceptions
+SETTINGS    := $(ATMOSPHERE_SETTINGS) -Os -Wextra -Werror -flto -fno-non-call-exceptions
 CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit
 ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS)
@@ -39,23 +39,9 @@ ifneq ($(BUILD),$(notdir $(CURDIR)))
 export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
 			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
 
-CFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.c)) $(notdir $(wildcard $(dir)/*.board.*.c)) $(notdir $(wildcard $(dir)/*.os.*.c)), \
-                                                      $(notdir $(wildcard $(dir)/*.c))))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).c)))
-
-CPPFILES    :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.cpp)) $(notdir $(wildcard $(dir)/*.board.*.cpp)) $(notdir $(wildcard $(dir)/*.os.*.cpp)), \
-                                                      $(notdir $(wildcard $(dir)/*.cpp))))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).cpp)))
-
-SFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.s)) $(notdir $(wildcard $(dir)/*.board.*.s)) $(notdir $(wildcard $(dir)/*.os.*.s)), \
-                                                      $(notdir $(wildcard $(dir)/*.s))))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).s)))
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
 
 #---------------------------------------------------------------------------------
 # use CXX for linking C++ projects, CC for standard C

libraries/libexosphere/arm64.mk

@@ -14,7 +14,7 @@ include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../config/common.mk
 #---------------------------------------------------------------------------------
 
 DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_EXOSPHERE
-SETTINGS    := $(ATMOSPHERE_SETTINGS) -mgeneral-regs-only -ffixed-x18 -Os -Werror -fno-non-call-exceptions
+SETTINGS    := $(ATMOSPHERE_SETTINGS) -mgeneral-regs-only -ffixed-x18 -Os -Wextra -Werror -fno-non-call-exceptions
 CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit
 ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS)
@@ -39,23 +39,9 @@ ifneq ($(BUILD),$(notdir $(CURDIR)))
 export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
 			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
 
-CFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.c)) $(notdir $(wildcard $(dir)/*.board.*.c)) $(notdir $(wildcard $(dir)/*.os.*.c)), \
-                                                      $(notdir $(wildcard $(dir)/*.c))))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).c)))
-
-CPPFILES    :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.cpp)) $(notdir $(wildcard $(dir)/*.board.*.cpp)) $(notdir $(wildcard $(dir)/*.os.*.cpp)), \
-                                                      $(notdir $(wildcard $(dir)/*.cpp))))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).cpp)))
-
-SFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.s)) $(notdir $(wildcard $(dir)/*.board.*.s)) $(notdir $(wildcard $(dir)/*.os.*.s)), \
-                                                      $(notdir $(wildcard $(dir)/*.s))))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).s)))
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
 
 #---------------------------------------------------------------------------------
 # use CXX for linking C++ projects, CC for standard C

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

@@ -89,7 +89,13 @@ namespace ams::secmon {
 
     constexpr inline const SecureMonitorConfiguration DefaultSecureMonitorConfiguration = {
         .target_firmware = ams::TargetFirmware_Current,
+        .key_generation  = {},
+        .hardware_type   = {},
+        .soc_type        = {},
+        .hardware_state  = {},
+        .pad_0B          = {},
         .flags           = SecureMonitorConfigurationFlag_Default,
+        .reserved        = {},
     };
 
 }

libraries/libexosphere/include/exosphere/tegra/tegra_clkrst.hpp

@@ -203,12 +203,12 @@ DEFINE_CLK_RST_REG_BIT_ENUM(RST_CPUG_CMPLX_CLR_CLR_NONCPURESET, 29, DISABLE, ENA
     HANDLER(H, MEM,           1,  0)    \
     HANDLER(H, AHBDMA,        1,  1)    \
     HANDLER(H, APBDMA,        1,  2)    \
-    HANDLER(H, USB2,          1, 26)    \
     HANDLER(H, PMC,           1,  6)    \
     HANDLER(H, FUSE,          1,  7)    \
     HANDLER(H, KFUSE,         1,  8)    \
     HANDLER(H, I2C5,          1, 15)    \
     HANDLER(H, EMC,           1, 25)    \
+    HANDLER(H, USB2,          1, 26)    \
     HANDLER(U, CSITE,         2,  9)    \
     HANDLER(U, IRAMA,         2, 20)    \
     HANDLER(U, IRAMB,         2, 21)    \

libraries/libexosphere/include/exosphere/tegra/tegra_pmc.hpp

@@ -114,6 +114,7 @@
 #define APBDEV_PMC_SECURE_SCRATCH113    (0xB1C)
 #define APBDEV_PMC_SECURE_SCRATCH114    (0xB20)
 #define APBDEV_PMC_SECURE_SCRATCH115    (0xB24)
+#define APBDEV_PMC_SECURE_SCRATCH119    (0xB34)
 
 
 #define PMC_REG_BITS_MASK(NAME)                                      REG_NAMED_BITS_MASK    (APBDEV_PMC, NAME)

libraries/libexosphere/source/clkrst/clkrst_api.cpp

@@ -38,7 +38,7 @@ namespace ams::clkrst {
             reg::ReadWrite(g_register_address + param.clk_enb_offset, REG_BITS_VALUE(param.index, 1, 0));
 
             /* Set the clock source. */
-            if (param.clk_src != 0) {
+            if (param.clk_src_offset != 0) {
                 reg::Write(g_register_address + param.clk_src_offset, (param.clk_src << 29) | (param.clk_div << 0));
             }
 
@@ -89,11 +89,11 @@ namespace ams::clkrst {
     }
 
     void EnableUartBClock() {
-        EnableClock(UartAClock);
+        EnableClock(UartBClock);
     }
 
     void EnableUartCClock() {
-        EnableClock(UartAClock);
+        EnableClock(UartCClock);
     }
 
     void EnableActmonClock() {

libraries/libexosphere/source/crypto/crypto_aes_impl_security_engine.cpp

@@ -33,6 +33,8 @@ namespace ams::crypto::impl {
     template<size_t KeySize>
     void AesImpl<KeySize>::Initialize(const void *key, size_t key_size, bool is_encrypt) {
         static_assert(IsSupportedKeySize(KeySize));
+        AMS_ASSERT(key_size == sizeof(int));
+        AMS_UNUSED(is_encrypt);
 
         /* Set the security engine keyslot. */
         this->slot = *static_cast<const int *>(key);
@@ -50,9 +52,11 @@ namespace ams::crypto::impl {
         } else if constexpr (KeySize == 24) {
             /* Aes 192. */
             /* TODO: se::EncryptAes192(dst, dst_size, this->slot, src, src_size); */
+            AMS_UNUSED(dst, dst_size, src, src_size);
         } else if constexpr (KeySize == 32) {
             /* Aes 256. */
             /* TODO: se::EncryptAes256(dst, dst_size, this->slot, src, src_size); */
+            AMS_UNUSED(dst, dst_size, src, src_size);
         } else {
             /* Invalid key size. */
             static_assert(!std::is_same<AesImpl<KeySize>, AesImpl<KeySize>>::value);
@@ -71,9 +75,11 @@ namespace ams::crypto::impl {
         } else if constexpr (KeySize == 24) {
             /* Aes 192. */
             /* TODO: se::DecryptAes192(dst, dst_size, this->slot, src, src_size); */
+            AMS_UNUSED(dst, dst_size, src, src_size);
         } else if constexpr (KeySize == 32) {
             /* Aes 256. */
             /* TODO: se::DecryptAes256(dst, dst_size, this->slot, src, src_size); */
+            AMS_UNUSED(dst, dst_size, src, src_size);
         } else {
             /* Invalid key size. */
             static_assert(!std::is_same<AesImpl<KeySize>, AesImpl<KeySize>>::value);

libraries/libexosphere/source/i2c/i2c_api.cpp

@@ -88,6 +88,8 @@ namespace ams::i2c {
         }
 
         bool Write(uintptr_t base_address, Port port, int address, const void *src, size_t src_size, bool unused) {
+            AMS_UNUSED(port, unused);
+
             /* Ensure we don't write too much. */
             u32 data = 0;
             if (src_size > MaxTransferSize) {
@@ -125,6 +127,8 @@ namespace ams::i2c {
         }
 
         bool Read(uintptr_t base_address, Port port, void *dst, size_t dst_size, int address, bool unused) {
+            AMS_UNUSED(port, unused);
+
             /* Ensure we don't read too much. */
             if (dst_size > MaxTransferSize) {
                 return false;

libraries/libexosphere/source/log/log_api.cpp

@@ -48,12 +48,14 @@ namespace ams::log {
                 clkrst::EnableUartAClock();
             } else if constexpr (UartLogPort == uart::Port_LeftJoyCon) {
                 /* Logging to left joy-con (e.g. with Joyless). */
-                pinmux::SetupUartB();
-                clkrst::EnableUartBClock();
-            } else if constexpr (UartLogPort == uart::Port_RightJoyCon) {
-                /* Logging to right joy-con (e.g. with Joyless). */
+                static_assert(uart::Port_LeftJoyCon == uart::Port_C);
                 pinmux::SetupUartC();
                 clkrst::EnableUartCClock();
+            } else if constexpr (UartLogPort == uart::Port_RightJoyCon) {
+                /* Logging to right joy-con (e.g. with Joyless). */
+                static_assert(uart::Port_RightJoyCon == uart::Port_B);
+                pinmux::SetupUartB();
+                clkrst::EnableUartBClock();
             } else {
                 __builtin_unreachable();
             }

libraries/libexosphere/source/pinmux/pinmux_api.cpp

@@ -104,7 +104,7 @@ namespace ams::pinmux {
         /* Get the registers. */
         const uintptr_t PINMUX = g_pinmux_address;
 
-        /* Configure Uart-B. */
+        /* Configure Uart-C. */
         reg::Write(PINMUX + PINMUX_AUX_UART3_TX,  PINMUX_REG_BITS_ENUM(AUX_UART3_PM,       UARTC),
                                                   PINMUX_REG_BITS_ENUM(AUX_PUPD,            NONE),
                                                   PINMUX_REG_BITS_ENUM(AUX_TRISTATE, PASSTHROUGH),
@@ -114,13 +114,13 @@ namespace ams::pinmux {
 
         reg::Write(PINMUX + PINMUX_AUX_UART3_RX,  PINMUX_REG_BITS_ENUM(AUX_UART3_PM,       UARTC),
                                                   PINMUX_REG_BITS_ENUM(AUX_PUPD,            NONE),
-                                                  PINMUX_REG_BITS_ENUM(AUX_TRISTATE, PASSTHROUGH),
+                                                  PINMUX_REG_BITS_ENUM(AUX_TRISTATE,    TRISTATE),
                                                   PINMUX_REG_BITS_ENUM(AUX_E_INPUT,       ENABLE),
                                                   PINMUX_REG_BITS_ENUM(AUX_LOCK,         DISABLE),
                                                   PINMUX_REG_BITS_ENUM(AUX_E_OD,         DISABLE));
 
         reg::Write(PINMUX + PINMUX_AUX_UART3_RTS, PINMUX_REG_BITS_ENUM(AUX_UART3_PM,       UARTC),
-                                                  PINMUX_REG_BITS_ENUM(AUX_PUPD,            NONE),
+                                                  PINMUX_REG_BITS_ENUM(AUX_PUPD,       PULL_DOWN),
                                                   PINMUX_REG_BITS_ENUM(AUX_TRISTATE, PASSTHROUGH),
                                                   PINMUX_REG_BITS_ENUM(AUX_E_INPUT,      DISABLE),
                                                   PINMUX_REG_BITS_ENUM(AUX_LOCK,         DISABLE),
@@ -128,13 +128,16 @@ namespace ams::pinmux {
 
         reg::Write(PINMUX + PINMUX_AUX_UART3_CTS, PINMUX_REG_BITS_ENUM(AUX_UART3_PM,       UARTC),
                                                   PINMUX_REG_BITS_ENUM(AUX_PUPD,            NONE),
-                                                  PINMUX_REG_BITS_ENUM(AUX_TRISTATE, PASSTHROUGH),
+                                                  PINMUX_REG_BITS_ENUM(AUX_TRISTATE,    TRISTATE),
                                                   PINMUX_REG_BITS_ENUM(AUX_E_INPUT,       ENABLE),
                                                   PINMUX_REG_BITS_ENUM(AUX_LOCK,         DISABLE),
                                                   PINMUX_REG_BITS_ENUM(AUX_E_OD,         DISABLE));
 
         /* Configure GPIO for Uart-C. */
-        reg::ReadWrite(g_gpio_address + 0x00C, REG_BITS_VALUE(1, 4, 0));
+        reg::ReadWrite(g_gpio_address + 0x118, REG_BITS_VALUE(0, 1, 1));
+        reg::Read(g_gpio_address + 0x118);
+        reg::ReadWrite(g_gpio_address + 0x00C, REG_BITS_VALUE(1, 1, 0));
+        reg::Read(g_gpio_address + 0x00C);
     }
 
     void SetupI2c1() {

libraries/libexosphere/source/uart/uart_api.cpp

@@ -33,11 +33,11 @@ namespace ams::uart {
         }
 
         void WaitSymbols(int baud, u32 num) {
-            util::WaitMicroSeconds(util::DivideUp(1'000'000, baud) * num);
+            util::WaitMicroSeconds(util::DivideUp(num * 1'000'000, baud));
         }
 
         void WaitCycles(int baud, u32 num) {
-            util::WaitMicroSeconds(util::DivideUp(1'000'000, 16 * baud) * num);
+            util::WaitMicroSeconds(util::DivideUp(num * 1'000'000, 16 * baud));
         }
 
         ALWAYS_INLINE void WaitFifoNotFull(volatile UartRegisters *uart) {
@@ -60,26 +60,6 @@ namespace ams::uart {
 
         constexpr inline u32 LockBit = (1 << 6);
 
-        void Lock(volatile UartRegisters *reg) {
-            while (true) {
-                if (reg->mie != 0) {
-                    continue;
-                }
-
-                reg->irda_csr = LockBit;
-
-                if (reg->mie == 0) {
-                    break;
-                }
-
-                reg->irda_csr = 0;
-            }
-        }
-
-        void Unlock(volatile UartRegisters *reg) {
-            reg->irda_csr = 0;
-        }
-
     }
 
     void SetRegisterAddress(uintptr_t address) {
@@ -97,7 +77,13 @@ namespace ams::uart {
         constexpr u32 UartClock = 408000000;
         const     u32 divisor = (UartClock + (baud_rate * 16) / 2) / (baud_rate * 16);
 
-        /* Disable DLAB and all interrupts. */
+        /* Wait for idle state. */
+        WaitIdle(uart, UART_VENDOR_STATE_TX_IDLE);
+
+        /* Wait 100 us. */
+        util::WaitMicroSeconds(100);
+
+        /* Disable interrupts. */
         uart->lcr = uart->lcr & ~UART_LCR_DLAB;
         uart->ier = 0;
         uart->mcr = 0;
@@ -128,8 +114,8 @@ namespace ams::uart {
         /* Wait for idle state. */
         WaitIdle(uart, UART_VENDOR_STATE_TX_IDLE | UART_VENDOR_STATE_RX_IDLE);
 
-        /* Set scratch register to 0. */
-        uart->spr = 0;
+        /* Wait 100 us. */
+        util::WaitMicroSeconds(100);
     }
 
     void SendText(Port port, const void *data, size_t size) {
@@ -139,10 +125,6 @@ namespace ams::uart {
         /* Get pointer to data. */
         const u8 *p = static_cast<const u8 *>(data);
 
-        /* Lock the uart registers. */
-        Lock(uart);
-        ON_SCOPE_EXIT { Unlock(uart); };
-
         /* Send each byte. */
         for (size_t i = 0; i < size; ++i) {
             WaitFifoNotFull(uart);

libraries/libexosphere/source/wdt/wdt_api.cpp

@@ -81,7 +81,8 @@ namespace ams::wdt {
                 /* Enable the counters. */
                 reg::Write(registers + 0x188, 0x1);
 
-                while (true) { /* ... */ }
+                /* Wait forever until the reboot takes. */
+                AMS_INFINITE_LOOP();
             }
         #endif
 

libraries/libmesosphere/Makefile

@@ -9,10 +9,10 @@ include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../config/common.mk
 PRECOMPILED_HEADERS := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/include/mesosphere.hpp
 
 DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_MESOSPHERE
-SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2 -mgeneral-regs-only -ffixed-x18 -Werror -fno-non-call-exceptions
+SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2 -mgeneral-regs-only -ffixed-x18 -Wextra -Werror -fno-non-call-exceptions
 CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit -flto
-ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS)
+ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 
 SOURCES     += $(call ALL_SOURCE_DIRS,../libvapours/source)
 
@@ -34,23 +34,9 @@ ifneq ($(BUILD),$(notdir $(CURDIR)))
 export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
 			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
 
-CFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.c)) $(notdir $(wildcard $(dir)/*.board.*.c)) $(notdir $(wildcard $(dir)/*.os.*.c)), \
-                                                      $(notdir $(wildcard $(dir)/*.c))))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).c)))
-CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).c)))
-
-CPPFILES    :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.cpp)) $(notdir $(wildcard $(dir)/*.board.*.cpp)) $(notdir $(wildcard $(dir)/*.os.*.cpp)), \
-                                                      $(notdir $(wildcard $(dir)/*.cpp))))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).cpp)))
-CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).cpp)))
-
-SFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.s)) $(notdir $(wildcard $(dir)/*.board.*.s)) $(notdir $(wildcard $(dir)/*.os.*.s)), \
-                                                      $(notdir $(wildcard $(dir)/*.s))))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).s)))
-SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).s)))
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
 
 #---------------------------------------------------------------------------------
 # use CXX for linking C++ projects, CC for standard C

libraries/libmesosphere/include/mesosphere.hpp

@@ -27,6 +27,9 @@
 #include <mesosphere/kern_initial_process.hpp>
 #include <mesosphere/kern_k_exception_context.hpp>
 
+/* Tracing functionality. */
+#include <mesosphere/kern_k_trace.hpp>
+
 /* Core pre-initialization includes. */
 #include <mesosphere/kern_select_cpu.hpp>
 #include <mesosphere/kern_select_system_control.hpp>

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

@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <mesosphere/kern_select_cpu.hpp>
+#include <mesosphere/kern_k_typed_address.hpp>
+
+namespace ams::kern::arch::arm {
+
+    struct GicDistributor {
+        u32 ctlr;
+        u32 typer;
+        u32 iidr;
+        u32 reserved_0x0c;
+        u32 statusr;
+        u32 reserved_0x14[3];
+        u32 impldef_0x20[8];
+        u32 setspi_nsr;
+        u32 reserved_0x44;
+        u32 clrspi_nsr;
+        u32 reserved_0x4c;
+        u32 setspi_sr;
+        u32 reserved_0x54;
+        u32 clrspi_sr;
+        u32 reserved_0x5c[9];
+        u32 igroupr[32];
+        u32 isenabler[32];
+        u32 icenabler[32];
+        u32 ispendr[32];
+        u32 icpendr[32];
+        u32 isactiver[32];
+        u32 icactiver[32];
+        union {
+            u8  bytes[1020];
+            u32 words[255];
+        } ipriorityr;
+        u32 _0x7fc;
+        union {
+            u8  bytes[1020];
+            u32 words[255];
+        } itargetsr;
+        u32 _0xbfc;
+        u32 icfgr[64];
+        u32 igrpmodr[32];
+        u32 _0xd80[32];
+        u32 nsacr[64];
+        u32 sgir;
+        u32 _0xf04[3];
+        u32 cpendsgir[4];
+        u32 spendsgir[4];
+        u32 reserved_0xf30[52];
+
+        static constexpr size_t SgirCpuTargetListShift = 16;
+
+        enum SgirTargetListFilter : u32 {
+            SgirTargetListFilter_CpuTargetList = (0 << 24),
+            SgirTargetListFilter_Others        = (1 << 24),
+            SgirTargetListFilter_Self          = (2 << 24),
+            SgirTargetListFilter_Reserved      = (3 << 24),
+        };
+    };
+    static_assert(util::is_pod<GicDistributor>::value);
+    static_assert(sizeof(GicDistributor) == 0x1000);
+
+    struct GicCpuInterface {
+        u32 ctlr;
+        u32 pmr;
+        u32 bpr;
+        u32 iar;
+        u32 eoir;
+        u32 rpr;
+        u32 hppir;
+        u32 abpr;
+        u32 aiar;
+        u32 aeoir;
+        u32 ahppir;
+        u32 statusr;
+        u32 reserved_30[4];
+        u32 impldef_40[36];
+        u32 apr[4];
+        u32 nsapr[4];
+        u32 reserved_f0[3];
+        u32 iidr;
+        u32 reserved_100[960];
+        u32 dir;
+        u32 _0x1004[1023];
+    };
+    static_assert(util::is_pod<GicCpuInterface>::value);
+    static_assert(sizeof(GicCpuInterface) == 0x2000);
+
+    struct KInterruptController {
+        NON_COPYABLE(KInterruptController);
+        NON_MOVEABLE(KInterruptController);
+        public:
+            static constexpr s32 NumSoftwareInterrupts = 16;
+            static constexpr s32 NumLocalInterrupts = NumSoftwareInterrupts + 16;
+            static constexpr s32 NumGlobalInterrupts = 988;
+            static constexpr s32 NumInterrupts = NumLocalInterrupts + NumGlobalInterrupts;
+            static constexpr s32 NumPriorityLevels = 4;
+        public:
+            struct LocalState {
+                u32 isenabler[NumLocalInterrupts / 32];
+                u32 ipriorityr[NumLocalInterrupts / 4];
+                u32 itargetsr[NumLocalInterrupts / 4];
+                u32 icfgr[NumLocalInterrupts / 16];
+            };
+
+            struct GlobalState {
+                u32 isenabler[NumGlobalInterrupts / 32];
+                u32 ipriorityr[NumGlobalInterrupts / 4];
+                u32 itargetsr[NumGlobalInterrupts / 4];
+                u32 icfgr[NumGlobalInterrupts / 16];
+            };
+
+            enum PriorityLevel : u8 {
+                PriorityLevel_High  = 0,
+                PriorityLevel_Low   = NumPriorityLevels - 1,
+
+                PriorityLevel_Timer     = 1,
+                PriorityLevel_Scheduler = 2,
+            };
+        private:
+            static inline u32 s_mask[cpu::NumCores];
+        private:
+            volatile GicDistributor  *gicd;
+            volatile GicCpuInterface *gicc;
+        public:
+            constexpr KInterruptController() : gicd(nullptr), gicc(nullptr) { /* ... */ }
+
+            void Initialize(s32 core_id);
+            void Finalize(s32 core_id);
+
+            void SaveCoreLocal(LocalState *state) const;
+            void SaveGlobal(GlobalState *state) const;
+            void RestoreCoreLocal(const LocalState *state) const;
+            void RestoreGlobal(const GlobalState *state) const;
+        public:
+            u32 GetIrq() const {
+                return this->gicc->iar;
+            }
+
+            static constexpr s32 ConvertRawIrq(u32 irq) {
+                return (irq == 0x3FF) ? -1 : (irq & 0x3FF);
+            }
+
+            void Enable(s32 irq) const {
+                this->gicd->isenabler[irq / BITSIZEOF(u32)] = (1u << (irq % BITSIZEOF(u32)));
+            }
+
+            void Disable(s32 irq) const {
+                this->gicd->icenabler[irq / BITSIZEOF(u32)] = (1u << (irq % BITSIZEOF(u32)));
+            }
+
+            void Clear(s32 irq) const {
+                this->gicd->icpendr[irq / BITSIZEOF(u32)] = (1u << (irq % BITSIZEOF(u32)));
+            }
+
+            void SetTarget(s32 irq, s32 core_id) const {
+                this->gicd->itargetsr.bytes[irq] = this->gicd->itargetsr.bytes[irq] | GetGicMask(core_id);
+            }
+
+            void ClearTarget(s32 irq, s32 core_id) const {
+                this->gicd->itargetsr.bytes[irq] = this->gicd->itargetsr.bytes[irq] & ~GetGicMask(core_id);
+            }
+
+            void SetPriorityLevel(s32 irq, s32 level) const {
+                MESOSPHERE_ASSERT(PriorityLevel_High <= level && level <= PriorityLevel_Low);
+                this->gicd->ipriorityr.bytes[irq] = ToGicPriorityValue(level);
+            }
+
+            s32 GetPriorityLevel(s32 irq) const {
+                return FromGicPriorityValue(this->gicd->ipriorityr.bytes[irq]);
+            }
+
+            void SetPriorityLevel(s32 level) const {
+                MESOSPHERE_ASSERT(PriorityLevel_High <= level && level <= PriorityLevel_Low);
+                this->gicc->pmr = ToGicPriorityValue(level);
+            }
+
+            void SetEdge(s32 irq) const {
+                u32 cfg = this->gicd->icfgr[irq / (BITSIZEOF(u32) / 2)];
+                cfg &= ~(0x3 << (2 * (irq % (BITSIZEOF(u32) / 2))));
+                cfg |=  (0x2 << (2 * (irq % (BITSIZEOF(u32) / 2))));
+                this->gicd->icfgr[irq / (BITSIZEOF(u32) / 2)] = cfg;
+            }
+
+            void SetLevel(s32 irq) const {
+                u32 cfg = this->gicd->icfgr[irq / (BITSIZEOF(u32) / 2)];
+                cfg &= ~(0x3 << (2 * (irq % (BITSIZEOF(u32) / 2))));
+                cfg |=  (0x0 << (2 * (irq % (BITSIZEOF(u32) / 2))));
+                this->gicd->icfgr[irq / (BITSIZEOF(u32) / 2)] = cfg;
+            }
+
+            void SendInterProcessorInterrupt(s32 irq, u64 core_mask) {
+                MESOSPHERE_ASSERT(IsSoftware(irq));
+                this->gicd->sgir = GetCpuTargetListMask(irq, core_mask);
+            }
+
+            void SendInterProcessorInterrupt(s32 irq) {
+                MESOSPHERE_ASSERT(IsSoftware(irq));
+                this->gicd->sgir = GicDistributor::SgirTargetListFilter_Others | irq;
+            }
+
+            void EndOfInterrupt(u32 irq) const {
+                this->gicc->eoir = irq;
+            }
+
+            bool IsInterruptDefined(s32 irq) const {
+                const s32 num_interrupts = std::min(32 + 32 * (this->gicd->typer & 0x1F), static_cast<u32>(NumInterrupts));
+                return (0 <= irq && irq < num_interrupts);
+            }
+        public:
+            static constexpr ALWAYS_INLINE bool IsSoftware(s32 id) {
+                MESOSPHERE_ASSERT(0 <= id && id < NumInterrupts);
+                return id < NumSoftwareInterrupts;
+            }
+
+            static constexpr ALWAYS_INLINE bool IsLocal(s32 id) {
+                MESOSPHERE_ASSERT(0 <= id && id < NumInterrupts);
+                return id < NumLocalInterrupts;
+            }
+
+            static constexpr ALWAYS_INLINE bool IsGlobal(s32 id) {
+                MESOSPHERE_ASSERT(0 <= id && id < NumInterrupts);
+                return NumLocalInterrupts <= id;
+            }
+
+            static constexpr size_t GetGlobalInterruptIndex(s32 id) {
+                MESOSPHERE_ASSERT(IsGlobal(id));
+                return id - NumLocalInterrupts;
+            }
+
+            static constexpr size_t GetLocalInterruptIndex(s32 id) {
+                MESOSPHERE_ASSERT(IsLocal(id));
+                return id;
+            }
+        private:
+            static constexpr size_t PriorityShift = BITSIZEOF(u8) - __builtin_ctz(NumPriorityLevels);
+            static_assert(PriorityShift < BITSIZEOF(u8));
+
+            static constexpr ALWAYS_INLINE u8 ToGicPriorityValue(s32 level) {
+                return (level << PriorityShift) | ((1 << PriorityShift) - 1);
+            }
+
+            static constexpr ALWAYS_INLINE s32 FromGicPriorityValue(u8 priority) {
+                return (priority >> PriorityShift) & (NumPriorityLevels - 1);
+            }
+
+            static constexpr ALWAYS_INLINE s32 GetCpuTargetListMask(s32 irq, u64 core_mask) {
+                MESOSPHERE_ASSERT(IsSoftware(irq));
+                MESOSPHERE_ASSERT(core_mask < (1ul << cpu::NumCores));
+                return GicDistributor::SgirTargetListFilter_CpuTargetList | irq | (static_cast<u16>(core_mask) << GicDistributor::SgirCpuTargetListShift);
+            }
+
+            static ALWAYS_INLINE s32 GetGicMask(s32 core_id) {
+                return s_mask[core_id];
+            }
+
+            ALWAYS_INLINE void SetGicMask(s32 core_id) const {
+                s_mask[core_id] = this->gicd->itargetsr.bytes[0];
+            }
+
+            NOINLINE void SetupInterruptLines(s32 core_id) const;
+    };
+
+}

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

@@ -13,22 +13,17 @@
  * 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 FUSEE_EMU_DEV_H
-#define FUSEE_EMU_DEV_H
+#pragma once
+#include <vapours.hpp>
+#include <mesosphere/kern_select_cpu.hpp>
+#include <mesosphere/kern_k_typed_address.hpp>
 
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include "device_partition.h"
+#if 1
 
-#define EMUDEV_MAX_DEVICES 16
+    #include <mesosphere/arch/arm/kern_generic_interrupt_controller.hpp>
 
-int emudev_mount_device(const char *name, const device_partition_t *devpart, const char *origin_path, int num_parts, uint64_t part_limit);
-int emudev_register_device(const char *name);
-int emudev_unregister_device(const char *name);
-int emudev_unmount_device(const char *name);        /* also unregisters. */
+#else
 
-int emudev_unmount_all(void);
+    #error "Unknown board for KInterruptController"
 
 #endif

libraries/libmesosphere/include/mesosphere/arch/arm/kern_k_memory_region_device_types.inc

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* All architectures must define NumArchitectureDeviceRegions. */
+constexpr inline const auto NumArchitectureDeviceRegions = 3;
+
+constexpr inline const auto KMemoryRegionType_Uart                  = KMemoryRegionType_ArchDeviceBase.DeriveSparse(0, NumArchitectureDeviceRegions, 0);
+constexpr inline const auto KMemoryRegionType_InterruptCpuInterface = KMemoryRegionType_ArchDeviceBase.DeriveSparse(0, NumArchitectureDeviceRegions, 1).SetAttribute(KMemoryRegionAttr_NoUserMap);
+constexpr inline const auto KMemoryRegionType_InterruptDistributor  = KMemoryRegionType_ArchDeviceBase.DeriveSparse(0, NumArchitectureDeviceRegions, 2).SetAttribute(KMemoryRegionAttr_NoUserMap);
+static_assert(KMemoryRegionType_Uart                 .GetValue() == (0x1D));
+static_assert(KMemoryRegionType_InterruptCpuInterface.GetValue() == (0x2D | KMemoryRegionAttr_NoUserMap));
+static_assert(KMemoryRegionType_InterruptDistributor .GetValue() == (0x4D | KMemoryRegionAttr_NoUserMap));

libraries/libmesosphere/include/mesosphere/arch/arm64/init/kern_k_init_page_table.hpp

@@ -23,6 +23,17 @@
 
 namespace ams::kern::arch::arm64::init {
 
+    inline void ClearPhysicalMemory(KPhysicalAddress address, size_t size) {
+        MESOSPHERE_INIT_ABORT_UNLESS(util::IsAligned(size, sizeof(u64)));
+
+        /* This Physical Address -> void * conversion is valid, because this is init page table code. */
+        /* The MMU is necessarily not yet turned on, if we are creating an initial page table. */
+        volatile u64 *ptr = reinterpret_cast<volatile u64 *>(GetInteger(address));
+        for (size_t i = 0; i < size / sizeof(u64); ++i) {
+            ptr[i] = 0;
+        }
+    }
+
     class KInitialPageTable {
         public:
             class IPageAllocator {
@@ -61,9 +72,11 @@ namespace ams::kern::arch::arm64::init {
             }
 
             static ALWAYS_INLINE void ClearNewPageTable(KPhysicalAddress address) {
-                /* This Physical Address -> void * conversion is valid, because this is page table code. */
-                /* The MMU is necessarily not yet turned on, if we are creating an initial page table. */
-                std::memset(reinterpret_cast<void *>(GetInteger(address)), 0, PageSize);
+                ClearPhysicalMemory(address, PageSize);
+            }
+        public:
+            static consteval size_t GetMaximumOverheadSize(size_t size) {
+                return (util::DivideUp(size, L1BlockSize) + util::DivideUp(size, L2BlockSize)) * PageSize;
             }
         private:
             size_t NOINLINE GetBlockCount(KVirtualAddress virt_addr, size_t size, size_t block_size) {
@@ -705,7 +718,7 @@ namespace ams::kern::arch::arm64::init {
                     this->state.next_address += PageSize;
                 }
 
-                std::memset(reinterpret_cast<void *>(allocated), 0, PageSize);
+                ClearPhysicalMemory(allocated, PageSize);
                 return allocated;
             }
 

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

@@ -59,9 +59,8 @@ namespace ams::kern::arch::arm64::cpu {
         InstructionMemoryBarrier();
     }
 
-    ALWAYS_INLINE void InvalidateEntireInstructionCache() {
-        __asm__ __volatile__("ic iallu" ::: "memory");
-        EnsureInstructionConsistency();
+    ALWAYS_INLINE void Yield() {
+        __asm__ __volatile__("yield" ::: "memory");
     }
 
     ALWAYS_INLINE void SwitchProcess(u64 ttbr, u32 proc_id) {
@@ -149,6 +148,25 @@ namespace ams::kern::arch::arm64::cpu {
         return true;
     }
 
+    ALWAYS_INLINE bool CanAccessAtomic(KProcessAddress addr, bool privileged = false) {
+        const uintptr_t va = GetInteger(addr);
+
+        if (privileged) {
+            __asm__ __volatile__("at s1e1w, %[va]" :: [va]"r"(va) : "memory");
+        } else {
+            __asm__ __volatile__("at s1e0w, %[va]" :: [va]"r"(va) : "memory");
+        }
+        InstructionMemoryBarrier();
+
+        u64 par = GetParEl1();
+
+        if (par & 0x1) {
+            return false;
+        }
+
+        return (par >> (BITSIZEOF(par) - BITSIZEOF(u8))) == 0xFF;
+    }
+
     /* Synchronization helpers. */
     NOINLINE void SynchronizeAllCores();
 
@@ -156,6 +174,7 @@ namespace ams::kern::arch::arm64::cpu {
     void ClearPageToZeroImpl(void *);
     void FlushEntireDataCacheSharedForInit();
     void FlushEntireDataCacheLocalForInit();
+    void InvalidateEntireInstructionCacheForInit();
     void StoreEntireCacheForInit();
 
     void FlushEntireDataCache();
@@ -165,6 +184,8 @@ namespace ams::kern::arch::arm64::cpu {
     Result FlushDataCache(const void *addr, size_t size);
     Result InvalidateInstructionCache(void *addr, size_t size);
 
+    void InvalidateEntireInstructionCache();
+
     ALWAYS_INLINE void ClearPageToZero(void *page) {
         MESOSPHERE_ASSERT(util::IsAligned(reinterpret_cast<uintptr_t>(page), PageSize));
         MESOSPHERE_ASSERT(page != nullptr);
@@ -173,7 +194,7 @@ namespace ams::kern::arch::arm64::cpu {
 
     ALWAYS_INLINE void InvalidateTlbByAsid(u32 asid) {
         const u64 value = (static_cast<u64>(asid) << 48);
-        __asm__ __volatile__("tlbi aside1is, %[value]" :: [value]"r"(static_cast<u64>(value) << 48) : "memory");
+        __asm__ __volatile__("tlbi aside1is, %[value]" :: [value]"r"(value) : "memory");
         EnsureInstructionConsistency();
     }
 

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

@@ -56,26 +56,69 @@ namespace ams::kern::arch::arm64::cpu {
 
     MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(OslarEl1, oslar_el1)
 
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(TpidrEl0,   tpidr_el0)
     MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(TpidrRoEl0, tpidrro_el0)
 
-    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(EsrEl1, esr_el1)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(ElrEl1,   elr_el1)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(EsrEl1,   esr_el1)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(SpsrEl1,  spsr_el1)
     MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(Afsr0El1, afsr0_el1)
     MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(Afsr1El1, afsr1_el1)
 
-    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmUserEnrEl0, pmuserenr_el0)
-    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmcCntrEl0,   pmccntr_el0)
-    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmevCntr0El0, pmevcntr0_el0)
-    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmevCntr1El0, pmevcntr1_el0)
-    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmevCntr2El0, pmevcntr2_el0)
-    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmevCntr3El0, pmevcntr3_el0)
-    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmevCntr4El0, pmevcntr4_el0)
-    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmevCntr5El0, pmevcntr5_el0)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(MdscrEl1, mdscr_el1)
+
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(CpacrEl1, cpacr_el1)
+
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(ContextidrEl1, contextidr_el1)
+
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(CntkCtlEl1,  cntkctl_el1)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(CntpCtlEl0,  cntp_ctl_el0)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(CntpCvalEl0, cntp_cval_el0)
+
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(Daif, daif)
+
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(SpEl0, sp_el0)
+
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(IdAa64Dfr0El1, id_aa64dfr0_el1)
+
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmcrEl0,       pmcr_el0)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmUserEnrEl0,  pmuserenr_el0)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmcCntrEl0,    pmccntr_el0)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmSelrEl0,     pmselr_el0)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmcCfiltrEl0,  pmccfiltr_el0)
+
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmIntEnSetEl1, pmintenset_el1)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmCntEnSetEl0, pmcntenset_el0)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmOvsSetEl0,   pmovsset_el0)
+
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmIntEnClrEl1, pmintenclr_el1)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmCntEnClrEl0, pmcntenclr_el0)
+    MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmOvsClrEl0,   pmovsclr_el0)
+
+    #define FOR_I_IN_0_TO_30(HANDLER, ...)                                                                              \
+        HANDLER(0,  ## __VA_ARGS__) HANDLER(1,  ## __VA_ARGS__) HANDLER(2,  ## __VA_ARGS__) HANDLER(3,  ## __VA_ARGS__) \
+        HANDLER(4,  ## __VA_ARGS__) HANDLER(5,  ## __VA_ARGS__) HANDLER(6,  ## __VA_ARGS__) HANDLER(7,  ## __VA_ARGS__) \
+        HANDLER(8,  ## __VA_ARGS__) HANDLER(9,  ## __VA_ARGS__) HANDLER(10, ## __VA_ARGS__) HANDLER(11, ## __VA_ARGS__) \
+        HANDLER(12, ## __VA_ARGS__) HANDLER(13, ## __VA_ARGS__) HANDLER(14, ## __VA_ARGS__) HANDLER(15, ## __VA_ARGS__) \
+        HANDLER(16, ## __VA_ARGS__) HANDLER(17, ## __VA_ARGS__) HANDLER(18, ## __VA_ARGS__) HANDLER(19, ## __VA_ARGS__) \
+        HANDLER(20, ## __VA_ARGS__) HANDLER(21, ## __VA_ARGS__) HANDLER(22, ## __VA_ARGS__) HANDLER(23, ## __VA_ARGS__) \
+        HANDLER(24, ## __VA_ARGS__) HANDLER(25, ## __VA_ARGS__) HANDLER(26, ## __VA_ARGS__) HANDLER(27, ## __VA_ARGS__) \
+        HANDLER(28, ## __VA_ARGS__) HANDLER(29, ## __VA_ARGS__) HANDLER(30, ## __VA_ARGS__)
+
+    #define MESOSPHERE_CPU_DEFINE_PMEV_ACCESSORS(ID, ...)                               \
+        MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmevCntr##ID##El0,  pmevcntr##ID##_el0)  \
+        MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(PmevTyper##ID##El0, pmevtyper##ID##_el0)
+
+    FOR_I_IN_0_TO_30(MESOSPHERE_CPU_DEFINE_PMEV_ACCESSORS)
+
+    #undef MESOSPHERE_CPU_DEFINE_PMEV_ACCESSORS
+    #undef FOR_I_IN_0_TO_30
 
     #define FOR_I_IN_0_TO_15(HANDLER, ...)                                                                              \
         HANDLER(0,  ## __VA_ARGS__) HANDLER(1,  ## __VA_ARGS__) HANDLER(2,  ## __VA_ARGS__) HANDLER(3,  ## __VA_ARGS__) \
         HANDLER(4,  ## __VA_ARGS__) HANDLER(5,  ## __VA_ARGS__) HANDLER(6,  ## __VA_ARGS__) HANDLER(7,  ## __VA_ARGS__) \
         HANDLER(8,  ## __VA_ARGS__) HANDLER(9,  ## __VA_ARGS__) HANDLER(10, ## __VA_ARGS__) HANDLER(11, ## __VA_ARGS__) \
-        HANDLER(12, ## __VA_ARGS__) HANDLER(13, ## __VA_ARGS__) HANDLER(14, ## __VA_ARGS__) HANDLER(15, ## __VA_ARGS__) \
+        HANDLER(12, ## __VA_ARGS__) HANDLER(13, ## __VA_ARGS__) HANDLER(14, ## __VA_ARGS__) HANDLER(15, ## __VA_ARGS__)
 
     #define MESOSPHERE_CPU_DEFINE_DBG_SYSREG_ACCESSORS(ID, ...)                     \
         MESOSPHERE_CPU_DEFINE_SYSREG_ACCESSORS(DbgWcr##ID##El1, dbgwcr##ID##_el1)   \
@@ -158,6 +201,15 @@ namespace ams::kern::arch::arm64::cpu {
                 const size_t shift_value = this->GetBits(16, 6);
                 return size_t(1) << (size_t(64) - shift_value);
             }
+
+            constexpr ALWAYS_INLINE bool GetEpd0() const {
+                return this->GetBits(7, 1) != 0;
+            }
+
+            constexpr ALWAYS_INLINE decltype(auto) SetEpd0(bool set) {
+                this->SetBit(7, set);
+                return *this;
+            }
     };
 
     MESOSPHERE_CPU_SYSREG_ACCESSOR_CLASS(ArchitecturalFeatureAccessControl) {
@@ -189,6 +241,10 @@ namespace ams::kern::arch::arm64::cpu {
             constexpr ALWAYS_INLINE size_t GetNumBreakpoints() const {
                 return this->GetBits(12, 4);
             }
+
+            constexpr ALWAYS_INLINE size_t GetNumContextAwareBreakpoints() const {
+                return this->GetBits(28, 4);
+            }
     };
 
     MESOSPHERE_CPU_SYSREG_ACCESSOR_CLASS(MonitorDebugSystemControl) {
@@ -387,6 +443,27 @@ namespace ams::kern::arch::arm64::cpu {
             /* TODO: Other bitfield accessors? */
     };
 
+    MESOSPHERE_CPU_SYSREG_ACCESSOR_CLASS(PerformanceMonitorsControl) {
+        public:
+            MESOSPHERE_CPU_SYSREG_ACCESSOR_CLASS_FUNCTIONS(PerformanceMonitorsControl, pmcr_el0)
+        public:
+            constexpr ALWAYS_INLINE u64 GetN() const {
+                return this->GetBits(11, 5);
+            }
+
+            constexpr ALWAYS_INLINE decltype(auto) SetEventCounterReset(bool en) {
+                this->SetBit(1, en);
+                return *this;
+            }
+
+            constexpr ALWAYS_INLINE decltype(auto) SetCycleCounterReset(bool en) {
+                this->SetBit(2, en);
+                return *this;
+            }
+
+            /* TODO: Other bitfield accessors? */
+    };
+
     #undef  FOR_I_IN_0_TO_15
     #undef  MESOSPHERE_CPU_SYSREG_ACCESSOR_CLASS_FUNCTIONS
     #undef  MESOSPHERE_CPU_SYSREG_ACCESSOR_CLASS

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

@@ -30,6 +30,38 @@ namespace ams::kern::arch::arm64 {
     class KDebug final : public KAutoObjectWithSlabHeapAndContainer<KDebug, KDebugBase> {
         MESOSPHERE_AUTOOBJECT_TRAITS(KDebug, KSynchronizationObject);
         public:
+            explicit KDebug() { /* ... */ }
+            virtual ~KDebug() { /* ... */ }
+
+            static void PostDestroy(uintptr_t arg) { MESOSPHERE_UNUSED(arg); /* ... */ }
+        public:
+            virtual Result GetThreadContextImpl(ams::svc::ThreadContext *out, KThread *thread, u32 context_flags) override;
+            virtual Result SetThreadContextImpl(const ams::svc::ThreadContext &ctx, KThread *thread, u32 context_flags) override;
+        private:
+            Result GetFpuContext(ams::svc::ThreadContext *out, KThread *thread, u32 context_flags);
+            Result SetFpuContext(const ams::svc::ThreadContext &ctx, KThread *thread, u32 context_flags);
+        public:
+            static uintptr_t GetProgramCounter(const KThread &thread);
+            static void SetPreviousProgramCounter();
+
+            static Result BreakIfAttached(ams::svc::BreakReason break_reason, uintptr_t address, size_t size);
+            static Result SetHardwareBreakPoint(ams::svc::HardwareBreakPointRegisterName name, u64 flags, u64 value);
+
+            static constexpr bool IsBreakInstruction(u32 insn, u32 psr) {
+                constexpr u32 BreakInstructionAarch64 = 0xE7FFFFFF;
+                constexpr u32 BreakInstructionAarch32 = 0xE7FFDEFE;
+                constexpr u32 BreakInstructionThumb32 = 0xB68E;
+                if ((psr & 0x10) == 0) {
+                    return insn == BreakInstructionAarch64;
+                } else {
+                    if ((psr & 0x20) == 0) {
+                        return insn == BreakInstructionAarch32;
+                    } else {
+                        return insn == BreakInstructionThumb32;
+                    }
+                }
+            }
+
             /* TODO: This is a placeholder definition. */
     };
 

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

@@ -22,9 +22,26 @@ namespace ams::kern::arch::arm64 {
         u64 x[(30 - 0) + 1];
         u64 sp;
         u64 pc;
-        u64 psr;
+        u32 psr;
+        u32 write;
         u64 tpidr;
         u64 reserved;
+
+        constexpr void GetSvcThreadContext(ams::svc::LastThreadContext *out) const {
+            if ((this->psr & 0x10) == 0) {
+                /* aarch64 thread. */
+                out->fp = this->x[29];
+                out->sp = this->sp;
+                out->lr = this->x[30];
+                out->pc = this->pc;
+            } else {
+                /* aarch32 thread. */
+                out->fp = this->x[11];
+                out->sp = this->x[13];
+                out->lr = this->x[14];
+                out->pc = this->pc;
+            }
+        }
     };
     static_assert(sizeof(KExceptionContext) == 0x120);
 

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

@@ -18,258 +18,19 @@
 #include <mesosphere/kern_select_cpu.hpp>
 #include <mesosphere/kern_k_typed_address.hpp>
 
-namespace ams::kern::arch::arm64 {
+#if 1
 
-    struct GicDistributor {
-        u32 ctlr;
-        u32 typer;
-        u32 iidr;
-        u32 reserved_0x0c;
-        u32 statusr;
-        u32 reserved_0x14[3];
-        u32 impldef_0x20[8];
-        u32 setspi_nsr;
-        u32 reserved_0x44;
-        u32 clrspi_nsr;
-        u32 reserved_0x4c;
-        u32 setspi_sr;
-        u32 reserved_0x54;
-        u32 clrspi_sr;
-        u32 reserved_0x5c[9];
-        u32 igroupr[32];
-        u32 isenabler[32];
-        u32 icenabler[32];
-        u32 ispendr[32];
-        u32 icpendr[32];
-        u32 isactiver[32];
-        u32 icactiver[32];
-        union {
-            u8  bytes[1020];
-            u32 words[255];
-        } ipriorityr;
-        u32 _0x7fc;
-        union {
-            u8  bytes[1020];
-            u32 words[255];
-        } itargetsr;
-        u32 _0xbfc;
-        u32 icfgr[64];
-        u32 igrpmodr[32];
-        u32 _0xd80[32];
-        u32 nsacr[64];
-        u32 sgir;
-        u32 _0xf04[3];
-        u32 cpendsgir[4];
-        u32 spendsgir[4];
-        u32 reserved_0xf30[52];
+    #include <mesosphere/arch/arm/kern_generic_interrupt_controller.hpp>
+    namespace ams::kern::arch::arm64 {
 
-        static constexpr size_t SgirCpuTargetListShift = 16;
+        using ams::kern::arch::arm::GicDistributor;
+        using ams::kern::arch::arm::GicCpuInterface;
+        using ams::kern::arch::arm::KInterruptController;
 
-        enum SgirTargetListFilter : u32 {
-            SgirTargetListFilter_CpuTargetList = (0 << 24),
-            SgirTargetListFilter_Others        = (1 << 24),
-            SgirTargetListFilter_Self          = (2 << 24),
-            SgirTargetListFilter_Reserved      = (3 << 24),
-        };
-    };
-    static_assert(util::is_pod<GicDistributor>::value);
-    static_assert(sizeof(GicDistributor) == 0x1000);
+    }
 
-    struct GicCpuInterface {
-        u32 ctlr;
-        u32 pmr;
-        u32 bpr;
-        u32 iar;
-        u32 eoir;
-        u32 rpr;
-        u32 hppir;
-        u32 abpr;
-        u32 aiar;
-        u32 aeoir;
-        u32 ahppir;
-        u32 statusr;
-        u32 reserved_30[4];
-        u32 impldef_40[36];
-        u32 apr[4];
-        u32 nsapr[4];
-        u32 reserved_f0[3];
-        u32 iidr;
-        u32 reserved_100[960];
-        u32 dir;
-        u32 _0x1004[1023];
-    };
-    static_assert(util::is_pod<GicCpuInterface>::value);
-    static_assert(sizeof(GicCpuInterface) == 0x2000);
+#else
 
-    struct KInterruptController {
-        NON_COPYABLE(KInterruptController);
-        NON_MOVEABLE(KInterruptController);
-        public:
-            static constexpr s32 NumSoftwareInterrupts = 16;
-            static constexpr s32 NumLocalInterrupts = NumSoftwareInterrupts + 16;
-            static constexpr s32 NumGlobalInterrupts = 988;
-            static constexpr s32 NumInterrupts = NumLocalInterrupts + NumGlobalInterrupts;
-            static constexpr s32 NumPriorityLevels = 4;
-        public:
-            struct LocalState {
-                u32 local_isenabler[NumLocalInterrupts / 32];
-                u32 local_ipriorityr[NumLocalInterrupts / 4];
-                u32 local_targetsr[NumLocalInterrupts / 4];
-                u32 local_icfgr[NumLocalInterrupts / 16];
-            };
+    #error "Unknown board for KInterruptController"
 
-            struct GlobalState {
-                u32 global_isenabler[NumGlobalInterrupts / 32];
-                u32 global_ipriorityr[NumGlobalInterrupts / 4];
-                u32 global_targetsr[NumGlobalInterrupts / 4];
-                u32 global_icfgr[NumGlobalInterrupts / 16];
-            };
-
-            enum PriorityLevel : u8 {
-                PriorityLevel_High  = 0,
-                PriorityLevel_Low   = NumPriorityLevels - 1,
-
-                PriorityLevel_Timer     = 1,
-                PriorityLevel_Scheduler = 2,
-            };
-        private:
-            static inline u32 s_mask[cpu::NumCores];
-        private:
-            volatile GicDistributor  *gicd;
-            volatile GicCpuInterface *gicc;
-        public:
-            constexpr KInterruptController() : gicd(nullptr), gicc(nullptr) { /* ... */ }
-
-            void Initialize(s32 core_id);
-            void Finalize(s32 core_id);
-        public:
-            u32 GetIrq() const {
-                return this->gicc->iar;
-            }
-
-            static constexpr s32 ConvertRawIrq(u32 irq) {
-                return (irq == 0x3FF) ? -1 : (irq & 0x3FF);
-            }
-
-            void Enable(s32 irq) const {
-                this->gicd->isenabler[irq / BITSIZEOF(u32)] = (1u << (irq % BITSIZEOF(u32)));
-            }
-
-            void Disable(s32 irq) const {
-                this->gicd->icenabler[irq / BITSIZEOF(u32)] = (1u << (irq % BITSIZEOF(u32)));
-            }
-
-            void Clear(s32 irq) const {
-                this->gicd->icpendr[irq / BITSIZEOF(u32)] = (1u << (irq % BITSIZEOF(u32)));
-            }
-
-            void SetTarget(s32 irq, s32 core_id) const {
-                this->gicd->itargetsr.bytes[irq] = this->gicd->itargetsr.bytes[irq] | GetGicMask(core_id);
-            }
-
-            void ClearTarget(s32 irq, s32 core_id) const {
-                this->gicd->itargetsr.bytes[irq] = this->gicd->itargetsr.bytes[irq] & ~GetGicMask(core_id);
-            }
-
-            void SetPriorityLevel(s32 irq, s32 level) const {
-                MESOSPHERE_ASSERT(PriorityLevel_High <= level && level <= PriorityLevel_Low);
-                this->gicd->ipriorityr.bytes[irq] = ToGicPriorityValue(level);
-            }
-
-            s32 GetPriorityLevel(s32 irq) const {
-                return FromGicPriorityValue(this->gicd->ipriorityr.bytes[irq]);
-            }
-
-            void SetPriorityLevel(s32 level) const {
-                MESOSPHERE_ASSERT(PriorityLevel_High <= level && level <= PriorityLevel_Low);
-                this->gicc->pmr = ToGicPriorityValue(level);
-            }
-
-            void SetEdge(s32 irq) const {
-                u32 cfg = this->gicd->icfgr[irq / (BITSIZEOF(u32) / 2)];
-                cfg &= ~(0x3 << (2 * (irq % (BITSIZEOF(u32) / 2))));
-                cfg |=  (0x2 << (2 * (irq % (BITSIZEOF(u32) / 2))));
-                this->gicd->icfgr[irq / (BITSIZEOF(u32) / 2)] = cfg;
-            }
-
-            void SetLevel(s32 irq) const {
-                u32 cfg = this->gicd->icfgr[irq / (BITSIZEOF(u32) / 2)];
-                cfg &= ~(0x3 << (2 * (irq % (BITSIZEOF(u32) / 2))));
-                cfg |=  (0x0 << (2 * (irq % (BITSIZEOF(u32) / 2))));
-                this->gicd->icfgr[irq / (BITSIZEOF(u32) / 2)] = cfg;
-            }
-
-            void SendInterProcessorInterrupt(s32 irq, u64 core_mask) {
-                MESOSPHERE_ASSERT(IsSoftware(irq));
-                this->gicd->sgir = GetCpuTargetListMask(irq, core_mask);
-            }
-
-            void SendInterProcessorInterrupt(s32 irq) {
-                MESOSPHERE_ASSERT(IsSoftware(irq));
-                this->gicd->sgir = GicDistributor::SgirTargetListFilter_Others | irq;
-            }
-
-            void EndOfInterrupt(u32 irq) const {
-                this->gicc->eoir = irq;
-            }
-
-            bool IsInterruptDefined(s32 irq) {
-                const s32 num_interrupts = std::min(32 + 32 * (this->gicd->typer & 0x1F), static_cast<u32>(NumInterrupts));
-                return (0 <= irq && irq < num_interrupts);
-            }
-
-            /* TODO: Implement more KInterruptController functionality. */
-        public:
-            static constexpr ALWAYS_INLINE bool IsSoftware(s32 id) {
-                MESOSPHERE_ASSERT(0 <= id && id < NumInterrupts);
-                return id < NumSoftwareInterrupts;
-            }
-
-            static constexpr ALWAYS_INLINE bool IsLocal(s32 id) {
-                MESOSPHERE_ASSERT(0 <= id && id < NumInterrupts);
-                return id < NumLocalInterrupts;
-            }
-
-            static constexpr ALWAYS_INLINE bool IsGlobal(s32 id) {
-                MESOSPHERE_ASSERT(0 <= id && id < NumInterrupts);
-                return NumLocalInterrupts <= id;
-            }
-
-            static constexpr size_t GetGlobalInterruptIndex(s32 id) {
-                MESOSPHERE_ASSERT(IsGlobal(id));
-                return id - NumLocalInterrupts;
-            }
-
-            static constexpr size_t GetLocalInterruptIndex(s32 id) {
-                MESOSPHERE_ASSERT(IsLocal(id));
-                return id;
-            }
-        private:
-            static constexpr size_t PriorityShift = BITSIZEOF(u8) - __builtin_ctz(NumPriorityLevels);
-            static_assert(PriorityShift < BITSIZEOF(u8));
-
-            static constexpr ALWAYS_INLINE u8 ToGicPriorityValue(s32 level) {
-                return (level << PriorityShift) | ((1 << PriorityShift) - 1);
-            }
-
-            static constexpr ALWAYS_INLINE s32 FromGicPriorityValue(u8 priority) {
-                return (priority >> PriorityShift) & (NumPriorityLevels - 1);
-            }
-
-            static constexpr ALWAYS_INLINE s32 GetCpuTargetListMask(s32 irq, u64 core_mask) {
-                MESOSPHERE_ASSERT(IsSoftware(irq));
-                MESOSPHERE_ASSERT(core_mask < (1ul << cpu::NumCores));
-                return GicDistributor::SgirTargetListFilter_CpuTargetList | irq | (static_cast<u16>(core_mask) << GicDistributor::SgirCpuTargetListShift);
-            }
-
-            static ALWAYS_INLINE s32 GetGicMask(s32 core_id) {
-                return s_mask[core_id];
-            }
-
-            ALWAYS_INLINE void SetGicMask(s32 core_id) const {
-                s_mask[core_id] = this->gicd->itargetsr.bytes[0];
-            }
-
-            NOINLINE void SetupInterruptLines(s32 core_id) const;
-    };
-}
+#endif

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

@@ -67,10 +67,21 @@ namespace ams::kern::arch::arm64 {
             NOINLINE void Initialize(s32 core_id);
             NOINLINE void Finalize(s32 core_id);
 
-            bool IsInterruptDefined(s32 irq) {
+            NOINLINE void Save(s32 core_id);
+            NOINLINE void Restore(s32 core_id);
+
+            bool IsInterruptDefined(s32 irq) const {
                 return this->interrupt_controller.IsInterruptDefined(irq);
             }
 
+            bool IsGlobal(s32 irq) const {
+                return this->interrupt_controller.IsGlobal(irq);
+            }
+
+            bool IsLocal(s32 irq) const {
+                return this->interrupt_controller.IsLocal(irq);
+            }
+
             NOINLINE Result BindHandler(KInterruptHandler *handler, s32 irq, s32 core_id, s32 priority, bool manual_clear, bool level);
             NOINLINE Result UnbindHandler(s32 irq, s32 core);
 

libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_memory_region_device_types.inc

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* All architectures must define NumArchitectureDeviceRegions. */
+constexpr inline const auto NumArchitectureDeviceRegions = 3;
+
+constexpr inline const auto KMemoryRegionType_Uart                  = KMemoryRegionType_ArchDeviceBase.DeriveSparse(0, NumArchitectureDeviceRegions, 0);
+constexpr inline const auto KMemoryRegionType_InterruptCpuInterface = KMemoryRegionType_ArchDeviceBase.DeriveSparse(0, NumArchitectureDeviceRegions, 1).SetAttribute(KMemoryRegionAttr_NoUserMap);
+constexpr inline const auto KMemoryRegionType_InterruptDistributor  = KMemoryRegionType_ArchDeviceBase.DeriveSparse(0, NumArchitectureDeviceRegions, 2).SetAttribute(KMemoryRegionAttr_NoUserMap);
+static_assert(KMemoryRegionType_Uart                 .GetValue() == (0x1D));
+static_assert(KMemoryRegionType_InterruptCpuInterface.GetValue() == (0x2D | KMemoryRegionAttr_NoUserMap));
+static_assert(KMemoryRegionType_InterruptDistributor .GetValue() == (0x4D | KMemoryRegionAttr_NoUserMap));

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

@@ -182,25 +182,31 @@ namespace ams::kern::arch::arm64 {
             NOINLINE Result InitializeForProcess(u32 id, ams::svc::CreateProcessFlag as_type, bool enable_aslr, bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address, size_t code_size, KMemoryBlockSlabManager *mem_block_slab_manager, KBlockInfoManager *block_info_manager, KPageTableManager *pt_manager);
             Result Finalize();
         private:
-            Result Map(KProcessAddress virt_addr, KPhysicalAddress phys_addr, size_t num_pages, PageTableEntry entry_template, PageLinkedList *page_list, bool reuse_ll);
+            Result MapL1Blocks(KProcessAddress virt_addr, KPhysicalAddress phys_addr, size_t num_pages, PageTableEntry entry_template, PageLinkedList *page_list, bool reuse_ll);
+            Result MapL2Blocks(KProcessAddress virt_addr, KPhysicalAddress phys_addr, size_t num_pages, PageTableEntry entry_template, PageLinkedList *page_list, bool reuse_ll);
+            Result MapL3Blocks(KProcessAddress virt_addr, KPhysicalAddress phys_addr, size_t num_pages, PageTableEntry entry_template, PageLinkedList *page_list, bool reuse_ll);
+
             Result Unmap(KProcessAddress virt_addr, size_t num_pages, PageLinkedList *page_list, bool force, bool reuse_ll);
 
             Result Map(KProcessAddress virt_addr, KPhysicalAddress phys_addr, size_t num_pages, PageTableEntry entry_template, size_t page_size, PageLinkedList *page_list, bool reuse_ll) {
                 switch (page_size) {
                     case L1BlockSize:
+                        return this->MapL1Blocks(virt_addr, phys_addr, num_pages, entry_template, page_list, reuse_ll);
+                    case L2ContiguousBlockSize:
+                        entry_template.SetContiguous(true);
+                        [[fallthrough]];
 #ifdef ATMOSPHERE_BOARD_NINTENDO_NX
                     case L2TegraSmmuBlockSize:
 #endif
                     case L2BlockSize:
-                    case L3BlockSize:
-                        break;
-                    case L2ContiguousBlockSize:
+                        return this->MapL2Blocks(virt_addr, phys_addr, num_pages, entry_template, page_list, reuse_ll);
                     case L3ContiguousBlockSize:
                         entry_template.SetContiguous(true);
-                        break;
+                        [[fallthrough]];
+                    case L3BlockSize:
+                        return this->MapL3Blocks(virt_addr, phys_addr, num_pages, entry_template, page_list, reuse_ll);
                     MESOSPHERE_UNREACHABLE_DEFAULT_CASE();
                 }
-                return this->Map(virt_addr, phys_addr, num_pages, entry_template, page_list, reuse_ll);
             }
 
             Result MapContiguous(KProcessAddress virt_addr, KPhysicalAddress phys_addr, size_t num_pages, PageTableEntry entry_template, PageLinkedList *page_list, bool reuse_ll);

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

@@ -106,6 +106,8 @@ namespace ams::kern::arch::arm64 {
             NOINLINE void InitializeForProcess(void *tb, KVirtualAddress start, KVirtualAddress end);
             L1PageTableEntry *Finalize();
 
+            void Dump(uintptr_t start, size_t size) const;
+
             bool BeginTraversal(TraversalEntry *out_entry, TraversalContext *out_context, KProcessAddress address) const;
             bool ContinueTraversal(TraversalEntry *out_entry, TraversalContext *context) const;
 

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

@@ -44,6 +44,10 @@ namespace ams::kern::arch::arm64 {
                 return this->page_table.SetProcessMemoryPermission(addr, size, perm);
             }
 
+            Result SetMemoryAttribute(KProcessAddress addr, size_t size, u32 mask, u32 attr) {
+                return this->page_table.SetMemoryAttribute(addr, size, mask, attr);
+            }
+
             Result SetHeapSize(KProcessAddress *out, size_t size) {
                 return this->page_table.SetHeapSize(out, size);
             }
@@ -56,6 +60,34 @@ namespace ams::kern::arch::arm64 {
                 return this->page_table.QueryInfo(out_info, out_page_info, addr);
             }
 
+            Result QueryPhysicalAddress(ams::svc::PhysicalMemoryInfo *out, KProcessAddress address) const {
+                return this->page_table.QueryPhysicalAddress(out, address);
+            }
+
+            Result QueryStaticMapping(KProcessAddress *out, KPhysicalAddress address, size_t size) const {
+                return this->page_table.QueryStaticMapping(out, address, size);
+            }
+
+            Result QueryIoMapping(KProcessAddress *out, KPhysicalAddress address, size_t size) const {
+                return this->page_table.QueryIoMapping(out, address, size);
+            }
+
+            Result MapMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
+                return this->page_table.MapMemory(dst_address, src_address, size);
+            }
+
+            Result UnmapMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
+                return this->page_table.UnmapMemory(dst_address, src_address, size);
+            }
+
+            Result MapCodeMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
+                return this->page_table.MapCodeMemory(dst_address, src_address, size);
+            }
+
+            Result UnmapCodeMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
+                return this->page_table.UnmapCodeMemory(dst_address, src_address, size);
+            }
+
             Result MapIo(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm) {
                 return this->page_table.MapIo(phys_addr, size, perm);
             }
@@ -72,6 +104,10 @@ namespace ams::kern::arch::arm64 {
                 return this->page_table.MapPageGroup(addr, pg, state, perm);
             }
 
+            Result UnmapPageGroup(KProcessAddress address, const KPageGroup &pg, KMemoryState state) {
+                return this->page_table.UnmapPageGroup(address, pg, state);
+            }
+
             Result MapPages(KProcessAddress *out_addr, size_t num_pages, size_t alignment, KPhysicalAddress phys_addr, KMemoryState state, KMemoryPermission perm) {
                 return this->page_table.MapPages(out_addr, num_pages, alignment, phys_addr, state, perm);
             }
@@ -80,6 +116,10 @@ namespace ams::kern::arch::arm64 {
                 return this->page_table.MapPages(out_addr, num_pages, state, perm);
             }
 
+            Result MapPages(KProcessAddress address, size_t num_pages, KMemoryState state, KMemoryPermission perm) {
+                return this->page_table.MapPages(address, num_pages, state, perm);
+            }
+
             Result UnmapPages(KProcessAddress addr, size_t num_pages, KMemoryState state) {
                 return this->page_table.UnmapPages(addr, num_pages, state);
             }
@@ -88,11 +128,123 @@ namespace ams::kern::arch::arm64 {
                 return this->page_table.MakeAndOpenPageGroup(out, address, num_pages, state_mask, state, perm_mask, perm, attr_mask, attr);
             }
 
+            Result MakeAndOpenPageGroupContiguous(KPageGroup *out, KProcessAddress address, size_t num_pages, u32 state_mask, u32 state, u32 perm_mask, u32 perm, u32 attr_mask, u32 attr) {
+                return this->page_table.MakeAndOpenPageGroupContiguous(out, address, num_pages, state_mask, state, perm_mask, perm, attr_mask, attr);
+            }
+
+            Result InvalidateProcessDataCache(KProcessAddress address, size_t size) {
+                return this->page_table.InvalidateProcessDataCache(address, size);
+            }
+
+            Result ReadDebugMemory(void *buffer, KProcessAddress address, size_t size) {
+                return this->page_table.ReadDebugMemory(buffer, address, size);
+            }
+
+            Result WriteDebugMemory(KProcessAddress address, const void *buffer, size_t size) {
+                return this->page_table.WriteDebugMemory(address, buffer, size);
+            }
+
+            Result LockForDeviceAddressSpace(KPageGroup *out, KProcessAddress address, size_t size, KMemoryPermission perm, bool is_aligned) {
+                return this->page_table.LockForDeviceAddressSpace(out, address, size, perm, is_aligned);
+            }
+
+            Result UnlockForDeviceAddressSpace(KProcessAddress address, size_t size) {
+                return this->page_table.UnlockForDeviceAddressSpace(address, size);
+            }
+
+            Result LockForIpcUserBuffer(KPhysicalAddress *out, KProcessAddress address, size_t size) {
+                return this->page_table.LockForIpcUserBuffer(out, address, size);
+            }
+
+            Result UnlockForIpcUserBuffer(KProcessAddress address, size_t size) {
+                return this->page_table.UnlockForIpcUserBuffer(address, size);
+            }
+
+            Result LockForTransferMemory(KPageGroup *out, KProcessAddress address, size_t size, KMemoryPermission perm) {
+                return this->page_table.LockForTransferMemory(out, address, size, perm);
+            }
+
+            Result UnlockForTransferMemory(KProcessAddress address, size_t size, const KPageGroup &pg) {
+                return this->page_table.UnlockForTransferMemory(address, size, pg);
+            }
+
+            Result LockForCodeMemory(KPageGroup *out, KProcessAddress address, size_t size) {
+                return this->page_table.LockForCodeMemory(out, address, size);
+            }
+
+            Result UnlockForCodeMemory(KProcessAddress address, size_t size, const KPageGroup &pg) {
+                return this->page_table.UnlockForCodeMemory(address, size, pg);
+            }
+
+            Result CopyMemoryFromLinearToUser(KProcessAddress dst_addr, size_t size, KProcessAddress src_addr, u32 src_state_mask, u32 src_state, KMemoryPermission src_test_perm, u32 src_attr_mask, u32 src_attr) {
+                return this->page_table.CopyMemoryFromLinearToUser(dst_addr, size, src_addr, src_state_mask, src_state, src_test_perm, src_attr_mask, src_attr);
+            }
+
+            Result CopyMemoryFromLinearToKernel(KProcessAddress dst_addr, size_t size, KProcessAddress src_addr, u32 src_state_mask, u32 src_state, KMemoryPermission src_test_perm, u32 src_attr_mask, u32 src_attr) {
+                return this->page_table.CopyMemoryFromLinearToKernel(dst_addr, size, src_addr, src_state_mask, src_state, src_test_perm, src_attr_mask, src_attr);
+            }
+
+            Result CopyMemoryFromUserToLinear(KProcessAddress dst_addr, size_t size, u32 dst_state_mask, u32 dst_state, KMemoryPermission dst_test_perm, u32 dst_attr_mask, u32 dst_attr, KProcessAddress src_addr) {
+                return this->page_table.CopyMemoryFromUserToLinear(dst_addr, size, dst_state_mask, dst_state, dst_test_perm, dst_attr_mask, dst_attr, src_addr);
+            }
+
+            Result CopyMemoryFromKernelToLinear(KProcessAddress dst_addr, size_t size, u32 dst_state_mask, u32 dst_state, KMemoryPermission dst_test_perm, u32 dst_attr_mask, u32 dst_attr, KProcessAddress src_addr) {
+                return this->page_table.CopyMemoryFromKernelToLinear(dst_addr, size, dst_state_mask, dst_state, dst_test_perm, dst_attr_mask, dst_attr, src_addr);
+            }
+
+            Result CopyMemoryFromHeapToHeap(KProcessPageTable &dst_page_table, KProcessAddress dst_addr, size_t size, u32 dst_state_mask, u32 dst_state, KMemoryPermission dst_test_perm, u32 dst_attr_mask, u32 dst_attr, KProcessAddress src_addr, u32 src_state_mask, u32 src_state, KMemoryPermission src_test_perm, u32 src_attr_mask, u32 src_attr) {
+                return this->page_table.CopyMemoryFromHeapToHeap(dst_page_table.page_table, dst_addr, size, dst_state_mask, dst_state, dst_test_perm, dst_attr_mask, dst_attr, src_addr, src_state_mask, src_state, src_test_perm, src_attr_mask, src_attr);
+            }
+
+            Result CopyMemoryFromHeapToHeapWithoutCheckDestination(KProcessPageTable &dst_page_table, KProcessAddress dst_addr, size_t size, u32 dst_state_mask, u32 dst_state, KMemoryPermission dst_test_perm, u32 dst_attr_mask, u32 dst_attr, KProcessAddress src_addr, u32 src_state_mask, u32 src_state, KMemoryPermission src_test_perm, u32 src_attr_mask, u32 src_attr) {
+                return this->page_table.CopyMemoryFromHeapToHeapWithoutCheckDestination(dst_page_table.page_table, dst_addr, size, dst_state_mask, dst_state, dst_test_perm, dst_attr_mask, dst_attr, src_addr, src_state_mask, src_state, src_test_perm, src_attr_mask, src_attr);
+            }
+
+            Result SetupForIpc(KProcessAddress *out_dst_addr, size_t size, KProcessAddress src_addr, KProcessPageTable &src_page_table, KMemoryPermission test_perm, KMemoryState dst_state, bool send) {
+                return this->page_table.SetupForIpc(out_dst_addr, size, src_addr, src_page_table.page_table, test_perm, dst_state, send);
+            }
+
+            Result CleanupForIpcServer(KProcessAddress address, size_t size, KMemoryState dst_state, KProcess *server_process) {
+                return this->page_table.CleanupForIpcServer(address, size, dst_state, server_process);
+            }
+
+            Result CleanupForIpcClient(KProcessAddress address, size_t size, KMemoryState dst_state) {
+                return this->page_table.CleanupForIpcClient(address, size, dst_state);
+            }
+
+            Result MapPhysicalMemory(KProcessAddress address, size_t size) {
+                return this->page_table.MapPhysicalMemory(address, size);
+            }
+
+            Result UnmapPhysicalMemory(KProcessAddress address, size_t size) {
+                return this->page_table.UnmapPhysicalMemory(address, size);
+            }
+
+            Result MapPhysicalMemoryUnsafe(KProcessAddress address, size_t size) {
+                return this->page_table.MapPhysicalMemoryUnsafe(address, size);
+            }
+
+            Result UnmapPhysicalMemoryUnsafe(KProcessAddress address, size_t size) {
+                return this->page_table.UnmapPhysicalMemoryUnsafe(address, size);
+            }
+
+            void DumpTable() const {
+                return this->page_table.DumpTable();
+            }
+
+            void DumpMemoryBlocks() const {
+                return this->page_table.DumpMemoryBlocks();
+            }
+
             bool GetPhysicalAddress(KPhysicalAddress *out, KProcessAddress address) const {
                 return this->page_table.GetPhysicalAddress(out, address);
             }
 
             bool Contains(KProcessAddress addr, size_t size) const { return this->page_table.Contains(addr, size); }
+
+            bool IsInAliasRegion(KProcessAddress addr, size_t size) const { return this->page_table.IsInAliasRegion(addr, size); }
+            bool IsInUnsafeAliasRegion(KProcessAddress addr, size_t size) const { return this->page_table.IsInUnsafeAliasRegion(addr, size); }
+
             bool CanContain(KProcessAddress addr, size_t size, KMemoryState state) const { return this->page_table.CanContain(addr, size, state); }
 
             KProcessAddress GetAddressSpaceStart()    const { return this->page_table.GetAddressSpaceStart(); }
@@ -109,8 +261,11 @@ namespace ams::kern::arch::arm64 {
             size_t GetKernelMapRegionSize() const { return this->page_table.GetKernelMapRegionSize(); }
             size_t GetAliasCodeRegionSize() const { return this->page_table.GetAliasCodeRegionSize(); }
 
+            size_t GetNormalMemorySize() const { return this->page_table.GetNormalMemorySize(); }
+
+            u32 GetAllocateOption() const { return this->page_table.GetAllocateOption(); }
+
             KPhysicalAddress GetHeapPhysicalAddress(KVirtualAddress address) const {
-                /* TODO: Better way to convert address type? */
                 return this->page_table.GetHeapPhysicalAddress(address);
             }
 

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <mesosphere/kern_select_cpu.hpp>
+
+namespace ams::kern::arch::arm64 {
+
+    template<typename T>
+    concept SlabHeapNode = requires (T &t) {
+        { t.next } -> std::convertible_to<T *>;
+    };
+
+    template<typename T> requires SlabHeapNode<T>
+    ALWAYS_INLINE T *AllocateFromSlabAtomic(T **head) {
+        u32 tmp;
+        T *node, *next;
+
+        __asm__ __volatile__(
+            "1:\n"
+            "    ldaxr  %[node], [%[head]]\n"
+            "    cbz    %[node], 2f\n"
+            "    ldr    %[next], [%[node]]\n"
+            "    stlxr  %w[tmp], %[next], [%[head]]\n"
+            "    cbnz   %w[tmp], 1b\n"
+            "    b      3f\n"
+            "2:\n"
+            "    clrex\n"
+            "3:\n"
+            : [tmp]"=&r"(tmp), [node]"=&r"(node), [next]"=&r"(next), [head]"+&r"(head)
+            :
+            : "cc", "memory"
+        );
+
+        return node;
+    }
+
+    template<typename T> requires SlabHeapNode<T>
+    ALWAYS_INLINE void FreeToSlabAtomic(T **head, T *node) {
+        u32 tmp;
+        T *next;
+
+        __asm__ __volatile__(
+            "1:\n"
+            "    ldaxr  %[next], [%[head]]\n"
+            "    str    %[next], [%[node]]\n"
+            "    stlxr  %w[tmp], %[node], [%[head]]\n"
+            "    cbnz   %w[tmp], 1b\n"
+            "2:\n"
+            : [tmp]"=&r"(tmp), [node]"+&r"(node), [next]"=&r"(next), [head]"+&r"(head)
+            :
+            : "cc", "memory"
+        );
+    }
+
+}

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

@@ -23,9 +23,9 @@ namespace ams::kern::arch::arm64 {
     class KSupervisorPageTable {
         private:
             KPageTable page_table;
-            u64 ttbr0[cpu::NumCores];
+            u64 ttbr0_identity[cpu::NumCores];
         public:
-            constexpr KSupervisorPageTable() : page_table(), ttbr0() { /* ... */ }
+            constexpr KSupervisorPageTable() : page_table(), ttbr0_identity() { /* ... */ }
 
             NOINLINE void Initialize(s32 core_id);
 
@@ -41,8 +41,6 @@ namespace ams::kern::arch::arm64 {
                 cpu::InvalidateEntireTlb();
             }
 
-            void Finalize(s32 core_id);
-
             Result MapPages(KProcessAddress *out_addr, size_t num_pages, size_t alignment, KPhysicalAddress phys_addr, KProcessAddress region_start, size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
                 return this->page_table.MapPages(out_addr, num_pages, alignment, phys_addr, region_start, region_num_pages, state, perm);
             }
@@ -62,6 +60,8 @@ namespace ams::kern::arch::arm64 {
             bool GetPhysicalAddress(KPhysicalAddress *out, KProcessAddress address) const {
                 return this->page_table.GetPhysicalAddress(out, address);
             }
+
+            constexpr u64 GetIdentityMapTtbr0(s32 core_id) const { return this->ttbr0_identity[core_id]; }
     };
 
 }

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

@@ -66,7 +66,21 @@ namespace ams::kern::arch::arm64 {
 
             static void FpuContextSwitchHandler(KThread *thread);
 
-            /* TODO: More methods (especially FPU management) */
+            u32 GetFpcr() const { return this->fpcr; }
+            u32 GetFpsr() const { return this->fpsr; }
+
+            void SetFpcr(u32 v) { this->fpcr = v; }
+            void SetFpsr(u32 v) { this->fpsr = v; }
+
+            void CloneFpuStatus();
+
+            void SetFpuRegisters(const u128 *v, bool is_64_bit);
+
+            const u128 *GetFpuRegisters() const { return this->fpu_registers; }
+        public:
+            static void OnThreadTerminating(const KThread *thread);
     };
 
+    void GetUserContext(ams::svc::ThreadContext *out, const KThread *thread);
+
 }

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

@@ -39,6 +39,10 @@ namespace ams::kern::arch::arm64 {
             static bool ClearMemoryAligned64Bit(void *dst, size_t size);
             static bool ClearMemorySize32Bit(void *dst);
 
+            static bool UpdateLockAtomic(u32 *out, u32 *address, u32 if_zero, u32 new_orr_mask);
+            static bool UpdateIfEqualAtomic(s32 *out, s32 *address, s32 compare_value, s32 new_value);
+            static bool DecrementIfLessThanAtomic(s32 *out, s32 *address, s32 compare);
+
             static bool StoreDataCache(uintptr_t start, uintptr_t end);
             static bool FlushDataCache(uintptr_t start, uintptr_t end);
             static bool InvalidateDataCache(uintptr_t start, uintptr_t end);