git subrepo push libraries

subrepo:
  subdir:   "libraries"
  merged:   "5a18bea6"
upstream:
  origin:   "https://github.com/Atmosphere-NX/Atmosphere-libs"
  branch:   "master"
  commit:   "5a18bea6"
git-subrepo:
  version:  "0.4.1"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "a04d8c2"

config_templates/exosphere.ini

@@ -35,6 +35,17 @@
 #    mmc space, encrypted to prevent detection. This backup can be used
 #    to prevent unrecoverable edits in emergencies.
 
+# Key: log_port, default: 0.
+#  Desc: Controls what uart port exosphere will set up for logging.
+#  NOTE: 0 = UART-A, 1 = UART-B, 2 = UART-C, 3 = UART-D
+
+# Key: log_baud_rate, default: 115200
+#  Desc: Controls the baud rate exosphere will set up for logging.
+#  NOTE: 0 is treated as equivalent to 115200.
+
+# Key: log_inverted, default: 0.
+#  Desc: Controls whether the logging uart port is inverted.
+
 [exosphere]
 debugmode=1
 debugmode_user=0
@@ -43,3 +54,6 @@ enable_user_pmu_access=0
 blank_prodinfo_sysmmc=0
 blank_prodinfo_emummc=0
 allow_writing_to_cal_sysmmc=0
+log_port=0
+log_baud_rate=115200
+log_inverted=0

docs/changelog.md

@@ -1,4 +1,16 @@
 # Changelog
+## 0.16.1
++ Support was added for 11.0.1.
+  + `mesosphère` was updated to reflect the latest official kernel behavior.
+    + A new svc::InfoType added in 11.0.0 was implemented (it wasn't discovered before 0.16.0 released).
+    + The new Control Flow Integrity (CFI) logic added in 11.0.0 kernel was implemented.
++ `fs` logic was refactored and cleaned up to reflect some newer sysmodule behavioral and structural changes.
++ `exosphère` was updated to allow dynamic control of what uart port is used for logging.
+  + This can be controlled by editing the `log_port`, `log_baud_rate`, and `log_inverted` fields in `exosphere.ini`.
++ `mesosphère` was updated to improve debugging capabilities ().
+  + This is still a work in progress, but developers may be interested.
++ A bug was fixed that caused `fatal` to fatal error if the fatal process was already being debugged.
++ Several issues were fixed, and usability and stability were improved.
 ## 0.16.0
 + Support was added for 11.0.0.
   + `exosphère` was updated to reflect the latest official secure monitor behavior.

emummc/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/m4xw/emuMMC
 	branch = develop
-	commit = 6fd752dad13c02d482a5d89c24f4e8ce8b9d8f56
-	parent = 4f1a4e74992aa84b8ab84bccacc720e2d5823791
+	commit = 5eed18eb527bbaa63aee5323c26de5b0cca6d28e
+	parent = 021b29d2dbc8ed0469bc822393e58c9f0d174d57
 	method = rebase
 	cmdver = 0.4.1

emummc/README.md

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

emummc/source/FS/FS_offsets.c

@@ -71,6 +71,7 @@ static const fs_offsets_t GET_OFFSET_STRUCT_NAME(vers) = { \
     .nand_mutex                      = FS_OFFSET##vers##_NAND_MUTEX, \
     .active_partition                = FS_OFFSET##vers##_ACTIVE_PARTITION, \
     .sdmmc_das_handle                = FS_OFFSET##vers##_SDMMC_DAS_HANDLE, \
+    .sdmmc_accessor_controller_open  = FS_OFFSET##vers##_SDMMC_WRAPPER_CONTROLLER_OPEN, \
     .sdmmc_accessor_controller_close = FS_OFFSET##vers##_SDMMC_WRAPPER_CONTROLLER_CLOSE, \
     .sd_das_init                     = FS_OFFSET##vers##_SD_DAS_INIT, \
     .nintendo_paths                  = FS_OFFSET##vers##_NINTENDO_PATHS, \

emummc/source/FS/FS_offsets.h

@@ -41,6 +41,7 @@ typedef struct {
     // Misc funcs
     uintptr_t lock_mutex;
     uintptr_t unlock_mutex;
+    uintptr_t sdmmc_accessor_controller_open;
     uintptr_t sdmmc_accessor_controller_close;
     // Misc data
     uintptr_t sd_mutex;

emummc/source/FS/FS_structs.h

@@ -35,7 +35,7 @@ typedef struct sdmmc_accessor_vt
     void *dtor;
     void *map_device_addr_space;
     void *unmap_device_addr_space;
-    void *controller_open;
+    uint64_t (*sdmmc_accessor_controller_open)(void *);
     uint64_t (*sdmmc_accessor_controller_close)(void *);
     uint64_t (*read_write)(void *, uint64_t, uint64_t, void *, uint64_t, uint64_t);
     // More not included because we don't use it.

emummc/source/FS/offsets/100.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_100_LOCK_MUTEX          0x2884
 #define FS_OFFSET_100_UNLOCK_MUTEX        0x28F0
 
+#define FS_OFFSET_100_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_100_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x6A8AC
 
 // Misc Data

emummc/source/FS/offsets/1000.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_1000_LOCK_MUTEX          0x28910
 #define FS_OFFSET_1000_UNLOCK_MUTEX        0x28960
 
+#define FS_OFFSET_1000_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_1000_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1422E0
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_1000_EXFAT_LOCK_MUTEX          0x28910
 #define FS_OFFSET_1000_EXFAT_UNLOCK_MUTEX        0x28960
 
+#define FS_OFFSET_1000_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_1000_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1422E0
 
 // Misc Data

emummc/source/FS/offsets/1020.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_1020_LOCK_MUTEX          0x28910
 #define FS_OFFSET_1020_UNLOCK_MUTEX        0x28960
 
+#define FS_OFFSET_1020_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_1020_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x142740
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_1020_EXFAT_LOCK_MUTEX          0x28910
 #define FS_OFFSET_1020_EXFAT_UNLOCK_MUTEX        0x28960
 
+#define FS_OFFSET_1020_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_1020_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x142740
 
 // Misc Data

emummc/source/FS/offsets/1100.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_1100_LOCK_MUTEX          0x28FF0
 #define FS_OFFSET_1100_UNLOCK_MUTEX        0x29040
 
+#define FS_OFFSET_1100_SDMMC_WRAPPER_CONTROLLER_OPEN  0x14B840
 #define FS_OFFSET_1100_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x14B8F0
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_1100_EXFAT_LOCK_MUTEX          0x28FF0
 #define FS_OFFSET_1100_EXFAT_UNLOCK_MUTEX        0x29040
 
+#define FS_OFFSET_1100_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0x14B840
 #define FS_OFFSET_1100_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x14B8F0
 
 // Misc Data

emummc/source/FS/offsets/200.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_200_LOCK_MUTEX          0x3264
 #define FS_OFFSET_200_UNLOCK_MUTEX        0x32D0
 
+#define FS_OFFSET_200_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_200_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x733F4
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_200_EXFAT_LOCK_MUTEX          0x3264
 #define FS_OFFSET_200_EXFAT_UNLOCK_MUTEX        0x32D0
 
+#define FS_OFFSET_200_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_200_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x733F4
 
 // Misc Data

emummc/source/FS/offsets/210.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_210_LOCK_MUTEX          0x3264
 #define FS_OFFSET_210_UNLOCK_MUTEX        0x32D0
 
+#define FS_OFFSET_210_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_210_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x737D4
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_210_EXFAT_LOCK_MUTEX          0x3264
 #define FS_OFFSET_210_EXFAT_UNLOCK_MUTEX        0x32D0
 
+#define FS_OFFSET_210_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_210_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x737D4
 
 // Misc Data

emummc/source/FS/offsets/300.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_300_LOCK_MUTEX          0x35CC
 #define FS_OFFSET_300_UNLOCK_MUTEX        0x3638
 
+#define FS_OFFSET_300_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_300_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x8A270
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_300_EXFAT_LOCK_MUTEX          0x35CC
 #define FS_OFFSET_300_EXFAT_UNLOCK_MUTEX        0x3638
 
+#define FS_OFFSET_300_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_300_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x8A270
 
 // Misc Data

emummc/source/FS/offsets/301.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_301_LOCK_MUTEX          0x3638
 #define FS_OFFSET_301_UNLOCK_MUTEX        0x36A4
 
+#define FS_OFFSET_301_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_301_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x8A32C
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_301_EXFAT_LOCK_MUTEX          0x3638
 #define FS_OFFSET_301_EXFAT_UNLOCK_MUTEX        0x36A4
 
+#define FS_OFFSET_301_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_301_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x8A32C
 
 // Misc Data

emummc/source/FS/offsets/400.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_400_LOCK_MUTEX          0x39A0
 #define FS_OFFSET_400_UNLOCK_MUTEX        0x3A0C
 
+#define FS_OFFSET_400_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_400_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x9DB48
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_400_EXFAT_LOCK_MUTEX          0x39A0
 #define FS_OFFSET_400_EXFAT_UNLOCK_MUTEX        0x3A0C
 
+#define FS_OFFSET_400_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_400_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x9DB48
 
 // Misc Data

emummc/source/FS/offsets/410.h

@@ -34,7 +34,8 @@
 #define FS_OFFSET_410_LOCK_MUTEX          0x39A0
 #define FS_OFFSET_410_UNLOCK_MUTEX        0x3A0C
 
-#define FS_OFFSET_410_SDMMC_WRAPPER_CONTROLLER_CLOSE        0x9DBAC
+#define FS_OFFSET_410_SDMMC_WRAPPER_CONTROLLER_OPEN  0
+#define FS_OFFSET_410_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x9DBAC
 
 // Misc Data
 #define FS_OFFSET_410_SD_MUTEX            0xE80268

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_410_EXFAT_LOCK_MUTEX          0x39A0
 #define FS_OFFSET_410_EXFAT_UNLOCK_MUTEX        0x3A0C
 
+#define FS_OFFSET_410_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_410_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x9DBAC
 
 // Misc Data

emummc/source/FS/offsets/500.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_500_LOCK_MUTEX          0x4080
 #define FS_OFFSET_500_UNLOCK_MUTEX        0x40D0
 
+#define FS_OFFSET_500_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_500_SDMMC_WRAPPER_CONTROLLER_CLOSE 0xC9380
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_500_EXFAT_LOCK_MUTEX          0x4080
 #define FS_OFFSET_500_EXFAT_UNLOCK_MUTEX        0x40D0
 
+#define FS_OFFSET_500_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_500_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0xC9380
 
 // Misc Data

emummc/source/FS/offsets/510.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_510_LOCK_MUTEX          0x4080
 #define FS_OFFSET_510_UNLOCK_MUTEX        0x40D0
 
+#define FS_OFFSET_510_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_510_SDMMC_WRAPPER_CONTROLLER_CLOSE 0xC9750
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_510_EXFAT_LOCK_MUTEX          0x4080
 #define FS_OFFSET_510_EXFAT_UNLOCK_MUTEX        0x40D0
 
+#define FS_OFFSET_510_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_510_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0xC9750
 
 // Misc Data

emummc/source/FS/offsets/600.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_600_LOCK_MUTEX          0x1412C0
 #define FS_OFFSET_600_UNLOCK_MUTEX        0x141310
 
+#define FS_OFFSET_600_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_600_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x148500
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_600_EXFAT_LOCK_MUTEX          0x14C9C0
 #define FS_OFFSET_600_EXFAT_UNLOCK_MUTEX        0x14CA10
 
+#define FS_OFFSET_600_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_600_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x153C00
 
 // Misc Data

emummc/source/FS/offsets/700.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_700_LOCK_MUTEX          0x148A90
 #define FS_OFFSET_700_UNLOCK_MUTEX        0x148AE0
 
+#define FS_OFFSET_700_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_700_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x14FD50
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_700_EXFAT_LOCK_MUTEX          0x154040
 #define FS_OFFSET_700_EXFAT_UNLOCK_MUTEX        0x154090
 
+#define FS_OFFSET_700_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_700_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x15B300
 
 // Misc Data

emummc/source/FS/offsets/800.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_800_LOCK_MUTEX          0x14B6D0
 #define FS_OFFSET_800_UNLOCK_MUTEX        0x14B720
 
+#define FS_OFFSET_800_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_800_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1529E0
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_800_EXFAT_LOCK_MUTEX          0x156C80
 #define FS_OFFSET_800_EXFAT_UNLOCK_MUTEX        0x156CD0
 
+#define FS_OFFSET_800_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_800_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x15DF90
 
 // Misc Data

emummc/source/FS/offsets/810.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_810_LOCK_MUTEX          0x14B6D0
 #define FS_OFFSET_810_UNLOCK_MUTEX        0x14B720
 
+#define FS_OFFSET_810_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_810_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x1529E0
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_810_EXFAT_LOCK_MUTEX          0x156C80
 #define FS_OFFSET_810_EXFAT_UNLOCK_MUTEX        0x156CD0
 
+#define FS_OFFSET_810_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_810_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x15DF90
 
 // Misc Data

emummc/source/FS/offsets/900.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_900_LOCK_MUTEX          0x25280
 #define FS_OFFSET_900_UNLOCK_MUTEX        0x252D0
 
+#define FS_OFFSET_900_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_900_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x137740
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_900_EXFAT_LOCK_MUTEX          0x25280
 #define FS_OFFSET_900_EXFAT_UNLOCK_MUTEX        0x252D0
 
+#define FS_OFFSET_900_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_900_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x137740
 
 // Misc Data

emummc/source/FS/offsets/910.h

@@ -34,6 +34,7 @@
 #define FS_OFFSET_910_LOCK_MUTEX          0x25280
 #define FS_OFFSET_910_UNLOCK_MUTEX        0x252D0
 
+#define FS_OFFSET_910_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_910_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x137750
 
 // Misc Data

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

@@ -34,6 +34,7 @@
 #define FS_OFFSET_910_EXFAT_LOCK_MUTEX          0x25280
 #define FS_OFFSET_910_EXFAT_UNLOCK_MUTEX        0x252D0
 
+#define FS_OFFSET_910_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0
 #define FS_OFFSET_910_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x137750
 
 // Misc Data

emummc/source/emuMMC/emummc.c

@@ -271,7 +271,7 @@ int sdmmc_nand_get_active_partition_index()
 
 static uint64_t emummc_read_write_inner(void *buf, unsigned int sector, unsigned int num_sectors, bool is_write)
 {
-    if ((emuMMC_ctx.EMMC_Type == emuMMC_SD))
+    if ((emuMMC_ctx.EMMC_Type == emuMMC_SD_Raw))
     {
         // raw partition sector offset: emuMMC_ctx.EMMC_StoragePartitionOffset.
         sector += emuMMC_ctx.EMMC_StoragePartitionOffset;
@@ -318,6 +318,31 @@ static uint64_t emummc_read_write_inner(void *buf, unsigned int sector, unsigned
     return res;
 }
 
+// Controller open wrapper
+uint64_t sdmmc_wrapper_controller_open(int mmc_id)
+{
+    uint64_t result;
+    sdmmc_accessor_t *_this;
+    _this = sdmmc_accessor_get(mmc_id);
+
+    if (_this != NULL)
+    {
+        // Lock eMMC xfer while SD card is being initialized by FS.
+        if (_this == sdmmc_accessor_get(FS_SDMMC_SD))
+            mutex_lock_handler(FS_SDMMC_EMMC); // Recursive Mutex, handler will lock SD as well if custom_driver
+
+        result = _this->vtab->sdmmc_accessor_controller_open(_this);
+
+        // Unlock eMMC.
+        if (_this == sdmmc_accessor_get(FS_SDMMC_SD))
+            mutex_unlock_handler(FS_SDMMC_EMMC);
+
+        return result;
+    }
+
+    fatal_abort(Fatal_OpenAccessor);
+}
+
 // Controller close wrapper
 uint64_t sdmmc_wrapper_controller_close(int mmc_id)
 {
@@ -389,7 +414,7 @@ uint64_t sdmmc_wrapper_read(void *buf, uint64_t bufSize, int mmc_id, unsigned in
             if (first_sd_read)
             {
                 first_sd_read = false;
-                if (emuMMC_ctx.EMMC_Type == emuMMC_SD)
+                if (emuMMC_ctx.EMMC_Type == emuMMC_SD_Raw)
                 {
                     // Because some SD cards have issues with emuMMC's driver
                     // we currently swap to FS's driver after first SD read
@@ -400,7 +425,7 @@ uint64_t sdmmc_wrapper_read(void *buf, uint64_t bufSize, int mmc_id, unsigned in
                 }
             }
 
-            // Call hekates driver.
+            // Call hekate's driver.
             if (sdmmc_storage_read(&sd_storage, sector, num_sectors, buf))
             {
                 mutex_unlock_handler(mmc_id);

emummc/source/emuMMC/emummc.h

@@ -52,6 +52,7 @@ void mutex_lock_handler(int mmc_id);
 void mutex_unlock_handler(int mmc_id);
 
 // Hooks
+uint64_t sdmmc_wrapper_controller_open(int mmc_id);
 uint64_t sdmmc_wrapper_controller_close(int mmc_id);
 uint64_t sdmmc_wrapper_read(void *buf, uint64_t bufSize, int mmc_id, unsigned int sector, unsigned int num_sectors);
 uint64_t sdmmc_wrapper_write(int mmc_id, unsigned int sector, unsigned int num_sectors, void *buf, uint64_t bufSize);

emummc/source/emuMMC/emummc_ctx.h

@@ -30,7 +30,7 @@ enum emuMMC_Type
     emuMMC_EMMC = 0,
 
     // SD Device raw
-    emuMMC_SD,
+    emuMMC_SD_Raw,
     // SD Device File
     emuMMC_SD_File,
 

emummc/source/main.c

@@ -92,7 +92,7 @@ volatile __attribute__((aligned(0x1000))) emuMMC_ctx_t emuMMC_ctx = {
     .fs_ver = FS_VER_MAX,
 
     // SD Default Metadata
-    .SD_Type = emuMMC_SD,
+    .SD_Type = emuMMC_SD_Raw,
     .SD_StoragePartitionOffset = 0,
 
     // EMMC Default Metadata
@@ -285,6 +285,9 @@ void setup_hooks(void)
     INJECT_HOOK(fs_offsets->sdmmc_wrapper_read, sdmmc_wrapper_read);
     // sdmmc_wrapper_write hook
     INJECT_HOOK(fs_offsets->sdmmc_wrapper_write, sdmmc_wrapper_write);
+	// sdmmc_wrapper_controller_open hook
+    if (fs_offsets->sdmmc_accessor_controller_open)
+        INJECT_HOOK(fs_offsets->sdmmc_accessor_controller_open, sdmmc_wrapper_controller_open);
     // sdmmc_wrapper_controller_close hook
     INJECT_HOOK(fs_offsets->sdmmc_accessor_controller_close, sdmmc_wrapper_controller_close);
 
@@ -346,7 +349,7 @@ static void load_emummc_ctx(void)
         emuMMC_ctx.id = config.base_cfg.id;
         emuMMC_ctx.EMMC_Type = (enum emuMMC_Type)config.base_cfg.type;
         emuMMC_ctx.fs_ver = (enum FS_VER)config.base_cfg.fs_version;
-        if (emuMMC_ctx.EMMC_Type == emuMMC_SD)
+        if (emuMMC_ctx.EMMC_Type == emuMMC_SD_Raw)
         {
             emuMMC_ctx.EMMC_StoragePartitionOffset = config.partition_cfg.start_sector;
         }

exosphere/program/source/secmon_setup.cpp

@@ -960,7 +960,7 @@ namespace ams::secmon {
         }
 
         void SetupLogForBoot() {
-            log::Initialize();
+            log::Initialize(secmon::GetLogPort(), secmon::GetLogBaudRate(), secmon::GetLogFlags());
             log::SendText("OHAYO\n", 6);
             log::Flush();
         }

exosphere/program/source/smc/secmon_smc_info.cpp

@@ -282,6 +282,10 @@ namespace ams::secmon::smc {
                         return SmcResult::NotInitialized;
                     }
                     break;
+                case ConfigItem::ExosphereLogConfiguration:
+                    /* Get the log configuration. */
+                    args.r[1] = (static_cast<u64>(static_cast<u8>(secmon::GetLogPort())) << 32) | static_cast<u64>(secmon::GetLogBaudRate());
+                    break;
                 default:
                     return SmcResult::InvalidArgument;
             }

exosphere/program/source/smc/secmon_smc_info.hpp

@@ -40,15 +40,16 @@ namespace ams::secmon::smc {
         Package2Hash                  = 17,
 
         /* Extension config items for exosphere. */
-        ExosphereApiVersion     = 65000,
-        ExosphereNeedsReboot    = 65001,
-        ExosphereNeedsShutdown  = 65002,
-        ExosphereGitCommitHash  = 65003,
-        ExosphereHasRcmBugPatch = 65004,
-        ExosphereBlankProdInfo  = 65005,
-        ExosphereAllowCalWrites = 65006,
-        ExosphereEmummcType     = 65007,
-        ExospherePayloadAddress = 65008,
+        ExosphereApiVersion       = 65000,
+        ExosphereNeedsReboot      = 65001,
+        ExosphereNeedsShutdown    = 65002,
+        ExosphereGitCommitHash    = 65003,
+        ExosphereHasRcmBugPatch   = 65004,
+        ExosphereBlankProdInfo    = 65005,
+        ExosphereAllowCalWrites   = 65006,
+        ExosphereEmummcType       = 65007,
+        ExospherePayloadAddress   = 65008,
+        ExosphereLogConfiguration = 65009,
     };
 
     SmcResult SmcGetConfigUser(SmcArguments &args);

exosphere/program/source/smc/secmon_smc_power_management.cpp

@@ -409,6 +409,7 @@ namespace ams::secmon::smc {
             /* NOTE: Nintendo only does this on dev, but we will always do it. */
             if (true /* !pkg1::IsProduction() */) {
                 log::SendText("OYASUMI\n", 8);
+                log::Flush();
             }
 
             /* If we're on erista, configure the bootrom to allow our custom warmboot firmware. */

fusee/fusee-secondary/src/exocfg.h

@@ -34,11 +34,17 @@
 #define EXOSPHERE_FLAG_BLANK_PRODINFO                       (1 << 5u)
 #define EXOSPHERE_FLAG_ALLOW_WRITING_TO_CAL_SYSMMC          (1 << 6u)
 
+#define EXOSPHERE_LOG_FLAG_INVERTED (1 << 0u)
+
 typedef struct {
     uint32_t magic;
     uint32_t target_firmware;
-    uint32_t flags;
-    uint32_t reserved[5];
+    uint32_t flags[2];
+    uint16_t lcd_vendor;
+    uint8_t  log_port;
+    uint8_t  log_flags;
+    uint32_t log_baud_rate;
+    uint32_t reserved1[2];
     exo_emummc_config_t emummc_cfg;
 } exosphere_config_t;
 
@@ -54,6 +60,9 @@ _Static_assert(sizeof(exosphere_config_t) == 0x20 + sizeof(exo_emummc_config_t),
 #define EXOSPHERE_BLANK_PRODINFO_SYSMMC_KEY "blank_prodinfo_sysmmc"
 #define EXOSPHERE_BLANK_PRODINFO_EMUMMC_KEY "blank_prodinfo_emummc"
 #define EXOSPHERE_ALLOW_WRITING_TO_CAL_SYSMMC_KEY "allow_writing_to_cal_sysmmc"
+#define EXOSPHERE_LOG_PORT_KEY "log_port"
+#define EXOSPHERE_LOG_BAUD_RATE_KEY "log_baud_rate"
+#define EXOSPHERE_LOG_INVERTED_KEY "log_inverted"
 
 typedef struct {
     int debugmode;
@@ -63,6 +72,9 @@ typedef struct {
     int blank_prodinfo_sysmmc;
     int blank_prodinfo_emummc;
     int allow_writing_to_cal_sysmmc;
+    int log_port;
+    int log_baud_rate;
+    int log_inverted;
 } exosphere_parse_cfg_t;
 
 #endif

fusee/fusee-secondary/src/kernel_patches.c

@@ -906,6 +906,35 @@ static const kernel_patch_t g_kernel_patches_1100[] = {
     }
 };
 
+static const kernel_patch_t g_kernel_patches_1101[] = {
+    {   /* Send Message Process ID Patch. */
+        .pattern_size = 0x1C,
+        .pattern = MAKE_KERNEL_PATTERN_NAME(1100, proc_id_send),
+        .pattern_hook_offset = 0x0,
+        .payload_num_instructions = sizeof(MAKE_KERNEL_PATCH_NAME(1100, proc_id_send))/sizeof(instruction_t),
+        .branch_back_offset = 0x10,
+        .payload = MAKE_KERNEL_PATCH_NAME(1100, proc_id_send)
+    },
+    {   /* Receive Message Process ID Patch. */
+        .pattern_size = 0x1C,
+        .pattern = MAKE_KERNEL_PATTERN_NAME(1100, proc_id_recv),
+        .pattern_hook_offset = 0x0,
+        .payload_num_instructions = sizeof(MAKE_KERNEL_PATCH_NAME(1100, proc_id_recv))/sizeof(instruction_t),
+        .branch_back_offset = 0x10,
+        .payload = MAKE_KERNEL_PATCH_NAME(1100, proc_id_recv)
+    },
+    {   /* svcControlCodeMemory Patch. */
+        .payload_num_instructions = sizeof(MAKE_KERNEL_PATCH_NAME(1100, svc_control_codememory))/sizeof(instruction_t),
+        .payload = MAKE_KERNEL_PATCH_NAME(1100, svc_control_codememory),
+        .patch_offset = 0x2FD04,
+    },
+    {   /* System Memory Increase Patch. */
+        .payload_num_instructions = sizeof(MAKE_KERNEL_PATCH_NAME(1100, system_memory_increase))/sizeof(instruction_t),
+        .payload = MAKE_KERNEL_PATCH_NAME(1100, system_memory_increase),
+        .patch_offset = 0x490C4,
+    }
+};
+
 #define KERNEL_PATCHES(vers) .num_patches = sizeof(g_kernel_patches_##vers)/sizeof(kernel_patch_t), .patches = g_kernel_patches_##vers,
 
 /* Kernel Infos. */
@@ -1000,6 +1029,15 @@ static const kernel_info_t g_kernel_infos[] = {
         .embedded_ini_ptr = 0x180,
         .free_code_space_offset = 0x49EE8,
         KERNEL_PATCHES(1100)
+    },
+    {   /* 11.0.1. */
+        .hash = {0x68, 0xB9, 0x72, 0xB7, 0x97, 0x55, 0x87, 0x5E, 0x24, 0x95, 0x8D, 0x99, 0x0A, 0x77, 0xAB, 0xF1, 0xC5, 0xC1, 0x32, 0x80, 0x67, 0xF0, 0xA2, 0xEC, 0x9C, 0xEF, 0xC3, 0x22, 0xE3, 0x42, 0xC0, 0x4D, },
+        .hash_offset = 0x1C4,
+        .hash_size = 0x69000 - 0x1C4,
+        .embedded_ini_offset = 0x69000,
+        .embedded_ini_ptr = 0x180,
+        .free_code_space_offset = 0x49EE8,
+        KERNEL_PATCHES(1101)
     }
 };
 

fusee/fusee-secondary/src/nxboot.c

@@ -196,6 +196,27 @@ static int exosphere_ini_handler(void *user, const char *section, const char *na
             } else if (tmp == 0) {
                 parse_cfg->allow_writing_to_cal_sysmmc = 0;
             }
+        } else if (strcmp(name, EXOSPHERE_LOG_PORT_KEY) == 0) {
+            sscanf(value, "%d", &tmp);
+            if (0 <= tmp && tmp < 4) {
+                parse_cfg->log_port = tmp;
+            } else {
+                parse_cfg->log_port = 0;
+            }
+        } else if (strcmp(name, EXOSPHERE_LOG_BAUD_RATE_KEY) == 0) {
+            sscanf(value, "%d", &tmp);
+            if (tmp > 0) {
+                parse_cfg->log_baud_rate = tmp;
+            } else {
+                parse_cfg->log_baud_rate = 115200;
+            }
+        } else if (strcmp(name, EXOSPHERE_LOG_INVERTED_KEY) == 0) {
+            sscanf(value, "%d", &tmp);
+            if (tmp == 1) {
+                parse_cfg->log_inverted = 1;
+            } else if (tmp == 0) {
+                parse_cfg->log_inverted = 0;
+            }
         } else {
             return 0;
         }
@@ -240,6 +261,7 @@ 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_11_0_0) {
+        CHECK_NCA("56211c7a5ed20a5332f5cdda67121e37", 11_0_1);
         CHECK_NCA("594c90bcdbcccad6b062eadba0cd0e7e", 11_0_0);
     } else if (target_firmware >= ATMOSPHERE_TARGET_FIRMWARE_10_0_0) {
         CHECK_NCA("26325de4db3909e0ef2379787c7e671d", 10_2_0);
@@ -464,9 +486,9 @@ static void nxboot_configure_exosphere(uint32_t target_firmware, unsigned int ke
     const bool is_emummc = exo_emummc_cfg->base_cfg.magic == MAGIC_EMUMMC_CONFIG && exo_emummc_cfg->base_cfg.type != EMUMMC_TYPE_NONE;
 
     if (keygen_type) {
-        exo_cfg.flags = EXOSPHERE_FLAG_PERFORM_620_KEYGEN;
+        exo_cfg.flags[0] = EXOSPHERE_FLAG_PERFORM_620_KEYGEN;
     } else {
-        exo_cfg.flags = 0;
+        exo_cfg.flags[0] = 0;
     }
 
     /* Setup exosphere parse configuration with defaults. */
@@ -478,6 +500,9 @@ static void nxboot_configure_exosphere(uint32_t target_firmware, unsigned int ke
         .blank_prodinfo_sysmmc              = 0,
         .blank_prodinfo_emummc              = 0,
         .allow_writing_to_cal_sysmmc        = 0,
+        .log_port                           = 0,
+        .log_baud_rate                      = 115200,
+        .log_inverted                       = 0,
     };
 
     /* If we have an ini to read, parse it. */
@@ -490,13 +515,17 @@ static void nxboot_configure_exosphere(uint32_t target_firmware, unsigned int ke
     free(exosphere_ini);
 
     /* Apply parse config. */
-    if (parse_cfg.debugmode)                           exo_cfg.flags |= EXOSPHERE_FLAG_IS_DEBUGMODE_PRIV;
-    if (parse_cfg.debugmode_user)                      exo_cfg.flags |= EXOSPHERE_FLAG_IS_DEBUGMODE_USER;
-    if (parse_cfg.disable_user_exception_handlers)     exo_cfg.flags |= EXOSPHERE_FLAG_DISABLE_USERMODE_EXCEPTION_HANDLERS;
-    if (parse_cfg.enable_user_pmu_access)              exo_cfg.flags |= EXOSPHERE_FLAG_ENABLE_USERMODE_PMU_ACCESS;
-    if (parse_cfg.blank_prodinfo_sysmmc && !is_emummc) exo_cfg.flags |= EXOSPHERE_FLAG_BLANK_PRODINFO;
-    if (parse_cfg.blank_prodinfo_emummc &&  is_emummc) exo_cfg.flags |= EXOSPHERE_FLAG_BLANK_PRODINFO;
-    if (parse_cfg.allow_writing_to_cal_sysmmc)         exo_cfg.flags |= EXOSPHERE_FLAG_ALLOW_WRITING_TO_CAL_SYSMMC;
+    if (parse_cfg.debugmode)                           exo_cfg.flags[0] |= EXOSPHERE_FLAG_IS_DEBUGMODE_PRIV;
+    if (parse_cfg.debugmode_user)                      exo_cfg.flags[0] |= EXOSPHERE_FLAG_IS_DEBUGMODE_USER;
+    if (parse_cfg.disable_user_exception_handlers)     exo_cfg.flags[0] |= EXOSPHERE_FLAG_DISABLE_USERMODE_EXCEPTION_HANDLERS;
+    if (parse_cfg.enable_user_pmu_access)              exo_cfg.flags[0] |= EXOSPHERE_FLAG_ENABLE_USERMODE_PMU_ACCESS;
+    if (parse_cfg.blank_prodinfo_sysmmc && !is_emummc) exo_cfg.flags[0] |= EXOSPHERE_FLAG_BLANK_PRODINFO;
+    if (parse_cfg.blank_prodinfo_emummc &&  is_emummc) exo_cfg.flags[0] |= EXOSPHERE_FLAG_BLANK_PRODINFO;
+    if (parse_cfg.allow_writing_to_cal_sysmmc)         exo_cfg.flags[0] |= EXOSPHERE_FLAG_ALLOW_WRITING_TO_CAL_SYSMMC;
+
+    exo_cfg.log_port      = parse_cfg.log_port;
+    exo_cfg.log_baud_rate = parse_cfg.log_baud_rate;
+    if (parse_cfg.log_inverted) exo_cfg.log_flags |= EXOSPHERE_LOG_FLAG_INVERTED;
 
     if ((exo_cfg.target_firmware < ATMOSPHERE_TARGET_FIRMWARE_MIN) || (exo_cfg.target_firmware > ATMOSPHERE_TARGET_FIRMWARE_MAX)) {
         fatal_error("[NXBOOT] Invalid Exosphere target firmware!\n");

libraries/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/Atmosphere-NX/Atmosphere-libs
 	branch = master
-	commit = 78510a74f010eb532ba77f905171f41094df94cb
-	parent = f72475872a5a6519e5ca9322e7f1960432230f40
+	commit = 5a18bea64545105c52d642d7789029b5ca875864
+	parent = 17c8c390fc84d059b89f563a8fae6936649d0d45
 	method = merge
 	cmdver = 0.4.1

libraries/libexosphere/include/exosphere/log.hpp

@@ -35,6 +35,7 @@ namespace ams::log {
     #endif
 
     void Initialize();
+    void Initialize(uart::Port port, u32 baud_rate, u32 flags);
     void Finalize();
 
     void Printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));

libraries/libexosphere/include/exosphere/secmon/secmon_configuration_context.arch.arm64.hpp

@@ -116,6 +116,18 @@ namespace ams::secmon {
         return GetSecmonConfiguration().GetLcdVendor();
     }
 
+    ALWAYS_INLINE uart::Port GetLogPort() {
+        return GetSecmonConfiguration().GetLogPort();
+    }
+
+    ALWAYS_INLINE u8 GetLogFlags() {
+        return GetSecmonConfiguration().GetLogFlags();
+    }
+
+    ALWAYS_INLINE u32 GetLogBaudRate() {
+        return GetSecmonConfiguration().GetLogBaudRate();
+    }
+
     ALWAYS_INLINE bool IsProduction() {
         return GetSecmonConfiguration().IsProduction();
     }

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

@@ -16,6 +16,7 @@
 #pragma once
 #include <vapours.hpp>
 #include <exosphere/fuse.hpp>
+#include <exosphere/uart.hpp>
 #include <exosphere/secmon/secmon_emummc_context.hpp>
 
 namespace ams::secmon {
@@ -39,8 +40,10 @@ namespace ams::secmon {
         ams::TargetFirmware target_firmware;
         u32 flags[2];
         u16 lcd_vendor;
-        u16 reserved0;
-        u32 reserved1[3];
+        u8  log_port;
+        u8  log_flags;
+        u32 log_baud_rate;
+        u32 reserved1[2];
         EmummcConfiguration emummc_cfg;
 
         constexpr bool IsValid() const { return this->magic == Magic; }
@@ -54,17 +57,22 @@ namespace ams::secmon {
         u8  hardware_type;
         u8  soc_type;
         u8  hardware_state;
-        u8  pad_0B[1];
+        u8  log_port;
         u32 flags[2];
         u16 lcd_vendor;
-        u16 reserved0;
-        u32 reserved1[(0x80 - 0x18) / sizeof(u32)];
+        u8  log_flags;
+        u8  reserved0;
+        u32 log_baud_rate;
+        u32 reserved1[(0x80 - 0x1C) / sizeof(u32)];
 
         constexpr void CopyFrom(const SecureMonitorStorageConfiguration &storage) {
             this->target_firmware = storage.target_firmware;
             this->flags[0]        = storage.flags[0];
             this->flags[1]        = storage.flags[1];
             this->lcd_vendor      = storage.lcd_vendor;
+            this->log_port        = storage.log_port;
+            this->log_flags       = storage.log_flags;
+            this->log_baud_rate   = storage.log_baud_rate != 0 ? storage.log_baud_rate : 115200;
         }
 
         void SetFuseInfo() {
@@ -78,9 +86,13 @@ namespace ams::secmon {
         constexpr fuse::HardwareType  GetHardwareType()  const { return static_cast<fuse::HardwareType>(this->hardware_type); }
         constexpr fuse::SocType       GetSocType()       const { return static_cast<fuse::SocType>(this->soc_type); }
         constexpr fuse::HardwareState GetHardwareState() const { return static_cast<fuse::HardwareState>(this->hardware_state); }
+        constexpr uart::Port GetLogPort() const { return static_cast<uart::Port>(this->log_port); }
+        constexpr u8 GetLogFlags() const { return this->log_flags; }
 
         constexpr u16 GetLcdVendor() const { return this->lcd_vendor; }
 
+        constexpr u32 GetLogBaudRate() const { return this->log_baud_rate; }
+
         constexpr bool IsProduction() const { return this->GetHardwareState() != fuse::HardwareState_Development; }
 
         constexpr bool IsDevelopmentFunctionEnabledForKernel()  const { return (this->flags[0] & SecureMonitorConfigurationFlag_IsDevelopmentFunctionEnabledForKernel)  != 0; }
@@ -101,10 +113,12 @@ namespace ams::secmon {
         .hardware_type   = {},
         .soc_type        = {},
         .hardware_state  = {},
-        .pad_0B          = {},
+        .log_port        = uart::Port_ReservedDebug,
         .flags           = { SecureMonitorConfigurationFlag_Default, SecureMonitorConfigurationFlag_None },
         .lcd_vendor      = {},
+        .log_flags       = {},
         .reserved0       = {},
+        .log_baud_rate   = 115200,
         .reserved1       = {},
     };
 

libraries/libexosphere/source/log/log_api.cpp

@@ -19,58 +19,46 @@ namespace ams::log {
 
     namespace {
 
-        constexpr inline uart::Port UartLogPort = uart::Port_ReservedDebug;
-        constexpr inline int UartBaudRate = 115200;
+        constexpr inline uart::Port DefaultLogPort = uart::Port_ReservedDebug;
+        constexpr inline u32 DefaultLogFlags = static_cast<u32>(uart::Flag_None);
+        constexpr inline int DefaultBaudRate = 115200;
+        constinit uart::Port g_log_port   = DefaultLogPort;
         constinit bool g_initialized_uart = false;
 
-        constexpr inline u32 UartPortFlags = [] {
-            if constexpr (UartLogPort == uart::Port_ReservedDebug) {
-                /* Logging to the debug port. */
-                /* Don't invert transactions. */
-                return uart::Flag_None;
-            } else if constexpr (UartLogPort == uart::Port_LeftJoyCon) {
-                /* Logging to left joy-con (e.g. with Joyless). */
-                /* Invert transactions. */
-                return uart::Flag_Inverted;
-            } else if constexpr (UartLogPort == uart::Port_RightJoyCon) {
-                /* Logging to right joy-con (e.g. with Joyless). */
-                /* Invert transactions. */
-                return uart::Flag_Inverted;
-            } else {
-                __builtin_unreachable();
-            }
-        }();
+        ALWAYS_INLINE void SetupUartClock(uart::Port port) {
+            /* The debug port must always be set up, for compatibility with official hos. */
+            pinmux::SetupUartA();
+            clkrst::EnableUartAClock();
 
-        ALWAYS_INLINE void SetupUart() {
-            if constexpr (UartLogPort == uart::Port_ReservedDebug) {
-                /* Logging to the debug port. */
-                pinmux::SetupUartA();
-                clkrst::EnableUartAClock();
-            } else if constexpr (UartLogPort == uart::Port_LeftJoyCon) {
+            /* If logging to a joy-con port, configure appropriately. */
+            if (port == uart::Port_LeftJoyCon) {
                 /* Logging to left 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) {
+            } else if (port == 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();
             }
         }
 
     }
 
     void Initialize() {
+        return Initialize(DefaultLogPort, DefaultBaudRate, DefaultLogFlags);
+    }
+
+    void Initialize(uart::Port port, u32 baud_rate, u32 flags) {
         /* Initialize pinmux and clock for the target uart port. */
-        SetupUart();
+        SetupUartClock(port);
 
         /* Initialize the target uart port. */
-        uart::Initialize(UartLogPort, UartBaudRate, UartPortFlags);
+        uart::Initialize(port, baud_rate, flags);
 
         /* Note that we've initialized. */
+        g_log_port        = port;
         g_initialized_uart = true;
     }
 
@@ -84,7 +72,7 @@ namespace ams::log {
         const auto len = util::TVSNPrintf(log_buf, sizeof(log_buf), fmt, vl);
 
         if (g_initialized_uart) {
-            uart::SendText(UartLogPort, log_buf, len);
+            uart::SendText(g_log_port, log_buf, len);
         }
     }
 
@@ -115,13 +103,13 @@ namespace ams::log {
 
     void SendText(const void *text, size_t size) {
         if (g_initialized_uart) {
-            uart::SendText(UartLogPort, text, size);
+            uart::SendText(g_log_port, text, size);
         }
     }
 
     void Flush() {
         if (g_initialized_uart) {
-            uart::WaitFlush(UartLogPort);
+            uart::WaitFlush(g_log_port);
         }
     }
 

libraries/libmesosphere/include/mesosphere.hpp

@@ -54,6 +54,7 @@
 #include <mesosphere/kern_kernel.hpp>
 #include <mesosphere/kern_k_page_table_manager.hpp>
 #include <mesosphere/kern_select_page_table.hpp>
+#include <mesosphere/kern_k_dump_object.hpp>
 
 /* Miscellaneous objects. */
 #include <mesosphere/kern_k_shared_memory_info.hpp>

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

@@ -44,6 +44,9 @@ namespace ams::kern::arch::arm64 {
             static uintptr_t GetProgramCounter(const KThread &thread);
             static void SetPreviousProgramCounter();
 
+            static void PrintRegister(KThread *thread = nullptr);
+            static void PrintBacktrace(KThread *thread = nullptr);
+
             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);
 
@@ -61,8 +64,6 @@ namespace ams::kern::arch::arm64 {
                     }
                 }
             }
-
-            /* TODO: This is a placeholder definition. */
     };
 
 }

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

@@ -112,6 +112,7 @@ namespace ams::kern::arch::arm64 {
             L1PageTableEntry *Finalize();
 
             void Dump(uintptr_t start, size_t size) const;
+            size_t CountPageTables() 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

@@ -232,14 +232,18 @@ namespace ams::kern::arch::arm64 {
                 return this->page_table.UnmapPhysicalMemoryUnsafe(address, size);
             }
 
-            void DumpTable() const {
-                return this->page_table.DumpTable();
-            }
-
             void DumpMemoryBlocks() const {
                 return this->page_table.DumpMemoryBlocks();
             }
 
+            void DumpPageTable() const {
+                return this->page_table.DumpPageTable();
+            }
+
+            size_t CountPageTables() const {
+                return this->page_table.CountPageTables();
+            }
+
             bool GetPhysicalAddress(KPhysicalAddress *out, KProcessAddress address) const {
                 return this->page_table.GetPhysicalAddress(out, address);
             }
@@ -267,12 +271,22 @@ namespace ams::kern::arch::arm64 {
 
             size_t GetNormalMemorySize() const { return this->page_table.GetNormalMemorySize(); }
 
+            size_t GetCodeSize() const { return this->page_table.GetCodeSize(); }
+            size_t GetCodeDataSize() const { return this->page_table.GetCodeDataSize(); }
+
+            size_t GetAliasCodeSize() const { return this->page_table.GetAliasCodeSize(); }
+            size_t GetAliasCodeDataSize() const { return this->page_table.GetAliasCodeDataSize(); }
+
             u32 GetAllocateOption() const { return this->page_table.GetAllocateOption(); }
 
             KPhysicalAddress GetHeapPhysicalAddress(KVirtualAddress address) const {
                 return this->page_table.GetHeapPhysicalAddress(address);
             }
 
+            KVirtualAddress GetHeapVirtualAddress(KPhysicalAddress address) const {
+                return this->page_table.GetHeapVirtualAddress(address);
+            }
+
             KBlockInfoManager *GetBlockInfoManager() {
                 return this->page_table.GetBlockInfoManager();
             }

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

@@ -62,6 +62,18 @@ namespace ams::kern::arch::arm64 {
             }
 
             constexpr u64 GetIdentityMapTtbr0(s32 core_id) const { return this->ttbr0_identity[core_id]; }
+
+            void DumpMemoryBlocks() const {
+                return this->page_table.DumpMemoryBlocks();
+            }
+
+            void DumpPageTable() const {
+                return this->page_table.DumpPageTable();
+            }
+
+            size_t CountPageTables() const {
+                return this->page_table.CountPageTables();
+            }
     };
 
 }

libraries/libmesosphere/include/mesosphere/board/nintendo/nx/kern_k_system_control.hpp

@@ -30,6 +30,7 @@ namespace ams::kern::board::nintendo::nx {
                     static size_t GetApplicationPoolSize();
                     static size_t GetAppletPoolSize();
                     static size_t GetMinimumNonSecureSystemPoolSize();
+                    static u8 GetDebugLogUartPort();
 
                     /* Randomness. */
                     static void GenerateRandomBytes(void *dst, size_t size);

libraries/libmesosphere/include/mesosphere/kern_build_config.hpp

@@ -26,6 +26,7 @@
 #ifdef  MESOSPHERE_BUILD_FOR_DEBUGGING
 #define MESOSPHERE_ENABLE_ASSERTIONS
 #define MESOSPHERE_ENABLE_DEBUG_PRINT
+#define MESOSPHERE_ENABLE_KERNEL_STACK_USAGE
 #endif
 
 //#define MESOSPHERE_BUILD_FOR_TRACING

libraries/libmesosphere/include/mesosphere/kern_debug_log.hpp

@@ -40,7 +40,7 @@ namespace ams::kern {
 #ifndef MESOSPHERE_DEBUG_LOG_SELECTED
 
     #ifdef ATMOSPHERE_BOARD_NINTENDO_NX
-        #define MESOSPHERE_DEBUG_LOG_USE_UART_A
+        #define MESOSPHERE_DEBUG_LOG_USE_UART
     #else
         #error "Unknown board for Default Debug Log Source"
     #endif

libraries/libmesosphere/include/mesosphere/kern_k_client_port.hpp

@@ -42,6 +42,10 @@ namespace ams::kern {
 
             constexpr const KPort *GetParent() const { return this->parent; }
 
+            ALWAYS_INLINE s32 GetNumSessions()  const { return this->num_sessions; }
+            ALWAYS_INLINE s32 GetPeakSessions() const { return this->peak_sessions; }
+            ALWAYS_INLINE s32 GetMaxSessions()  const { return this->max_sessions; }
+
             bool IsLight() const;
 
             /* Overridden virtual functions. */

libraries/libmesosphere/include/mesosphere/kern_k_dump_object.hpp

@@ -0,0 +1,43 @@
+/*
+ * 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 <mesosphere/kern_common.hpp>
+#include <mesosphere/kern_select_cpu.hpp>
+
+namespace ams::kern::KDumpObject {
+
+    void DumpThread();
+    void DumpThread(u64 thread_id);
+
+    void DumpThreadCallStack();
+    void DumpThreadCallStack(u64 thread_id);
+
+    void DumpKernelObject();
+
+    void DumpHandle();
+    void DumpHandle(u64 process_id);
+
+    void DumpKernelMemory();
+    void DumpMemory();
+    void DumpMemory(u64 process_id);
+
+    void DumpProcess();
+    void DumpProcess(u64 process_id);
+
+    void DumpPort();
+    void DumpPort(u64 process_id);
+
+}

libraries/libmesosphere/include/mesosphere/kern_k_memory_manager.hpp

@@ -90,6 +90,8 @@ namespace ams::kern {
 
                     size_t GetFreeSize() const { return this->heap.GetFreeSize(); }
 
+                    void DumpFreeList() const { return this->heap.DumpFreeList(); }
+
                     constexpr size_t GetPageOffset(KVirtualAddress address)      const { return this->heap.GetPageOffset(address); }
                     constexpr size_t GetPageOffsetToEnd(KVirtualAddress address) const { return this->heap.GetPageOffsetToEnd(address); }
 
@@ -247,12 +249,15 @@ namespace ams::kern {
             size_t GetFreeSize() {
                 size_t total = 0;
                 for (size_t i = 0; i < this->num_managers; i++) {
+                    KScopedLightLock lk(this->pool_locks[this->managers[i].GetPool()]);
                     total += this->managers[i].GetFreeSize();
                 }
                 return total;
             }
 
             size_t GetFreeSize(Pool pool) {
+                KScopedLightLock lk(this->pool_locks[pool]);
+
                 constexpr Direction GetSizeDirection = Direction_FromFront;
                 size_t total = 0;
                 for (auto *manager = this->GetFirstManager(pool, GetSizeDirection); manager != nullptr; manager = this->GetNextManager(manager, GetSizeDirection)) {
@@ -260,6 +265,15 @@ namespace ams::kern {
                 }
                 return total;
             }
+
+            void DumpFreeList(Pool pool) {
+                KScopedLightLock lk(this->pool_locks[pool]);
+
+                constexpr Direction DumpDirection = Direction_FromFront;
+                for (auto *manager = this->GetFirstManager(pool, DumpDirection); manager != nullptr; manager = this->GetNextManager(manager, DumpDirection)) {
+                    manager->DumpFreeList();
+                }
+            }
         public:
             static size_t CalculateManagementOverheadSize(size_t region_size) {
                 return Impl::CalculateManagementOverheadSize(region_size);

libraries/libmesosphere/include/mesosphere/kern_k_page_heap.hpp

@@ -147,6 +147,7 @@ namespace ams::kern {
             }
 
             size_t GetFreeSize() const { return this->GetNumFreePages() * PageSize; }
+            void DumpFreeList() const;
 
             void UpdateUsedSize() {
                 this->used_size = this->heap_size - (this->GetNumFreePages() * PageSize);

libraries/libmesosphere/include/mesosphere/kern_k_page_table_base.hpp

@@ -301,6 +301,8 @@ namespace ams::kern {
             Result SetupForIpcClient(PageLinkedList *page_list, size_t *out_blocks_needed, KProcessAddress address, size_t size, KMemoryPermission test_perm, KMemoryState dst_state);
             Result SetupForIpcServer(KProcessAddress *out_addr, size_t size, KProcessAddress src_addr, KMemoryPermission test_perm, KMemoryState dst_state, KPageTableBase &src_page_table, bool send);
             void CleanupForIpcClientOnServerSetupFailure(PageLinkedList *page_list, KProcessAddress address, size_t size, KMemoryPermission prot_perm);
+
+            size_t GetSize(KMemoryState state) const;
         public:
             bool GetPhysicalAddress(KPhysicalAddress *out, KProcessAddress virt_addr) const {
                 return this->GetImpl().GetPhysicalAddress(out, virt_addr);
@@ -382,9 +384,9 @@ namespace ams::kern {
             Result MapPhysicalMemoryUnsafe(KProcessAddress address, size_t size);
             Result UnmapPhysicalMemoryUnsafe(KProcessAddress address, size_t size);
 
-            void DumpTable() const {
-                KScopedLightLock lk(this->general_lock);
-                this->GetImpl().Dump(GetInteger(this->address_space_start), this->address_space_end - this->address_space_start);
+            void DumpMemoryBlocksLocked() const {
+                MESOSPHERE_ASSERT(this->IsLockedByCurrentThread());
+                this->memory_block_manager.DumpBlocks();
             }
 
             void DumpMemoryBlocks() const {
@@ -392,9 +394,14 @@ namespace ams::kern {
                 this->DumpMemoryBlocksLocked();
             }
 
-            void DumpMemoryBlocksLocked() const {
-                MESOSPHERE_ASSERT(this->IsLockedByCurrentThread());
-                this->memory_block_manager.DumpBlocks();
+            void DumpPageTable() const {
+                KScopedLightLock lk(this->general_lock);
+                this->GetImpl().Dump(GetInteger(this->address_space_start), this->address_space_end - this->address_space_start);
+            }
+
+            size_t CountPageTables() const {
+                KScopedLightLock lk(this->general_lock);
+                return this->GetImpl().CountPageTables();
             }
         public:
             KProcessAddress GetAddressSpaceStart()    const { return this->address_space_start; }
@@ -418,6 +425,11 @@ namespace ams::kern {
                 return (this->current_heap_end - this->heap_region_start) + this->mapped_physical_memory_size;
             }
 
+            size_t GetCodeSize() const;
+            size_t GetCodeDataSize() const;
+            size_t GetAliasCodeSize() const;
+            size_t GetAliasCodeDataSize() const;
+
             u32 GetAllocateOption() const { return this->allocate_option; }
         public:
             static ALWAYS_INLINE KVirtualAddress GetLinearMappedVirtualAddress(KPhysicalAddress addr) {

libraries/libmesosphere/include/mesosphere/kern_k_process.hpp

@@ -170,6 +170,8 @@ namespace ams::kern {
 
             constexpr KProcessAddress GetEntryPoint() const { return this->code_address; }
 
+            constexpr size_t GetMainStackSize() const { return this->main_thread_stack_size; }
+
             constexpr KMemoryManager::Pool GetMemoryPool() const { return this->memory_pool; }
 
             constexpr u64 GetRandomEntropy(size_t i) const { return this->entropy[i]; }
@@ -305,6 +307,11 @@ namespace ams::kern {
                 }
             }
 
+            const KDynamicPageManager &GetDynamicPageManager() const { return this->dynamic_page_manager; }
+            const KMemoryBlockSlabManager &GetMemoryBlockSlabManager() const { return this->memory_block_slab_manager; }
+            const KBlockInfoManager &GetBlockInfoManager() const { return this->block_info_manager; }
+            const KPageTableManager &GetPageTableManager() const { return this->page_table_manager; }
+
             constexpr KThread *GetRunningThread(s32 core) const { return this->running_threads[core]; }
             constexpr u64 GetRunningThreadIdleCount(s32 core) const { return this->running_thread_idle_counts[core]; }
 

libraries/libmesosphere/include/mesosphere/kern_k_server_session.hpp

@@ -50,6 +50,8 @@ namespace ams::kern {
             Result SendReply(uintptr_t message, uintptr_t buffer_size, KPhysicalAddress message_paddr);
 
             void OnClientClosed();
+
+            void Dump();
         private:
             bool IsSignaledImpl() const;
             void CleanupRequests();

libraries/libmesosphere/include/mesosphere/kern_k_session.hpp

@@ -71,6 +71,8 @@ namespace ams::kern {
             KServerSession &GetServerSession() { return this->server; }
             const KClientSession &GetClientSession() const { return this->client; }
             const KServerSession &GetServerSession() const { return this->server; }
+
+            const KClientPort *GetParent() const { return this->port; }
     };
 
 }

libraries/libmesosphere/include/mesosphere/kern_k_slab_heap.hpp

@@ -140,7 +140,21 @@ namespace ams::kern {
 
                 void *obj = this->GetImpl()->Allocate();
 
-                /* TODO: under some debug define, track the peak for statistics, as N does? */
+                /* Track the allocated peak. */
+                #if defined(MESOSPHERE_BUILD_FOR_DEBUGGING)
+                if (AMS_LIKELY(obj != nullptr)) {
+                    static_assert(std::atomic_ref<uintptr_t>::is_always_lock_free);
+                    std::atomic_ref<uintptr_t> peak_ref(this->peak);
+
+                    const uintptr_t alloc_peak = reinterpret_cast<uintptr_t>(obj) + this->GetObjectSize();
+                    uintptr_t cur_peak = this->peak;
+                    do {
+                        if (alloc_peak <= cur_peak) {
+                            break;
+                        }
+                    } while (!peak_ref.compare_exchange_strong(cur_peak, alloc_peak));
+                }
+                #endif
 
                 return obj;
             }
@@ -165,6 +179,29 @@ namespace ams::kern {
             uintptr_t GetSlabHeapAddress() const {
                 return this->start;
             }
+
+            size_t GetNumRemaining() const {
+                size_t remaining = 0;
+
+                /* Only calculate the number of remaining objects under debug configuration. */
+                #if defined(MESOSPHERE_BUILD_FOR_DEBUGGING)
+                while (true) {
+                    auto *cur = this->GetImpl()->GetHead();
+                    remaining = 0;
+
+                    while (this->Contains(reinterpret_cast<uintptr_t>(cur))) {
+                        ++remaining;
+                        cur = cur->next;
+                    }
+
+                    if (cur == nullptr) {
+                        break;
+                    }
+                }
+                #endif
+
+                return remaining;
+            }
     };
 
     template<typename T>

libraries/libmesosphere/include/mesosphere/kern_k_synchronization_object.hpp

@@ -30,9 +30,10 @@ namespace ams::kern {
                 KThread *thread;
             };
         private:
-            ThreadListNode *thread_list_root;
+            ThreadListNode *thread_list_head;
+            ThreadListNode *thread_list_tail;
         protected:
-            constexpr ALWAYS_INLINE explicit KSynchronizationObject() : KAutoObjectWithList(), thread_list_root() { MESOSPHERE_ASSERT_THIS(); }
+            constexpr ALWAYS_INLINE explicit KSynchronizationObject() : KAutoObjectWithList(), thread_list_head(), thread_list_tail() { MESOSPHERE_ASSERT_THIS(); }
             virtual ~KSynchronizationObject() { MESOSPHERE_ASSERT_THIS(); }
 
             virtual void OnFinalizeSynchronizationObject() { MESOSPHERE_ASSERT_THIS(); }
@@ -46,7 +47,7 @@ namespace ams::kern {
         public:
             virtual void Finalize() override;
             virtual bool IsSignaled() const = 0;
-            virtual void DebugWaiters();
+            virtual void DumpWaiters();
     };
 
 }

libraries/libmesosphere/include/mesosphere/kern_k_thread.hpp

@@ -49,11 +49,11 @@ namespace ams::kern {
             };
 
             enum SuspendType : u32 {
-                SuspendType_Process = 0,
-                SuspendType_Thread  = 1,
-                SuspendType_Debug   = 2,
-                SuspendType_Unk3    = 3,
-                SuspendType_Init    = 4,
+                SuspendType_Process   = 0,
+                SuspendType_Thread    = 1,
+                SuspendType_Debug     = 2,
+                SuspendType_Backtrace = 3,
+                SuspendType_Init      = 4,
 
                 SuspendType_Count,
             };
@@ -67,13 +67,13 @@ namespace ams::kern {
                 ThreadState_SuspendShift = 4,
                 ThreadState_Mask         = (1 << ThreadState_SuspendShift) - 1,
 
-                ThreadState_ProcessSuspended = (1 << (SuspendType_Process + ThreadState_SuspendShift)),
-                ThreadState_ThreadSuspended  = (1 << (SuspendType_Thread  + ThreadState_SuspendShift)),
-                ThreadState_DebugSuspended   = (1 << (SuspendType_Debug   + ThreadState_SuspendShift)),
-                ThreadState_Unk3Suspended    = (1 << (SuspendType_Unk3    + ThreadState_SuspendShift)),
-                ThreadState_InitSuspended    = (1 << (SuspendType_Init    + ThreadState_SuspendShift)),
+                ThreadState_ProcessSuspended   = (1 << (SuspendType_Process   + ThreadState_SuspendShift)),
+                ThreadState_ThreadSuspended    = (1 << (SuspendType_Thread    + ThreadState_SuspendShift)),
+                ThreadState_DebugSuspended     = (1 << (SuspendType_Debug     + ThreadState_SuspendShift)),
+                ThreadState_BacktraceSuspended = (1 << (SuspendType_Backtrace + ThreadState_SuspendShift)),
+                ThreadState_InitSuspended      = (1 << (SuspendType_Init      + ThreadState_SuspendShift)),
 
-                ThreadState_SuspendFlagMask  = ((1 << SuspendType_Count) - 1) << ThreadState_SuspendShift,
+                ThreadState_SuspendFlagMask    = ((1 << SuspendType_Count) - 1) << ThreadState_SuspendShift,
             };
 
             enum DpcFlag : u32 {
@@ -533,6 +533,7 @@ namespace ams::kern {
                 return this->termination_requested || this->GetRawState() == ThreadState_Terminated;
             }
 
+            size_t GetKernelStackUsage() const;
         public:
             /* Overridden parent functions. */
             virtual u64 GetId() const override final { return this->GetThreadId(); }

libraries/libmesosphere/include/mesosphere/kern_slab_helpers.hpp

@@ -48,6 +48,8 @@ namespace ams::kern {
             static size_t GetSlabHeapSize() { return s_slab_heap.GetSlabHeapSize(); }
             static size_t GetPeakIndex() { return s_slab_heap.GetPeakIndex(); }
             static uintptr_t GetSlabHeapAddress() { return s_slab_heap.GetSlabHeapAddress(); }
+
+            static size_t GetNumRemaining() { return s_slab_heap.GetNumRemaining(); }
     };
 
     template<typename Derived, typename Base>
@@ -92,7 +94,7 @@ namespace ams::kern {
             virtual uintptr_t GetPostDestroyArgument() const { return 0; }
 
             size_t GetSlabIndex() const {
-                return s_slab_heap.GetIndex(static_cast<const Derived *>(this));
+                return s_slab_heap.GetObjectIndex(static_cast<const Derived *>(this));
             }
         public:
             static void InitializeSlabHeap(void *memory, size_t memory_size) {
@@ -116,6 +118,8 @@ namespace ams::kern {
             static size_t GetSlabHeapSize() { return s_slab_heap.GetSlabHeapSize(); }
             static size_t GetPeakIndex() { return s_slab_heap.GetPeakIndex(); }
             static uintptr_t GetSlabHeapAddress() { return s_slab_heap.GetSlabHeapAddress(); }
+
+            static size_t GetNumRemaining() { return s_slab_heap.GetNumRemaining(); }
     };
 
 }

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

@@ -384,4 +384,541 @@ namespace ams::kern::arch::arm64 {
     #undef MESOSPHERE_SET_HW_WATCH_POINT
     #undef MESOSPHERE_SET_HW_BREAK_POINT
 
+    void KDebug::PrintRegister(KThread *thread) {
+        #if defined(MESOSPHERE_BUILD_FOR_DEBUGGING)
+        {
+            /* Treat no thread as current thread. */
+            if (thread == nullptr) {
+                thread = GetCurrentThreadPointer();
+            }
+
+            /* Get the exception context. */
+            KExceptionContext *e_ctx = GetExceptionContext(thread);
+
+            /* Get the owner process. */
+            if (auto *process = thread->GetOwnerProcess(); process != nullptr) {
+                /* Lock the owner process. */
+                KScopedLightLock state_lk(process->GetStateLock());
+                KScopedLightLock list_lk(process->GetListLock());
+
+                /* Suspend all the process's threads. */
+                {
+                    KScopedSchedulerLock sl;
+
+                    auto end = process->GetThreadList().end();
+                    for (auto it = process->GetThreadList().begin(); it != end; ++it) {
+                        if (std::addressof(*it) != GetCurrentThreadPointer()) {
+                            it->RequestSuspend(KThread::SuspendType_Backtrace);
+                        }
+                    }
+                }
+
+                /* Print the registers. */
+                MESOSPHERE_RELEASE_LOG("Registers\n");
+                if ((e_ctx->psr & 0x10) == 0) {
+                    /* 64-bit thread. */
+                    for (auto i = 0; i < 31; ++i) {
+                        MESOSPHERE_RELEASE_LOG("   X[%2d]:     0x%016lx\n", i, e_ctx->x[i]);
+                    }
+                    MESOSPHERE_RELEASE_LOG("   SP:        0x%016lx\n", e_ctx->sp);
+                    MESOSPHERE_RELEASE_LOG("   PC:        0x%016lx\n", e_ctx->pc - sizeof(u32));
+                    MESOSPHERE_RELEASE_LOG("   PSR:       0x%08x\n", e_ctx->psr);
+                    MESOSPHERE_RELEASE_LOG("   TPIDR_EL0: 0x%016lx\n", e_ctx->tpidr);
+                } else {
+                    /* 32-bit thread. */
+                    for (auto i = 0; i < 13; ++i) {
+                        MESOSPHERE_RELEASE_LOG("   R[%2d]: 0x%08x\n", i, static_cast<u32>(e_ctx->x[i]));
+                    }
+                    MESOSPHERE_RELEASE_LOG("   SP:    0x%08x\n", static_cast<u32>(e_ctx->x[13]));
+                    MESOSPHERE_RELEASE_LOG("   LR:    0x%08x\n", static_cast<u32>(e_ctx->x[14]));
+                    MESOSPHERE_RELEASE_LOG("   PC:    0x%08x\n", static_cast<u32>(e_ctx->pc) - static_cast<u32>((e_ctx->psr & 0x20) ? sizeof(u16) : sizeof(u32)));
+                    MESOSPHERE_RELEASE_LOG("   PSR:   0x%08x\n", e_ctx->psr);
+                    MESOSPHERE_RELEASE_LOG("   TPIDR: 0x%08x\n", static_cast<u32>(e_ctx->tpidr));
+                }
+
+                /* Resume the threads that we suspended. */
+                {
+                    KScopedSchedulerLock sl;
+
+                    auto end = process->GetThreadList().end();
+                    for (auto it = process->GetThreadList().begin(); it != end; ++it) {
+                        if (std::addressof(*it) != GetCurrentThreadPointer()) {
+                            it->Resume(KThread::SuspendType_Backtrace);
+                        }
+                    }
+                }
+            }
+        }
+        #else
+            MESOSPHERE_UNUSED(thread);
+        #endif
+    }
+
+    #if defined(MESOSPHERE_BUILD_FOR_DEBUGGING)
+    namespace {
+
+        bool IsHeapPhysicalAddress(KPhysicalAddress phys_addr) {
+            const KMemoryRegion *cached = nullptr;
+            return KMemoryLayout::IsHeapPhysicalAddress(cached, phys_addr);
+        }
+
+        template<typename T>
+        bool ReadValue(T *out, KProcess *process, uintptr_t address) {
+            KPhysicalAddress   phys_addr;
+            KMemoryInfo        mem_info;
+            ams::svc::PageInfo page_info;
+
+            if (!util::IsAligned(address, sizeof(T))) {
+                return false;
+            }
+            if (R_FAILED(process->GetPageTable().QueryInfo(std::addressof(mem_info), std::addressof(page_info), address))) {
+                return false;
+            }
+            if ((mem_info.GetPermission() & KMemoryPermission_UserRead) != KMemoryPermission_UserRead) {
+                return false;
+            }
+            if (!process->GetPageTable().GetPhysicalAddress(std::addressof(phys_addr), address)) {
+                return false;
+            }
+            if (!IsHeapPhysicalAddress(phys_addr)) {
+                return false;
+            }
+
+            *out = *GetPointer<T>(process->GetPageTable().GetHeapVirtualAddress(phys_addr));
+            return true;
+        }
+
+        bool GetModuleName(char *dst, size_t dst_size, KProcess *process, uintptr_t base_address) {
+            /* Locate .rodata. */
+            KMemoryInfo        mem_info;
+            ams::svc::PageInfo page_info;
+            KMemoryState       mem_state = KMemoryState_None;
+
+            while (true) {
+                if (R_FAILED(process->GetPageTable().QueryInfo(std::addressof(mem_info), std::addressof(page_info), base_address))) {
+                    return false;
+                }
+                if (mem_state == KMemoryState_None) {
+                    mem_state = mem_info.GetState();
+                    if (mem_state != KMemoryState_Code && mem_state != KMemoryState_AliasCode) {
+                        return false;
+                    }
+                }
+                if (mem_info.GetState() != mem_state) {
+                    return false;
+                }
+                if (mem_info.GetPermission() == KMemoryPermission_UserRead) {
+                    break;
+                }
+                base_address = mem_info.GetEndAddress();
+            }
+
+            /* Check that first value is 0. */
+            u32 val;
+            if (!ReadValue(std::addressof(val), process, base_address)) {
+                return false;
+            }
+            if (val != 0) {
+                return false;
+            }
+
+            /* Read the name length. */
+            if (!ReadValue(std::addressof(val), process, base_address + sizeof(u32))) {
+                return false;
+            }
+            if (!(0 < val && val < dst_size)) {
+                return false;
+            }
+            const size_t name_len = val;
+
+            /* Read the name, one character at a time. */
+            for (size_t i = 0; i < name_len; ++i) {
+                if (!ReadValue(dst + i, process, base_address + 2 * sizeof(u32) + i)) {
+                    return false;
+                }
+                if (!(0 < dst[i] && dst[i] <= 0x7F)) {
+                    return false;
+                }
+            }
+
+            /* NULL-terminate. */
+            dst[name_len] = 0;
+
+            return true;
+        }
+
+        void PrintAddress(uintptr_t address) {
+            MESOSPHERE_RELEASE_LOG("   %p\n", reinterpret_cast<void *>(address));
+        }
+
+        void PrintAddressWithModuleName(uintptr_t address, bool has_module_name, const char *module_name, uintptr_t base_address) {
+            if (has_module_name) {
+                MESOSPHERE_RELEASE_LOG("   %p [%10s + %8lx]\n", reinterpret_cast<void *>(address), module_name, address - base_address);
+            } else {
+                MESOSPHERE_RELEASE_LOG("   %p [%10lx + %8lx]\n", reinterpret_cast<void *>(address), base_address, address - base_address);
+            }
+        }
+
+        void PrintAddressWithSymbol(uintptr_t address, bool has_module_name, const char *module_name, uintptr_t base_address, const char *symbol_name, uintptr_t func_address) {
+            if (has_module_name) {
+                MESOSPHERE_RELEASE_LOG("   %p [%10s + %8lx] (%s + %lx)\n", reinterpret_cast<void *>(address), module_name, address - base_address, symbol_name, address - func_address);
+            } else {
+                MESOSPHERE_RELEASE_LOG("   %p [%10lx + %8lx] (%s + %lx)\n", reinterpret_cast<void *>(address), base_address, address - base_address, symbol_name, address - func_address);
+            }
+        }
+
+        void PrintCodeAddress(KProcess *process, uintptr_t address, bool is_lr = true) {
+            /* Prepare to parse + print the address. */
+            uintptr_t          test_address = is_lr ? address - sizeof(u32) : address;
+            uintptr_t          base_address = address;
+            uintptr_t          dyn_address  = 0;
+            uintptr_t          sym_tab      = 0;
+            uintptr_t          str_tab      = 0;
+            size_t             num_sym      = 0;
+
+            u64                temp_64;
+            u32                temp_32;
+
+            /* Locate the start of .text. */
+            KMemoryInfo        mem_info;
+            ams::svc::PageInfo page_info;
+            KMemoryState       mem_state = KMemoryState_None;
+            while (true) {
+                if (R_FAILED(process->GetPageTable().QueryInfo(std::addressof(mem_info), std::addressof(page_info), base_address))) {
+                    return PrintAddress(address);
+                }
+                if (mem_state == KMemoryState_None) {
+                    mem_state = mem_info.GetState();
+                    if (mem_state != KMemoryState_Code && mem_state != KMemoryState_AliasCode) {
+                        return PrintAddress(address);
+                    }
+                } else if (mem_info.GetState() != mem_state) {
+                    return PrintAddress(address);
+                }
+                if (mem_info.GetPermission() != KMemoryPermission_UserReadExecute) {
+                    return PrintAddress(address);
+                }
+                base_address = mem_info.GetAddress();
+
+                if (R_FAILED(process->GetPageTable().QueryInfo(std::addressof(mem_info), std::addressof(page_info), base_address - 1))) {
+                    return PrintAddress(address);
+                }
+                if (mem_info.GetState() != mem_state) {
+                    break;
+                }
+                if (mem_info.GetPermission() != KMemoryPermission_UserReadExecute) {
+                    break;
+                }
+            }
+
+            /* Read the first instruction. */
+            if (!ReadValue(std::addressof(temp_32), process, base_address)) {
+                return PrintAddress(address);
+            }
+
+            /* Get the module name. */
+            char module_name[0x20];
+            const bool has_module_name = GetModuleName(module_name, sizeof(module_name), process, base_address);
+
+            /* If the process is 32-bit, just print the module. */
+            if (!process->Is64Bit()) {
+                return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+            }
+
+            if (temp_32 == 0) {
+                /* Module is dynamically loaded by rtld. */
+                u32 mod_offset;
+                if (!ReadValue(std::addressof(mod_offset), process, base_address + sizeof(u32))) {
+                    return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                }
+                if (!ReadValue(std::addressof(temp_32), process, base_address + mod_offset)) {
+                    return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                }
+                if (temp_32 != 0x30444F4D) { /* MOD0 */
+                    return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                }
+                if (!ReadValue(std::addressof(temp_32), process, base_address + mod_offset + sizeof(u32))) {
+                    return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                }
+                dyn_address = base_address + mod_offset + temp_32;
+            } else if (temp_32 == 0x14000002) {
+                /* Module embeds rtld. */
+                if (!ReadValue(std::addressof(temp_32), process, base_address + 0x5C)) {
+                    return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                }
+                if (temp_32 != 0x94000002) {
+                    return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                }
+                if (!ReadValue(std::addressof(temp_32), process, base_address + 0x60)) {
+                    return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                }
+                dyn_address = base_address + 0x60 + temp_32;
+            } else {
+                return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+            }
+
+            /* Locate tables inside .dyn. */
+            for (size_t ofs = 0; /* ... */; ofs += 0x10) {
+                /* Read the DynamicTag. */
+                if (!ReadValue(std::addressof(temp_64), process, dyn_address + ofs)) {
+                    return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                }
+                if (temp_64 == 0) {
+                    /* We're done parsing .dyn. */
+                    break;
+                } else if (temp_64 == 4) {
+                    /* We found DT_HASH */
+                    if (!ReadValue(std::addressof(temp_64), process, dyn_address + ofs + sizeof(u64))) {
+                        return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                    }
+                    /* Read nchain, to get the number of symbols. */
+                    if (!ReadValue(std::addressof(temp_32), process, base_address + temp_64 + sizeof(u32))) {
+                        return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                    }
+
+                    num_sym = temp_32;
+                } else if (temp_64 == 5) {
+                    /* We found DT_STRTAB */
+                    if (!ReadValue(std::addressof(temp_64), process, dyn_address + ofs + sizeof(u64))) {
+                        return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                    }
+
+                    str_tab = base_address + temp_64;
+                } else if (temp_64 == 6) {
+                    /* We found DT_SYMTAB */
+                    if (!ReadValue(std::addressof(temp_64), process, dyn_address + ofs + sizeof(u64))) {
+                        return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                    }
+
+                    sym_tab = base_address + temp_64;
+                }
+            }
+
+            /* Check that we found all the tables. */
+            if (!(sym_tab != 0 && str_tab != 0 && num_sym != 0)) {
+                return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+            }
+
+            /* Try to locate an appropriate symbol. */
+            for (size_t i = 0; i < num_sym; ++i) {
+                /* Read the symbol from userspace. */
+                struct {
+                    u32 st_name;
+                    u8  st_info;
+                    u8  st_other;
+                    u16 st_shndx;
+                    u64 st_value;
+                    u64 st_size;
+                } sym;
+                {
+                    u64 x[sizeof(sym) / sizeof(u64)];
+                    for (size_t j = 0; j < util::size(x); ++j) {
+                        if (!ReadValue(x + j, process, sym_tab + sizeof(sym) * i + sizeof(u64) * j)) {
+                            return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                        }
+                    }
+                    std::memcpy(std::addressof(sym), x, sizeof(sym));
+                }
+
+                /* Check the symbol is valid/STT_FUNC. */
+                if (sym.st_shndx == 0 || ((sym.st_shndx & 0xFF00) == 0xFF00)) {
+                    continue;
+                }
+                if ((sym.st_info & 0xF) != 2) {
+                    continue;
+                }
+
+                /* Check the address. */
+                const uintptr_t func_start = base_address + sym.st_value;
+                if (func_start <= test_address && test_address < func_start + sym.st_size) {
+                    /* Read the symbol name. */
+                    const uintptr_t sym_address = str_tab + sym.st_name;
+                    char sym_name[0x80];
+                    sym_name[util::size(sym_name) - 1] = 0;
+                    for (size_t j = 0; j < util::size(sym_name) - 1; ++j) {
+                        if (!ReadValue(sym_name + j, process, sym_address + j)) {
+                            return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+                        }
+                        if (sym_name[j] == 0) {
+                            break;
+                        }
+                    }
+
+                    /* Print the symbol. */
+                    return PrintAddressWithSymbol(address, has_module_name, module_name, base_address, sym_name, func_start);
+                }
+            }
+
+            /* Fall back to printing the module. */
+            return PrintAddressWithModuleName(address, has_module_name, module_name, base_address);
+        }
+
+    }
+    #endif
+
+    void KDebug::PrintBacktrace(KThread *thread) {
+        #if defined(MESOSPHERE_BUILD_FOR_DEBUGGING)
+        {
+            /* Treat no thread as current thread. */
+            if (thread == nullptr) {
+                thread = GetCurrentThreadPointer();
+            }
+
+            /* Get the exception context. */
+            KExceptionContext *e_ctx = GetExceptionContext(thread);
+
+            /* Get the owner process. */
+            if (auto *process = thread->GetOwnerProcess(); process != nullptr) {
+                /* Lock the owner process. */
+                KScopedLightLock state_lk(process->GetStateLock());
+                KScopedLightLock list_lk(process->GetListLock());
+
+                /* Suspend all the process's threads. */
+                {
+                    KScopedSchedulerLock sl;
+
+                    auto end = process->GetThreadList().end();
+                    for (auto it = process->GetThreadList().begin(); it != end; ++it) {
+                        if (std::addressof(*it) != GetCurrentThreadPointer()) {
+                            it->RequestSuspend(KThread::SuspendType_Backtrace);
+                        }
+                    }
+                }
+
+                /* Print the backtrace. */
+                MESOSPHERE_RELEASE_LOG("User Backtrace\n");
+                if ((e_ctx->psr & 0x10) == 0) {
+                    /* 64-bit thread. */
+                    PrintCodeAddress(process, e_ctx->pc, false);
+                    PrintCodeAddress(process, e_ctx->x[30]);
+
+                    /* Walk the stack frames. */
+                    uintptr_t fp = static_cast<uintptr_t>(e_ctx->x[29]);
+                    for (auto i = 0; i < 0x20 && fp != 0 && util::IsAligned(fp, 0x10); ++i) {
+                        /* Read the next frame. */
+                        struct {
+                            u64 fp;
+                            u64 lr;
+                        } stack_frame;
+                        {
+                            KMemoryInfo        mem_info;
+                            ams::svc::PageInfo page_info;
+                            KPhysicalAddress   phys_addr;
+
+                            if (R_FAILED(process->GetPageTable().QueryInfo(std::addressof(mem_info), std::addressof(page_info), fp))) {
+                                break;
+                            }
+                            if ((mem_info.GetState() & KMemoryState_FlagReferenceCounted) == 0) {
+                                break;
+                            }
+                            if ((mem_info.GetAttribute() & KMemoryAttribute_Uncached) != 0) {
+                                break;
+                            }
+                            if ((mem_info.GetPermission() & KMemoryPermission_UserRead) != KMemoryPermission_UserRead) {
+                                break;
+                            }
+                            if (!process->GetPageTable().GetPhysicalAddress(std::addressof(phys_addr), fp)) {
+                                break;
+                            }
+                            if (!IsHeapPhysicalAddress(phys_addr)) {
+                                break;
+                            }
+
+                            u64 *frame_ptr = GetPointer<u64>(process->GetPageTable().GetHeapVirtualAddress(phys_addr));
+                            stack_frame.fp = frame_ptr[0];
+                            stack_frame.lr = frame_ptr[1];
+                        }
+
+                        /* Print and advance. */
+                        PrintCodeAddress(process, stack_frame.lr);
+                        fp = stack_frame.fp;
+                    }
+                } else {
+                    /* 32-bit thread. */
+                    PrintCodeAddress(process, e_ctx->pc, false);
+                    PrintCodeAddress(process, e_ctx->x[14]);
+
+                    /* Walk the stack frames. */
+                    uintptr_t fp = static_cast<uintptr_t>(e_ctx->x[11]);
+                    for (auto i = 0; i < 0x20 && fp != 0 && util::IsAligned(fp, 4); ++i) {
+                        /* Read the next frame. */
+                        struct {
+                            u32 fp;
+                            u32 lr;
+                        } stack_frame;
+                        {
+                            KMemoryInfo        mem_info;
+                            ams::svc::PageInfo page_info;
+                            KPhysicalAddress   phys_addr;
+
+                            /* Read FP */
+                            if (R_FAILED(process->GetPageTable().QueryInfo(std::addressof(mem_info), std::addressof(page_info), fp))) {
+                                break;
+                            }
+                            if ((mem_info.GetState() & KMemoryState_FlagReferenceCounted) == 0) {
+                                break;
+                            }
+                            if ((mem_info.GetAttribute() & KMemoryAttribute_Uncached) != 0) {
+                                break;
+                            }
+                            if ((mem_info.GetPermission() & KMemoryPermission_UserRead) != KMemoryPermission_UserRead) {
+                                break;
+                            }
+                            if (!process->GetPageTable().GetPhysicalAddress(std::addressof(phys_addr), fp)) {
+                                break;
+                            }
+                            if (!IsHeapPhysicalAddress(phys_addr)) {
+                                break;
+                            }
+
+                            stack_frame.fp = *GetPointer<u32>(process->GetPageTable().GetHeapVirtualAddress(phys_addr));
+
+                            /* Read LR. */
+                            uintptr_t lr_ptr = (e_ctx->x[13] <= stack_frame.fp && stack_frame.fp < e_ctx->x[13] + PageSize) ? fp + 4 : fp - 4;
+                            if (R_FAILED(process->GetPageTable().QueryInfo(std::addressof(mem_info), std::addressof(page_info), lr_ptr))) {
+                                break;
+                            }
+                            if ((mem_info.GetState() & KMemoryState_FlagReferenceCounted) == 0) {
+                                break;
+                            }
+                            if ((mem_info.GetAttribute() & KMemoryAttribute_Uncached) != 0) {
+                                break;
+                            }
+                            if ((mem_info.GetPermission() & KMemoryPermission_UserRead) != KMemoryPermission_UserRead) {
+                                break;
+                            }
+                            if (!process->GetPageTable().GetPhysicalAddress(std::addressof(phys_addr), lr_ptr)) {
+                                break;
+                            }
+                            if (!IsHeapPhysicalAddress(phys_addr)) {
+                                break;
+                            }
+
+                            stack_frame.lr = *GetPointer<u32>(process->GetPageTable().GetHeapVirtualAddress(phys_addr));
+                        }
+
+                        /* Print and advance. */
+                        PrintCodeAddress(process, stack_frame.lr);
+                        fp = stack_frame.fp;
+                    }
+                }
+
+                /* Resume the threads that we suspended. */
+                {
+                    KScopedSchedulerLock sl;
+
+                    auto end = process->GetThreadList().end();
+                    for (auto it = process->GetThreadList().begin(); it != end; ++it) {
+                        if (std::addressof(*it) != GetCurrentThreadPointer()) {
+                            it->Resume(KThread::SuspendType_Backtrace);
+                        }
+                    }
+                }
+            }
+        }
+        #else
+            MESOSPHERE_UNUSED(thread);
+        #endif
+    }
+
 }

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

@@ -431,5 +431,28 @@ namespace ams::kern::arch::arm64 {
         }
     }
 
+    size_t KPageTableImpl::CountPageTables() const {
+        size_t num_tables = 0;
+
+        #if defined(MESOSPHERE_BUILD_FOR_DEBUGGING)
+        {
+            ++num_tables;
+            for (size_t l1_index = 0; l1_index < this->num_entries; ++l1_index) {
+                auto &l1_entry = this->table[l1_index];
+                if (l1_entry.IsTable()) {
+                    ++num_tables;
+                    for (size_t l2_index = 0; l2_index < MaxPageTableEntries; ++l2_index) {
+                        auto *l2_entry = GetPointer<L2PageTableEntry>(GetTableEntry(KMemoryLayout::GetLinearVirtualAddress(l1_entry.GetTable()), l2_index));
+                        if (l2_entry->IsTable()) {
+                            ++num_tables;
+                        }
+                    }
+                }
+            }
+        }
+        #endif
+
+        return num_tables;
+    }
 
 }

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

@@ -51,7 +51,7 @@ namespace ams::kern::arch::arm64 {
             cpu::InstructionMemoryBarrier();
         }
 
-        uintptr_t SetupStackForUserModeThreadStarter(KVirtualAddress pc, KVirtualAddress k_sp, KVirtualAddress u_sp, uintptr_t arg, bool is_64_bit) {
+        uintptr_t SetupStackForUserModeThreadStarter(KVirtualAddress pc, KVirtualAddress k_sp, KVirtualAddress u_sp, uintptr_t arg, const bool is_64_bit) {
             /* NOTE: Stack layout on entry looks like following:                         */
             /* SP                                                                        */
             /* |                                                                         */
@@ -76,6 +76,11 @@ namespace ams::kern::arch::arm64 {
                 MESOSPHERE_LOG("Creating User 32-Thread, %016lx\n", GetInteger(pc));
             }
 
+            /* Set CFI-value. */
+            if (is_64_bit) {
+                ctx->x[18] = KSystemControl::GenerateRandomU64() | 1;
+            }
+
             /* Set stack pointer. */
             if (is_64_bit) {
                 ctx->sp    = GetInteger(u_sp);

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

@@ -409,6 +409,15 @@ namespace ams::kern::board::nintendo::nx {
         return MinimumSize;
     }
 
+    u8 KSystemControl::Init::GetDebugLogUartPort() {
+        /* Get the log configuration. */
+        u64 value = 0;
+        smc::init::GetConfig(std::addressof(value), 1, smc::ConfigItem::ExosphereLogConfiguration);
+
+        /* Extract the port. */
+        return static_cast<u8>((value >> 32) & 0xFF);
+    }
+
     void KSystemControl::Init::CpuOn(u64 core_id, uintptr_t entrypoint, uintptr_t arg) {
         smc::init::CpuOn(core_id, entrypoint, arg);
     }

libraries/libmesosphere/source/board/nintendo/nx/kern_secure_monitor.hpp

@@ -55,15 +55,16 @@ namespace ams::kern::board::nintendo::nx::smc {
         Package2Hash                = 17,
 
         /* Extension config items for exosphere. */
-        ExosphereApiVersion     = 65000,
-        ExosphereNeedsReboot    = 65001,
-        ExosphereNeedsShutdown  = 65002,
-        ExosphereGitCommitHash  = 65003,
-        ExosphereHasRcmBugPatch = 65004,
-        ExosphereBlankProdInfo  = 65005,
-        ExosphereAllowCalWrites = 65006,
-        ExosphereEmummcType     = 65007,
-        ExospherePayloadAddress = 65008,
+        ExosphereApiVersion       = 65000,
+        ExosphereNeedsReboot      = 65001,
+        ExosphereNeedsShutdown    = 65002,
+        ExosphereGitCommitHash    = 65003,
+        ExosphereHasRcmBugPatch   = 65004,
+        ExosphereBlankProdInfo    = 65005,
+        ExosphereAllowCalWrites   = 65006,
+        ExosphereEmummcType       = 65007,
+        ExospherePayloadAddress   = 65008,
+        ExosphereLogConfiguration = 65009,
     };
 
     enum class SmcResult {

libraries/libmesosphere/source/init/kern_init_slab_setup.cpp

@@ -22,7 +22,7 @@ namespace ams::kern::init {
     #define FOREACH_SLAB_TYPE(HANDLER, ...)                                                                                     \
         HANDLER(KProcess,            (SLAB_COUNT(KProcess)),                                                    ## __VA_ARGS__) \
         HANDLER(KThread,             (SLAB_COUNT(KThread)),                                                     ## __VA_ARGS__) \
-        HANDLER(KLinkedListNode,     (SLAB_COUNT(KThread) * 17),                                                ## __VA_ARGS__) \
+        HANDLER(KLinkedListNode,     (SLAB_COUNT(KThread)),                                                     ## __VA_ARGS__) \
         HANDLER(KEvent,              (SLAB_COUNT(KEvent)),                                                      ## __VA_ARGS__) \
         HANDLER(KInterruptEvent,     (SLAB_COUNT(KInterruptEvent)),                                             ## __VA_ARGS__) \
         HANDLER(KInterruptEventTask, (SLAB_COUNT(KInterruptEvent)),                                             ## __VA_ARGS__) \
@@ -77,7 +77,7 @@ namespace ams::kern::init {
 
         namespace test {
 
-            constexpr size_t RequiredSizeForExtraThreadCount = SlabCountExtraKThread * (sizeof(KThread) + (sizeof(KLinkedListNode) * 17) + (sizeof(KThreadLocalPage) / 8) + sizeof(KEventInfo));
+            constexpr size_t RequiredSizeForExtraThreadCount = SlabCountExtraKThread * (sizeof(KThread) + sizeof(KLinkedListNode) + (sizeof(KThreadLocalPage) / 8) + sizeof(KEventInfo));
             static_assert(RequiredSizeForExtraThreadCount <= KernelSlabHeapAdditionalSize);
 
         }

libraries/libmesosphere/source/kern_debug_log_impl.board.nintendo_nx.cpp

@@ -18,10 +18,12 @@
 
 namespace ams::kern {
 
-#if defined(MESOSPHERE_DEBUG_LOG_USE_UART_A) || defined(MESOSPHERE_DEBUG_LOG_USE_UART_B) || defined(MESOSPHERE_DEBUG_LOG_USE_UART_C) || defined(MESOSPHERE_DEBUG_LOG_USE_UART_D)
+#if defined(MESOSPHERE_DEBUG_LOG_USE_UART)
 
     namespace {
 
+        constexpr bool DoSaveAndRestore = false;
+
         enum UartRegister {
             UartRegister_THR = 0,
             UartRegister_IER = 1,
@@ -38,13 +40,13 @@ namespace ams::kern {
 
         KVirtualAddress g_uart_address = 0;
 
-        constinit u32 g_saved_registers[5];
+        [[maybe_unused]] constinit u32 g_saved_registers[5];
 
-        NOINLINE u32 ReadUartRegister(UartRegister which) {
+        ALWAYS_INLINE u32 ReadUartRegister(UartRegister which) {
             return GetPointer<volatile u32>(g_uart_address)[which];
         }
 
-        NOINLINE void WriteUartRegister(UartRegister which, u32 value) {
+        ALWAYS_INLINE void WriteUartRegister(UartRegister which, u32 value) {
             GetPointer<volatile u32>(g_uart_address)[which] = value;
         }
 
@@ -86,43 +88,47 @@ namespace ams::kern {
     }
 
     void KDebugLogImpl::Save() {
-        /* Save LCR, IER, FCR. */
-        g_saved_registers[0] = ReadUartRegister(UartRegister_LCR);
-        g_saved_registers[1] = ReadUartRegister(UartRegister_IER);
-        g_saved_registers[2] = ReadUartRegister(UartRegister_FCR);
+        if constexpr (DoSaveAndRestore) {
+            /* Save LCR, IER, FCR. */
+            g_saved_registers[0] = ReadUartRegister(UartRegister_LCR);
+            g_saved_registers[1] = ReadUartRegister(UartRegister_IER);
+            g_saved_registers[2] = ReadUartRegister(UartRegister_FCR);
 
-        /* Set Divisor Latch Access bit, to allow access to DLL/DLH */
-        WriteUartRegister(UartRegister_LCR, 0x80);
-        ReadUartRegister(UartRegister_LCR);
+            /* Set Divisor Latch Access bit, to allow access to DLL/DLH */
+            WriteUartRegister(UartRegister_LCR, 0x80);
+            ReadUartRegister(UartRegister_LCR);
 
-        /* Save DLL/DLH. */
-        g_saved_registers[3] = ReadUartRegister(UartRegister_DLL);
-        g_saved_registers[4] = ReadUartRegister(UartRegister_DLH);
+            /* Save DLL/DLH. */
+            g_saved_registers[3] = ReadUartRegister(UartRegister_DLL);
+            g_saved_registers[4] = ReadUartRegister(UartRegister_DLH);
 
-        /* Restore Divisor Latch Access bit. */
-        WriteUartRegister(UartRegister_LCR, g_saved_registers[0]);
-        ReadUartRegister(UartRegister_LCR);
+            /* Restore Divisor Latch Access bit. */
+            WriteUartRegister(UartRegister_LCR, g_saved_registers[0]);
+            ReadUartRegister(UartRegister_LCR);
+        }
     }
 
     void KDebugLogImpl::Restore() {
-        /* Set Divisor Latch Access bit, to allow access to DLL/DLH */
-        WriteUartRegister(UartRegister_LCR, 0x80);
-        ReadUartRegister(UartRegister_LCR);
+        if constexpr (DoSaveAndRestore) {
+            /* Set Divisor Latch Access bit, to allow access to DLL/DLH */
+            WriteUartRegister(UartRegister_LCR, 0x80);
+            ReadUartRegister(UartRegister_LCR);
 
-        /* Restore DLL/DLH. */
-        WriteUartRegister(UartRegister_DLL, g_saved_registers[3]);
-        WriteUartRegister(UartRegister_DLH, g_saved_registers[4]);
-        ReadUartRegister(UartRegister_DLH);
+            /* Restore DLL/DLH. */
+            WriteUartRegister(UartRegister_DLL, g_saved_registers[3]);
+            WriteUartRegister(UartRegister_DLH, g_saved_registers[4]);
+            ReadUartRegister(UartRegister_DLH);
 
-        /* Restore Divisor Latch Access bit. */
-        WriteUartRegister(UartRegister_LCR, g_saved_registers[0]);
-        ReadUartRegister(UartRegister_LCR);
+            /* Restore Divisor Latch Access bit. */
+            WriteUartRegister(UartRegister_LCR, g_saved_registers[0]);
+            ReadUartRegister(UartRegister_LCR);
 
-        /* Restore IER and FCR. */
-        WriteUartRegister(UartRegister_IER, g_saved_registers[1]);
-        WriteUartRegister(UartRegister_FCR, g_saved_registers[2] | 2);
-        WriteUartRegister(UartRegister_IRDA_CSR, 0x02);
-        ReadUartRegister(UartRegister_FCR);
+            /* Restore IER and FCR. */
+            WriteUartRegister(UartRegister_IER, g_saved_registers[1]);
+            WriteUartRegister(UartRegister_FCR, g_saved_registers[2] | 2);
+            WriteUartRegister(UartRegister_IRDA_CSR, 0x02);
+            ReadUartRegister(UartRegister_FCR);
+        }
     }
 
 #elif defined(MESOSPHERE_DEBUG_LOG_USE_IRAM_RINGBUFFER)

libraries/libmesosphere/source/kern_k_dump_object.cpp

@@ -0,0 +1,651 @@
+/*
+ * 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 <mesosphere.hpp>
+
+namespace ams::kern::KDumpObject {
+
+    namespace {
+
+        constexpr const char * const ThreadStates[] = {
+            [KThread::ThreadState_Initialized] = "Initialized",
+            [KThread::ThreadState_Waiting]     = "Waiting",
+            [KThread::ThreadState_Runnable]    = "Runnable",
+            [KThread::ThreadState_Terminated]  = "Terminated",
+        };
+
+        void DumpThread(KThread *thread) {
+            if (KProcess *process = thread->GetOwnerProcess(); process != nullptr) {
+                MESOSPHERE_RELEASE_LOG("Thread ID=%5lu pid=%3lu %-11s Pri=%2d %-11s KernelStack=%4zu/%4zu Run=%d Ideal=%d (%d) Affinity=%016lx (%016lx)\n",
+                               thread->GetId(), process->GetId(), process->GetName(), thread->GetPriority(), ThreadStates[thread->GetState()],
+                               thread->GetKernelStackUsage(), PageSize, thread->GetActiveCore(), thread->GetIdealVirtualCore(), thread->GetIdealPhysicalCore(),
+                               thread->GetVirtualAffinityMask(), thread->GetAffinityMask().GetAffinityMask());
+
+                MESOSPHERE_RELEASE_LOG("    State: 0x%04x Suspend: 0x%04x Dpc: 0x%x\n", thread->GetRawState(), thread->GetSuspendFlags(), thread->GetDpc());
+
+                MESOSPHERE_RELEASE_LOG("    TLS: %p (%p)\n", GetVoidPointer(thread->GetThreadLocalRegionAddress()), thread->GetThreadLocalRegionHeapAddress());
+            } else {
+                MESOSPHERE_RELEASE_LOG("Thread ID=%5lu pid=%3d %-11s Pri=%2d %-11s KernelStack=%4zu/%4zu Run=%d Ideal=%d (%d) Affinity=%016lx (%016lx)\n",
+                               thread->GetId(), -1, "(kernel)", thread->GetPriority(), ThreadStates[thread->GetState()],
+                               thread->GetKernelStackUsage(), PageSize, thread->GetActiveCore(), thread->GetIdealVirtualCore(), thread->GetIdealPhysicalCore(),
+                               thread->GetVirtualAffinityMask(), thread->GetAffinityMask().GetAffinityMask());
+            }
+        }
+
+        void DumpThreadCallStack(KThread *thread) {
+            if (KProcess *process = thread->GetOwnerProcess(); process != nullptr) {
+                MESOSPHERE_RELEASE_LOG("Thread ID=%5lu pid=%3lu %-11s Pri=%2d %-11s KernelStack=%4zu/%4zu\n",
+                               thread->GetId(), process->GetId(), process->GetName(), thread->GetPriority(), ThreadStates[thread->GetState()], thread->GetKernelStackUsage(), PageSize);
+
+                KDebug::PrintRegister(thread);
+                KDebug::PrintBacktrace(thread);
+            } else {
+                MESOSPHERE_RELEASE_LOG("Thread ID=%5lu pid=%3d %-11s Pri=%2d %-11s KernelStack=%4zu/%4zu\n",
+                               thread->GetId(), -1, "(kernel)", thread->GetPriority(), ThreadStates[thread->GetState()], thread->GetKernelStackUsage(), PageSize);
+            }
+        }
+
+        void DumpHandle(const KProcess::ListAccessor &accessor, KProcess *process) {
+            MESOSPHERE_RELEASE_LOG("Process ID=%lu (%s)\n", process->GetId(), process->GetName());
+
+            const auto end = accessor.end();
+            const auto &handle_table = process->GetHandleTable();
+            const size_t max_handles = handle_table.GetMaxCount();
+            for (size_t i = 0; i < max_handles; ++i) {
+                /* Get the object + handle. */
+                ams::svc::Handle handle = ams::svc::InvalidHandle;
+                KScopedAutoObject obj = handle_table.GetObjectByIndex(std::addressof(handle), i);
+                if (obj.IsNotNull()) {
+                    if (auto *target = obj->DynamicCast<KServerSession *>(); target != nullptr) {
+                        MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s Client=%p\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), std::addressof(target->GetParent()->GetClientSession()));
+                        target->Dump();
+                    } else if (auto *target = obj->DynamicCast<KClientSession *>(); target != nullptr) {
+                        MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s Server=%p\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), std::addressof(target->GetParent()->GetServerSession()));
+                    } else if (auto *target = obj->DynamicCast<KThread *>(); target != nullptr) {
+                        KProcess *target_owner = target->GetOwnerProcess();
+                        const s32 owner_pid = target_owner != nullptr ? static_cast<s32>(target_owner->GetId()) : -1;
+                        MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s ID=%d PID=%d\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), static_cast<s32>(target->GetId()), owner_pid);
+                    } else if (auto *target = obj->DynamicCast<KProcess *>(); target != nullptr) {
+                        MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s ID=%d\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), static_cast<s32>(target->GetId()));
+                    } else if (auto *target = obj->DynamicCast<KSharedMemory *>(); target != nullptr) {
+                        /* Find the owner. */
+                        KProcess *target_owner = nullptr;
+                        for (auto it = accessor.begin(); it != end; ++it) {
+                            if (static_cast<KProcess *>(std::addressof(*it))->GetId() == target->GetOwnerProcessId()) {
+                                target_owner = static_cast<KProcess *>(std::addressof(*it));
+                                break;
+                            }
+                        }
+
+                        MESOSPHERE_ASSERT(target_owner != nullptr);
+                        MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s Size=%zu KB OwnerPID=%d (%s)\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), target->GetSize() / 1_KB, static_cast<s32>(target_owner->GetId()), target_owner->GetName());
+                    } else if (auto *target = obj->DynamicCast<KTransferMemory *>(); target != nullptr) {
+                        KProcess *target_owner = target->GetOwner();
+                        MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s OwnerPID=%d (%s) OwnerAddress=%lx Size=%zu KB\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), static_cast<s32>(target_owner->GetId()), target_owner->GetName(), GetInteger(target->GetSourceAddress()), target->GetSize() / 1_KB);
+                    } else if (auto *target = obj->DynamicCast<KCodeMemory *>(); target != nullptr) {
+                        KProcess *target_owner = target->GetOwner();
+                        MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s OwnerPID=%d (%s) OwnerAddress=%lx Size=%zu KB\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), static_cast<s32>(target_owner->GetId()), target_owner->GetName(), GetInteger(target->GetSourceAddress()), target->GetSize() / 1_KB);
+                    } else if (auto *target = obj->DynamicCast<KInterruptEvent *>(); target != nullptr) {
+                        MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s irq=%d\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), target->GetInterruptId());
+                    } else if (auto *target = obj->DynamicCast<KWritableEvent *>(); target != nullptr) {
+                        if (KEvent *event = target->GetParent(); event != nullptr) {
+                            MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s Pair=%p\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), std::addressof(event->GetReadableEvent()));
+                        } else {
+                            MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName());
+                        }
+                    } else if (auto *target = obj->DynamicCast<KReadableEvent *>(); target != nullptr) {
+                        if (KEvent *event = target->GetParent(); event != nullptr) {
+                            MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s Pair=%p\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName(), std::addressof(event->GetWritableEvent()));
+                        } else {
+                            MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName());
+                        }
+                    } else {
+                        MESOSPHERE_RELEASE_LOG("Handle %08x Obj=%p Ref=%d Type=%s\n", handle, obj.GetPointerUnsafe(), obj->GetReferenceCount() - 1, obj->GetTypeName());
+                    }
+
+                    if (auto *sync = obj->DynamicCast<KSynchronizationObject *>(); sync != nullptr) {
+                        sync->DumpWaiters();
+                    }
+                }
+            }
+
+            MESOSPHERE_RELEASE_LOG("%zu(max %zu)/%zu used.\n", handle_table.GetCount(), max_handles, handle_table.GetTableSize());
+            MESOSPHERE_RELEASE_LOG("\n\n");
+        }
+
+        void DumpMemory(KProcess *process) {
+            const auto process_id = process->GetId();
+            MESOSPHERE_RELEASE_LOG("Process ID=%3lu (%s)\n", process_id, process->GetName());
+
+            /* Dump the memory blocks. */
+            process->GetPageTable().DumpMemoryBlocks();
+
+            /* Collect information about memory totals. */
+            const size_t code            = process->GetPageTable().GetCodeSize();
+            const size_t code_data       = process->GetPageTable().GetCodeDataSize();
+            const size_t alias_code      = process->GetPageTable().GetAliasCodeSize();
+            const size_t alias_code_data = process->GetPageTable().GetAliasCodeDataSize();
+            const size_t normal          = process->GetPageTable().GetNormalMemorySize();
+            const size_t main_stack      = process->GetMainStackSize();
+
+            size_t shared = 0;
+            {
+                KSharedMemory::ListAccessor accessor;
+                const auto end = accessor.end();
+                for (auto it = accessor.begin(); it != end; ++it) {
+                    KSharedMemory *shared_mem = static_cast<KSharedMemory *>(std::addressof(*it));
+                    if (shared_mem->GetOwnerProcessId() == process_id) {
+                        shared += shared_mem->GetSize();
+                    }
+                }
+            }
+
+            /* Dump the totals. */
+            MESOSPHERE_RELEASE_LOG("---\n");
+            MESOSPHERE_RELEASE_LOG("Code          %8zu KB\n", code / 1_KB);
+            MESOSPHERE_RELEASE_LOG("CodeData      %8zu KB\n", code_data / 1_KB);
+            MESOSPHERE_RELEASE_LOG("AliasCode     %8zu KB\n", alias_code / 1_KB);
+            MESOSPHERE_RELEASE_LOG("AliasCodeData %8zu KB\n", alias_code_data / 1_KB);
+            MESOSPHERE_RELEASE_LOG("Heap          %8zu KB\n", normal / 1_KB);
+            MESOSPHERE_RELEASE_LOG("SharedMemory  %8zu KB\n", shared / 1_KB);
+            MESOSPHERE_RELEASE_LOG("InitialStack  %8zu KB\n", main_stack / 1_KB);
+            MESOSPHERE_RELEASE_LOG("---\n");
+            MESOSPHERE_RELEASE_LOG("TOTAL         %8zu KB\n", (code + code_data + alias_code + alias_code_data + normal + main_stack + shared) / 1_KB);
+            MESOSPHERE_RELEASE_LOG("\n\n");
+        }
+
+        void DumpProcess(KProcess *process) {
+            MESOSPHERE_RELEASE_LOG("Process ID=%3lu index=%3zu State=%d (%s)\n", process->GetId(), process->GetSlabIndex(), process->GetState(), process->GetName());
+        }
+
+        void DumpPort(const KProcess::ListAccessor &accessor, KProcess *process) {
+            MESOSPHERE_RELEASE_LOG("Dump Port Process ID=%lu (%s)\n", process->GetId(), process->GetName());
+
+            const auto end = accessor.end();
+            const auto &handle_table = process->GetHandleTable();
+            const size_t max_handles = handle_table.GetMaxCount();
+            for (size_t i = 0; i < max_handles; ++i) {
+                /* Get the object + handle. */
+                ams::svc::Handle handle = ams::svc::InvalidHandle;
+                KScopedAutoObject obj = handle_table.GetObjectByIndex(std::addressof(handle), i);
+                if (obj.IsNull()) {
+                    continue;
+                }
+
+                /* Process the object as a port. */
+                if (auto *server = obj->DynamicCast<KServerPort *>(); server != nullptr) {
+                    const KClientPort *client = std::addressof(server->GetParent()->GetClientPort());
+                    const uintptr_t port_name = server->GetParent()->GetName();
+
+                    /* Get the port name. */
+                    char name[9] = {};
+                    {
+                        /* Find the client port process. */
+                        KScopedAutoObject<KProcess> client_port_process;
+                        {
+                            for (auto it = accessor.begin(); it != end && client_port_process.IsNull(); ++it) {
+                                KProcess *cur = static_cast<KProcess *>(std::addressof(*it));
+                                for (size_t j = 0; j < cur->GetHandleTable().GetMaxCount(); ++j) {
+                                    ams::svc::Handle cur_h  = ams::svc::InvalidHandle;
+                                    KScopedAutoObject cur_o = cur->GetHandleTable().GetObjectByIndex(std::addressof(cur_h), j);
+                                    if (cur_o.IsNotNull()) {
+                                        if (cur_o.GetPointerUnsafe() == client) {
+                                            client_port_process = cur;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        /* Read the port name. */
+                        if (client_port_process.IsNotNull()) {
+                            if (R_FAILED(client_port_process->GetPageTable().CopyMemoryFromLinearToKernel(KProcessAddress(name), 8, port_name, KMemoryState_None, KMemoryState_None, KMemoryPermission_UserRead, KMemoryAttribute_None, KMemoryAttribute_None))) {
+                                std::memset(name, 0, sizeof(name));
+                            }
+                            for (size_t i = 0; i < 8 && name[i] != 0; i++) {
+                                if (name[i] > 0x7F) {
+                                    std::memset(name, 0, sizeof(name));
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    MESOSPHERE_RELEASE_LOG("%-9s: Handle %08x Obj=%p Cur=%3d Peak=%3d Max=%3d\n", name, handle, obj.GetPointerUnsafe(), client->GetNumSessions(), client->GetPeakSessions(), client->GetMaxSessions());
+
+                    /* Identify any sessions. */
+                    {
+                        for (auto it = accessor.begin(); it != end; ++it) {
+                            KProcess *cur = static_cast<KProcess *>(std::addressof(*it));
+                            for (size_t j = 0; j < cur->GetHandleTable().GetMaxCount(); ++j) {
+                                ams::svc::Handle cur_h  = ams::svc::InvalidHandle;
+                                KScopedAutoObject cur_o = cur->GetHandleTable().GetObjectByIndex(std::addressof(cur_h), j);
+                                if (cur_o.IsNull()) {
+                                    continue;
+                                }
+                                if (auto *session = cur_o->DynamicCast<KClientSession *>(); session != nullptr && session->GetParent()->GetParent() == client) {
+                                    MESOSPHERE_RELEASE_LOG("    Client %p Server %p %-12s: PID=%3lu\n", session, std::addressof(session->GetParent()->GetServerSession()), cur->GetName(), cur->GetId());
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+
+    void DumpThread() {
+        MESOSPHERE_RELEASE_LOG("Dump Thread\n");
+
+        {
+            /* Lock the list. */
+            KThread::ListAccessor accessor;
+            const auto end = accessor.end();
+
+            /* Dump each thread. */
+            for (auto it = accessor.begin(); it != end; ++it) {
+                DumpThread(static_cast<KThread *>(std::addressof(*it)));
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpThread(u64 thread_id) {
+        MESOSPHERE_RELEASE_LOG("Dump Thread\n");
+
+        {
+            /* Find and dump the target thread. */
+            if (KThread *thread = KThread::GetThreadFromId(thread_id); thread != nullptr) {
+                ON_SCOPE_EXIT { thread->Close(); };
+                DumpThread(thread);
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpThreadCallStack() {
+        MESOSPHERE_RELEASE_LOG("Dump Thread\n");
+
+        {
+            /* Lock the list. */
+            KThread::ListAccessor accessor;
+            const auto end = accessor.end();
+
+            /* Dump each thread. */
+            for (auto it = accessor.begin(); it != end; ++it) {
+                DumpThreadCallStack(static_cast<KThread *>(std::addressof(*it)));
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpThreadCallStack(u64 thread_id) {
+        MESOSPHERE_RELEASE_LOG("Dump Thread\n");
+
+        {
+            /* Find and dump the target thread. */
+            if (KThread *thread = KThread::GetThreadFromId(thread_id); thread != nullptr) {
+                ON_SCOPE_EXIT { thread->Close(); };
+                DumpThreadCallStack(thread);
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpKernelObject() {
+        MESOSPHERE_LOG("Dump Kernel Object\n");
+
+        {
+            /* Static slab heaps. */
+            {
+                #define DUMP_KSLABOBJ(__OBJECT__)                                                                                                                                                         \
+                    MESOSPHERE_RELEASE_LOG(#__OBJECT__ "\n");                                                                                                                                             \
+                    MESOSPHERE_RELEASE_LOG("    Cur=%3zu Peak=%3zu Max=%3zu\n", __OBJECT__::GetSlabHeapSize() - __OBJECT__::GetNumRemaining(), __OBJECT__::GetPeakIndex(), __OBJECT__::GetSlabHeapSize())
+
+                DUMP_KSLABOBJ(KPageBuffer);
+                DUMP_KSLABOBJ(KEvent);
+                DUMP_KSLABOBJ(KInterruptEvent);
+                DUMP_KSLABOBJ(KProcess);
+                DUMP_KSLABOBJ(KThread);
+                DUMP_KSLABOBJ(KPort);
+                DUMP_KSLABOBJ(KSharedMemory);
+                DUMP_KSLABOBJ(KTransferMemory);
+                DUMP_KSLABOBJ(KDeviceAddressSpace);
+                DUMP_KSLABOBJ(KDebug);
+                DUMP_KSLABOBJ(KSession);
+                DUMP_KSLABOBJ(KLightSession);
+                DUMP_KSLABOBJ(KLinkedListNode);
+                DUMP_KSLABOBJ(KThreadLocalPage);
+                DUMP_KSLABOBJ(KObjectName);
+                DUMP_KSLABOBJ(KEventInfo);
+                DUMP_KSLABOBJ(KSessionRequest);
+                DUMP_KSLABOBJ(KResourceLimit);
+                DUMP_KSLABOBJ(KAlpha);
+                DUMP_KSLABOBJ(KBeta);
+
+                #undef DUMP_KSLABOBJ
+
+            }
+            MESOSPHERE_RELEASE_LOG("\n");
+
+            /* Dynamic slab heaps. */
+            {
+                /* Memory block slabs. */
+                {
+                    MESOSPHERE_RELEASE_LOG("App Memory Block\n");
+                    auto &app = Kernel::GetApplicationMemoryBlockManager();
+                    MESOSPHERE_RELEASE_LOG("    Cur=%6zu Peak=%6zu Max=%6zu\n", app.GetUsed(), app.GetPeak(), app.GetCount());
+                    MESOSPHERE_RELEASE_LOG("Sys Memory Block\n");
+                    auto &sys = Kernel::GetSystemMemoryBlockManager();
+                    MESOSPHERE_RELEASE_LOG("    Cur=%6zu Peak=%6zu Max=%6zu\n", sys.GetUsed(), sys.GetPeak(), sys.GetCount());
+                }
+
+                /* KBlockInfo slab. */
+                {
+                    MESOSPHERE_RELEASE_LOG("KBlockInfo\n");
+                    auto &manager = Kernel::GetBlockInfoManager();
+                    MESOSPHERE_RELEASE_LOG("    Cur=%6zu Peak=%6zu Max=%6zu\n", manager.GetUsed(), manager.GetPeak(), manager.GetCount());
+                }
+
+                /* Page Table slab. */
+                {
+                    MESOSPHERE_RELEASE_LOG("Page Table\n");
+                    auto &manager = Kernel::GetPageTableManager();
+                    MESOSPHERE_RELEASE_LOG("    Cur=%6zu Peak=%6zu Max=%6zu\n", manager.GetUsed(), manager.GetPeak(), manager.GetCount());
+                }
+            }
+            MESOSPHERE_RELEASE_LOG("\n");
+
+            /* Process resources. */
+            {
+                KProcess::ListAccessor accessor;
+
+                size_t process_pts = 0;
+
+                const auto end = accessor.end();
+                for (auto it = accessor.begin(); it != end; ++it) {
+                    KProcess *process = static_cast<KProcess *>(std::addressof(*it));
+
+                    /* Count the number of threads. */
+                    int threads = 0;
+                    {
+                        KThread::ListAccessor thr_accessor;
+                        const auto thr_end = thr_accessor.end();
+                        for (auto thr_it = thr_accessor.begin(); thr_it != thr_end; ++thr_it) {
+                            KThread *thread = static_cast<KThread *>(std::addressof(*thr_it));
+                            if (thread->GetOwnerProcess() == process) {
+                                ++threads;
+                            }
+                        }
+                    }
+
+                    /* Count the number of events. */
+                    int events = 0;
+                    {
+                        KEvent::ListAccessor ev_accessor;
+                        const auto ev_end = ev_accessor.end();
+                        for (auto ev_it = ev_accessor.begin(); ev_it != ev_end; ++ev_it) {
+                            KEvent *event = static_cast<KEvent *>(std::addressof(*ev_it));
+                            if (event->GetOwner() == process) {
+                                ++events;
+                            }
+                        }
+                    }
+
+                    size_t pts = process->GetPageTable().CountPageTables();
+                    process_pts += pts;
+
+                    MESOSPHERE_RELEASE_LOG("%-12s: PID=%3lu Thread %4d / Event %4d / PageTable %5zu\n", process->GetName(), process->GetId(), threads, events, pts);
+                    if (process->GetTotalSystemResourceSize() != 0) {
+                        MESOSPHERE_RELEASE_LOG("    System Resource\n");
+                        MESOSPHERE_RELEASE_LOG("        Cur=%6zu Peak=%6zu Max=%6zu\n", process->GetDynamicPageManager().GetUsed(), process->GetDynamicPageManager().GetPeak(), process->GetDynamicPageManager().GetCount());
+                        MESOSPHERE_RELEASE_LOG("    Memory Block\n");
+                        MESOSPHERE_RELEASE_LOG("        Cur=%6zu Peak=%6zu Max=%6zu\n", process->GetMemoryBlockSlabManager().GetUsed(), process->GetMemoryBlockSlabManager().GetPeak(), process->GetMemoryBlockSlabManager().GetCount());
+                        MESOSPHERE_RELEASE_LOG("    Page Table\n");
+                        MESOSPHERE_RELEASE_LOG("        Cur=%6zu Peak=%6zu Max=%6zu\n", process->GetPageTableManager().GetUsed(), process->GetPageTableManager().GetPeak(), process->GetPageTableManager().GetCount());
+                        MESOSPHERE_RELEASE_LOG("    Block Info\n");
+                        MESOSPHERE_RELEASE_LOG("        Cur=%6zu Peak=%6zu Max=%6zu\n", process->GetBlockInfoManager().GetUsed(), process->GetBlockInfoManager().GetPeak(), process->GetBlockInfoManager().GetCount());
+                    }
+                }
+
+                MESOSPHERE_RELEASE_LOG("Process Page Table %zu\n", process_pts);
+                MESOSPHERE_RELEASE_LOG("Kernel Page Table  %zu\n", Kernel::GetKernelPageTable().CountPageTables());
+            }
+            MESOSPHERE_RELEASE_LOG("\n");
+
+            /* Resource limits. */
+            {
+                auto &sys_rl = Kernel::GetSystemResourceLimit();
+
+                u64 cur = sys_rl.GetCurrentValue(ams::svc::LimitableResource_PhysicalMemoryMax);
+                u64 lim = sys_rl.GetLimitValue(ams::svc::LimitableResource_PhysicalMemoryMax);
+                MESOSPHERE_RELEASE_LOG("System ResourceLimit PhysicalMemory 0x%01x_%08x / 0x%01x_%08x\n", static_cast<u32>(cur >> 32), static_cast<u32>(cur), static_cast<u32>(lim >> 32), static_cast<u32>(lim));
+
+                cur = sys_rl.GetCurrentValue(ams::svc::LimitableResource_ThreadCountMax);
+                lim = sys_rl.GetLimitValue(ams::svc::LimitableResource_ThreadCountMax);
+                MESOSPHERE_RELEASE_LOG("System ResourceLimit Thread         %4lu / %4lu\n", cur, lim);
+
+                cur = sys_rl.GetCurrentValue(ams::svc::LimitableResource_EventCountMax);
+                lim = sys_rl.GetLimitValue(ams::svc::LimitableResource_EventCountMax);
+                MESOSPHERE_RELEASE_LOG("System ResourceLimit Event          %4lu / %4lu\n", cur, lim);
+
+                cur = sys_rl.GetCurrentValue(ams::svc::LimitableResource_TransferMemoryCountMax);
+                lim = sys_rl.GetLimitValue(ams::svc::LimitableResource_TransferMemoryCountMax);
+                MESOSPHERE_RELEASE_LOG("System ResourceLimit TransferMemory %4lu / %4lu\n", cur, lim);
+
+                cur = sys_rl.GetCurrentValue(ams::svc::LimitableResource_SessionCountMax);
+                lim = sys_rl.GetLimitValue(ams::svc::LimitableResource_SessionCountMax);
+                MESOSPHERE_RELEASE_LOG("System ResourceLimit Session        %4lu / %4lu\n", cur, lim);
+
+                {
+                    KResourceLimit::ListAccessor accessor;
+
+                    const auto end = accessor.end();
+                    for (auto it = accessor.begin(); it != end; ++it) {
+                        KResourceLimit *rl = static_cast<KResourceLimit *>(std::addressof(*it));
+                        cur = rl->GetCurrentValue(ams::svc::LimitableResource_PhysicalMemoryMax);
+                        lim = rl->GetLimitValue(ams::svc::LimitableResource_PhysicalMemoryMax);
+                        MESOSPHERE_RELEASE_LOG("ResourceLimit %zu PhysicalMemory 0x%01x_%08x / 0x%01x_%08x\n", rl->GetSlabIndex(), static_cast<u32>(cur >> 32), static_cast<u32>(cur), static_cast<u32>(lim >> 32), static_cast<u32>(lim));
+                    }
+                }
+            }
+            MESOSPHERE_RELEASE_LOG("\n");
+
+            /* Memory Manager. */
+            {
+                auto &mm = Kernel::GetMemoryManager();
+                u64 max = mm.GetSize();
+                u64 cur = max - mm.GetFreeSize();
+                MESOSPHERE_RELEASE_LOG("Kernel Heap Size 0x%01x_%08x / 0x%01x_%08x\n", static_cast<u32>(cur >> 32), static_cast<u32>(cur), static_cast<u32>(max >> 32), static_cast<u32>(max));
+                MESOSPHERE_RELEASE_LOG("\n");
+
+                max = mm.GetSize(KMemoryManager::Pool_Application);
+                cur = max - mm.GetFreeSize(KMemoryManager::Pool_Application);
+                MESOSPHERE_RELEASE_LOG("Application      0x%01x_%08x / 0x%01x_%08x\n", static_cast<u32>(cur >> 32), static_cast<u32>(cur), static_cast<u32>(max >> 32), static_cast<u32>(max));
+                mm.DumpFreeList(KMemoryManager::Pool_Application);
+                MESOSPHERE_RELEASE_LOG("\n");
+
+                max = mm.GetSize(KMemoryManager::Pool_Applet);
+                cur = max - mm.GetFreeSize(KMemoryManager::Pool_Applet);
+                MESOSPHERE_RELEASE_LOG("Applet           0x%01x_%08x / 0x%01x_%08x\n", static_cast<u32>(cur >> 32), static_cast<u32>(cur), static_cast<u32>(max >> 32), static_cast<u32>(max));
+                mm.DumpFreeList(KMemoryManager::Pool_Applet);
+                MESOSPHERE_RELEASE_LOG("\n");
+
+                max = mm.GetSize(KMemoryManager::Pool_System);
+                cur = max - mm.GetFreeSize(KMemoryManager::Pool_System);
+                MESOSPHERE_RELEASE_LOG("System           0x%01x_%08x / 0x%01x_%08x\n", static_cast<u32>(cur >> 32), static_cast<u32>(cur), static_cast<u32>(max >> 32), static_cast<u32>(max));
+                mm.DumpFreeList(KMemoryManager::Pool_System);
+                MESOSPHERE_RELEASE_LOG("\n");
+
+                max = mm.GetSize(KMemoryManager::Pool_SystemNonSecure);
+                cur = max - mm.GetFreeSize(KMemoryManager::Pool_SystemNonSecure);
+                MESOSPHERE_RELEASE_LOG("SystemNonSecure  0x%01x_%08x / 0x%01x_%08x\n", static_cast<u32>(cur >> 32), static_cast<u32>(cur), static_cast<u32>(max >> 32), static_cast<u32>(max));
+                mm.DumpFreeList(KMemoryManager::Pool_SystemNonSecure);
+                MESOSPHERE_RELEASE_LOG("\n");
+            }
+            MESOSPHERE_RELEASE_LOG("\n");
+
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpHandle() {
+        MESOSPHERE_RELEASE_LOG("Dump Handle\n");
+
+        {
+            /* Lock the list. */
+            KProcess::ListAccessor accessor;
+            const auto end = accessor.end();
+
+            /* Dump each process. */
+            for (auto it = accessor.begin(); it != end; ++it) {
+                DumpHandle(accessor, static_cast<KProcess *>(std::addressof(*it)));
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpHandle(u64 process_id) {
+        MESOSPHERE_RELEASE_LOG("Dump Handle\n");
+
+        {
+            /* Find and dump the target process. */
+            if (KProcess *process = KProcess::GetProcessFromId(process_id); process != nullptr) {
+                ON_SCOPE_EXIT { process->Close(); };
+
+                /* Lock the list. */
+                KProcess::ListAccessor accessor;
+                DumpHandle(accessor, process);
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpKernelMemory() {
+        MESOSPHERE_RELEASE_LOG("Dump Kernel Memory Info\n");
+
+        {
+            Kernel::GetKernelPageTable().DumpMemoryBlocks();
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpMemory() {
+        MESOSPHERE_RELEASE_LOG("Dump Memory Info\n");
+
+        {
+            /* Lock the list. */
+            KProcess::ListAccessor accessor;
+            const auto end = accessor.end();
+
+            /* Dump each process. */
+            for (auto it = accessor.begin(); it != end; ++it) {
+                DumpMemory(static_cast<KProcess *>(std::addressof(*it)));
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpMemory(u64 process_id) {
+        MESOSPHERE_RELEASE_LOG("Dump Memory Info\n");
+
+        {
+            /* Find and dump the target process. */
+            if (KProcess *process = KProcess::GetProcessFromId(process_id); process != nullptr) {
+                ON_SCOPE_EXIT { process->Close(); };
+                DumpMemory(process);
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpProcess() {
+        MESOSPHERE_RELEASE_LOG("Dump Process\n");
+
+        {
+            /* Lock the list. */
+            KProcess::ListAccessor accessor;
+            const auto end = accessor.end();
+
+            /* Dump each process. */
+            for (auto it = accessor.begin(); it != end; ++it) {
+                DumpProcess(static_cast<KProcess *>(std::addressof(*it)));
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpProcess(u64 process_id) {
+        MESOSPHERE_RELEASE_LOG("Dump Process\n");
+
+        {
+            /* Find and dump the target process. */
+            if (KProcess *process = KProcess::GetProcessFromId(process_id); process != nullptr) {
+                ON_SCOPE_EXIT { process->Close(); };
+                DumpProcess(process);
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpPort() {
+        MESOSPHERE_RELEASE_LOG("Dump Port\n");
+
+        {
+            /* Lock the list. */
+            KProcess::ListAccessor accessor;
+            const auto end = accessor.end();
+
+            /* Dump each process. */
+            for (auto it = accessor.begin(); it != end; ++it) {
+                DumpPort(accessor, static_cast<KProcess *>(std::addressof(*it)));
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+    void DumpPort(u64 process_id) {
+        MESOSPHERE_RELEASE_LOG("Dump Port\n");
+
+        {
+            /* Find and dump the target process. */
+            if (KProcess *process = KProcess::GetProcessFromId(process_id); process != nullptr) {
+                ON_SCOPE_EXIT { process->Close(); };
+
+                /* Lock the list. */
+                KProcess::ListAccessor accessor;
+                DumpPort(accessor, process);
+            }
+        }
+
+        MESOSPHERE_RELEASE_LOG("\n");
+    }
+
+}

libraries/libmesosphere/source/kern_k_memory_block_manager.cpp

@@ -70,10 +70,10 @@ namespace ams::kern {
         }
 
         void DumpMemoryInfo(const KMemoryInfo &info) {
-            const char *state = GetMemoryStateName(info.state);
-            const char *perm  = GetMemoryPermissionString(info);
-            const void *start = reinterpret_cast<void *>(info.GetAddress());
-            const void *end   = reinterpret_cast<void *>(info.GetLastAddress());
+            const char *state     = GetMemoryStateName(info.state);
+            const char *perm      = GetMemoryPermissionString(info);
+            const uintptr_t start = info.GetAddress();
+            const uintptr_t end   = info.GetLastAddress();
             const size_t kb   = info.GetSize() / 1_KB;
 
             const char l = (info.attribute & KMemoryAttribute_Locked)       ? 'L' : '-';
@@ -81,7 +81,7 @@ namespace ams::kern {
             const char d = (info.attribute & KMemoryAttribute_DeviceShared) ? 'D' : '-';
             const char u = (info.attribute & KMemoryAttribute_Uncached)     ? 'U' : '-';
 
-            MESOSPHERE_LOG("%p - %p (%9zu KB) %s %s %c%c%c%c [%d, %d]\n", start, end, kb, perm, state, l, i, d, u, info.ipc_lock_count, info.device_use_count);
+            MESOSPHERE_LOG("0x%10lx - 0x%10lx (%9zu KB) %s %s %c%c%c%c [%d, %d]\n", start, end, kb, perm, state, l, i, d, u, info.ipc_lock_count, info.device_use_count);
         }
 
     }

libraries/libmesosphere/source/kern_k_memory_layout.board.nintendo_nx.cpp

@@ -26,14 +26,14 @@ namespace ams::kern {
         constexpr size_t CarveoutSizeMax        = 512_MB - CarveoutAlignment;
 
         ALWAYS_INLINE bool SetupUartPhysicalMemoryRegion() {
-            #if   defined(MESOSPHERE_DEBUG_LOG_USE_UART_A)
-                return KMemoryLayout::GetPhysicalMemoryRegionTree().Insert(0x70006000, 0x40,  KMemoryRegionType_Uart | KMemoryRegionAttr_ShouldKernelMap);
-            #elif defined(MESOSPHERE_DEBUG_LOG_USE_UART_B)
-                return KMemoryLayout::GetPhysicalMemoryRegionTree().Insert(0x70006040, 0x40,  KMemoryRegionType_Uart | KMemoryRegionAttr_ShouldKernelMap);
-            #elif defined(MESOSPHERE_DEBUG_LOG_USE_UART_C)
-                return KMemoryLayout::GetPhysicalMemoryRegionTree().Insert(0x70006200, 0x100, KMemoryRegionType_Uart | KMemoryRegionAttr_ShouldKernelMap);
-            #elif defined(MESOSPHERE_DEBUG_LOG_USE_UART_D)
-                return KMemoryLayout::GetPhysicalMemoryRegionTree().Insert(0x70006300, 0x100, KMemoryRegionType_Uart | KMemoryRegionAttr_ShouldKernelMap);
+            #if   defined(MESOSPHERE_DEBUG_LOG_USE_UART)
+                switch (KSystemControl::Init::GetDebugLogUartPort()) {
+                    case 0:  return KMemoryLayout::GetPhysicalMemoryRegionTree().Insert(0x70006000, 0x40,  KMemoryRegionType_Uart | KMemoryRegionAttr_ShouldKernelMap);
+                    case 1:  return KMemoryLayout::GetPhysicalMemoryRegionTree().Insert(0x70006040, 0x40,  KMemoryRegionType_Uart | KMemoryRegionAttr_ShouldKernelMap);
+                    case 2:  return KMemoryLayout::GetPhysicalMemoryRegionTree().Insert(0x70006200, 0x100, KMemoryRegionType_Uart | KMemoryRegionAttr_ShouldKernelMap);
+                    case 3:  return KMemoryLayout::GetPhysicalMemoryRegionTree().Insert(0x70006300, 0x100, KMemoryRegionType_Uart | KMemoryRegionAttr_ShouldKernelMap);
+                    default: return false;
+                }
             #elif defined(MESOSPHERE_DEBUG_LOG_USE_IRAM_RINGBUFFER)
                 return true;
             #else

libraries/libmesosphere/source/kern_k_page_heap.cpp

@@ -132,4 +132,29 @@ namespace ams::kern {
         return util::AlignUp(overhead_size, PageSize);
     }
 
+    void KPageHeap::DumpFreeList() const {
+        MESOSPHERE_RELEASE_LOG("KPageHeap::DumpFreeList %p\n", this);
+
+        for (size_t i = 0; i < this->num_blocks; ++i) {
+            const size_t block_size = this->blocks[i].GetSize();
+            const char *suffix;
+            size_t size;
+            if (block_size >= 1_GB) {
+                suffix = "GiB";
+                size   = block_size / 1_GB;
+            } else if (block_size >= 1_MB) {
+                suffix = "MiB";
+                size   = block_size / 1_MB;
+            } else if (block_size >= 1_KB) {
+                suffix = "KiB";
+                size   = block_size / 1_KB;
+            } else {
+                suffix = "B";
+                size   = block_size;
+            }
+
+            MESOSPHERE_RELEASE_LOG("    %4zu %s block x %zu\n", size, suffix, this->blocks[i].GetNumFreeBlocks());
+        }
+    }
+
 }

libraries/libmesosphere/source/kern_k_page_table_base.cpp

@@ -1018,6 +1018,39 @@ namespace ams::kern {
         return address;
     }
 
+    size_t KPageTableBase::GetSize(KMemoryState state) const {
+        /* Lock the table. */
+        KScopedLightLock lk(this->general_lock);
+
+        /* Iterate, counting blocks with the desired state. */
+        size_t total_size = 0;
+        for (KMemoryBlockManager::const_iterator it = this->memory_block_manager.FindIterator(this->address_space_start); it != this->memory_block_manager.end(); ++it) {
+            /* Get the memory info. */
+            const KMemoryInfo info = it->GetMemoryInfo();
+            if (info.GetState() == state) {
+                total_size += info.GetSize();
+            }
+        }
+
+        return total_size;
+    }
+
+    size_t KPageTableBase::GetCodeSize() const {
+        return this->GetSize(KMemoryState_Code);
+    }
+
+    size_t KPageTableBase::GetCodeDataSize() const {
+        return this->GetSize(KMemoryState_CodeData);
+    }
+
+    size_t KPageTableBase::GetAliasCodeSize() const {
+        return this->GetSize(KMemoryState_AliasCode);
+    }
+
+    size_t KPageTableBase::GetAliasCodeDataSize() const {
+        return this->GetSize(KMemoryState_AliasCodeData);
+    }
+
     Result KPageTableBase::AllocateAndMapPagesImpl(PageLinkedList *page_list, KProcessAddress address, size_t num_pages, KMemoryPermission perm) {
         MESOSPHERE_ASSERT(this->IsLockedByCurrentThread());
 

libraries/libmesosphere/source/kern_k_server_session.cpp

@@ -1367,4 +1367,36 @@ namespace ams::kern {
 
     #pragma GCC pop_options
 
+    void KServerSession::Dump() {
+        MESOSPHERE_ASSERT_THIS();
+
+        KScopedLightLock lk(this->lock);
+        {
+            KScopedSchedulerLock sl;
+            MESOSPHERE_RELEASE_LOG("Dump Session %p\n", this);
+
+            /* Dump current request. */
+            bool has_request = false;
+            if (this->current_request != nullptr) {
+                KThread *thread = this->current_request->GetThread();
+                const s32 thread_id = thread != nullptr ? static_cast<s32>(thread->GetId()) : -1;
+                MESOSPHERE_RELEASE_LOG("    CurrentReq %p Thread=%p ID=%d\n", this->current_request, thread, thread_id);
+                has_request = true;
+            }
+
+            /* Dump all rqeuests in list. */
+            for (auto it = this->request_list.begin(); it != this->request_list.end(); ++it) {
+                KThread *thread = it->GetThread();
+                const s32 thread_id = thread != nullptr ? static_cast<s32>(thread->GetId()) : -1;
+                MESOSPHERE_RELEASE_LOG("    Req %p Thread=%p ID=%d\n", this->current_request, thread, thread_id);
+                has_request = true;
+            }
+
+            /* If we didn't have any requests, print so. */
+            if (!has_request) {
+                MESOSPHERE_RELEASE_LOG("    None\n");
+            }
+        }
+    }
+
 }

libraries/libmesosphere/source/kern_k_synchronization_object.cpp

@@ -81,8 +81,15 @@ namespace ams::kern {
             /* Add the waiters. */
             for (auto i = 0; i < num_objects; ++i) {
                 thread_nodes[i].thread      = thread;
-                thread_nodes[i].next        = objects[i]->thread_list_root;
-                objects[i]->thread_list_root = std::addressof(thread_nodes[i]);
+                thread_nodes[i].next        = nullptr;
+
+                if (objects[i]->thread_list_tail == nullptr) {
+                    objects[i]->thread_list_head = std::addressof(thread_nodes[i]);
+                } else {
+                    objects[i]->thread_list_tail->next = std::addressof(thread_nodes[i]);
+                }
+
+                objects[i]->thread_list_tail = std::addressof(thread_nodes[i]);
             }
 
             /* Mark the thread as waiting. */
@@ -111,11 +118,22 @@ namespace ams::kern {
 
             for (auto i = 0; i < num_objects; ++i) {
                 /* Unlink the object from the list. */
-                ThreadListNode **link = std::addressof(objects[i]->thread_list_root);
-                while (*link != std::addressof(thread_nodes[i])) {
-                    link = std::addressof((*link)->next);
+                ThreadListNode *prev_ptr = reinterpret_cast<ThreadListNode *>(std::addressof(objects[i]->thread_list_head));
+                ThreadListNode *prev_val = nullptr;
+                ThreadListNode *prev, *tail_prev;
+
+                do {
+                    prev      = prev_ptr;
+                    prev_ptr  = prev_ptr->next;
+                    tail_prev = prev_val;
+                    prev_val  = prev_ptr;
+                } while (prev_ptr != std::addressof(thread_nodes[i]));
+
+                if (objects[i]->thread_list_tail == std::addressof(thread_nodes[i])) {
+                    objects[i]->thread_list_tail = tail_prev;
                 }
-                *link = thread_nodes[i].next;
+
+                prev->next = thread_nodes[i].next;
 
                 if (objects[i] == synced_obj) {
                     sync_index = i;
@@ -139,7 +157,7 @@ namespace ams::kern {
         }
 
         /* Iterate over each thread. */
-        for (auto *cur_node = this->thread_list_root; cur_node != nullptr; cur_node = cur_node->next) {
+        for (auto *cur_node = this->thread_list_head; cur_node != nullptr; cur_node = cur_node->next) {
             KThread *thread = cur_node->thread;
             if (thread->GetState() == KThread::ThreadState_Waiting) {
                 thread->SetSyncedObject(this, result);
@@ -148,7 +166,7 @@ namespace ams::kern {
         }
     }
 
-    void KSynchronizationObject::DebugWaiters() {
+    void KSynchronizationObject::DumpWaiters() {
         MESOSPHERE_ASSERT_THIS();
 
         /* If debugging, dump the list of waiters. */
@@ -158,8 +176,7 @@ namespace ams::kern {
 
             MESOSPHERE_RELEASE_LOG("Threads waiting on %p:\n", this);
 
-            bool has_waiters = false;
-            for (auto *cur_node = this->thread_list_root; cur_node != nullptr; cur_node = cur_node->next) {
+            for (auto *cur_node = this->thread_list_head; cur_node != nullptr; cur_node = cur_node->next) {
                 KThread *thread = cur_node->thread;
 
                 if (KProcess *process = thread->GetOwnerProcess(); process != nullptr) {
@@ -167,12 +184,10 @@ namespace ams::kern {
                 } else {
                     MESOSPHERE_RELEASE_LOG("    %p tid=%ld (Kernel)\n", thread, thread->GetId());
                 }
-
-                has_waiters = true;
             }
 
             /* If we didn't have any waiters, print so. */
-            if (!has_waiters) {
+            if (this->thread_list_head != nullptr) {
                 MESOSPHERE_RELEASE_LOG("    None\n");
             }
         }

libraries/libmesosphere/source/kern_k_thread.cpp

@@ -24,6 +24,15 @@ namespace ams::kern {
             return KernelVirtualAddressSpaceBase <= key_uptr && key_uptr <= KernelVirtualAddressSpaceLast;
         }
 
+        void InitializeKernelStack(uintptr_t stack_top) {
+            #if defined(MESOSPHERE_ENABLE_KERNEL_STACK_USAGE)
+                const uintptr_t stack_bottom = stack_top - PageSize;
+                std::memset(reinterpret_cast<void *>(stack_bottom), 0xCC, PageSize - sizeof(KThread::StackParameters));
+            #else
+                MESOSPHERE_UNUSED(stack_top);
+            #endif
+        }
+
         void CleanupKernelStack(uintptr_t stack_top) {
             const uintptr_t stack_bottom = stack_top - PageSize;
 
@@ -153,6 +162,11 @@ namespace ams::kern {
         this->resource_limit_release_hint   = 0;
         this->cpu_time                      = 0;
 
+        /* Setup our kernel stack. */
+        if (type != ThreadType_Main) {
+            InitializeKernelStack(reinterpret_cast<uintptr_t>(kern_stack_top));
+        }
+
         /* Clear our stack parameters. */
         std::memset(static_cast<void *>(std::addressof(this->GetStackParameters())), 0, sizeof(StackParameters));
 
@@ -803,6 +817,26 @@ namespace ams::kern {
         KScheduler::OnThreadStateChanged(this, old_state);
     }
 
+    size_t KThread::GetKernelStackUsage() const {
+        MESOSPHERE_ASSERT_THIS();
+        MESOSPHERE_ASSERT(this->kernel_stack_top != nullptr);
+
+        #if defined(MESOSPHERE_ENABLE_KERNEL_STACK_USAGE)
+            const u8 *stack = static_cast<const u8 *>(this->kernel_stack_top) - PageSize;
+
+            size_t i;
+            for (i = 0; i < PageSize; ++i) {
+                if (stack[i] != 0xCC) {
+                    break;
+                }
+            }
+
+            return PageSize - i;
+        #else
+            return 0;
+        #endif
+    }
+
     Result KThread::SetActivity(ams::svc::ThreadActivity activity) {
         /* Lock ourselves. */
         KScopedLightLock lk(this->activity_pause_lock);

libraries/libmesosphere/source/kern_panic.cpp

@@ -97,25 +97,20 @@ namespace ams::kern {
             /* Print the state. */
             MESOSPHERE_RELEASE_LOG("Core[%d] Current State:\n", core_id);
 
-            #ifdef ATMOSPHERE_ARCH_ARM64
-                /* Print registers. */
-                if (core_ctx != nullptr) {
-                    MESOSPHERE_RELEASE_LOG("    Registers:\n");
-                    for (size_t i = 0; i < util::size(core_ctx->x); ++i) {
-                        MESOSPHERE_RELEASE_LOG("        X[%02zx]: %p\n", i, reinterpret_cast<void *>(core_ctx->x[i]));
-                    }
-                    MESOSPHERE_RELEASE_LOG("        SP:   %p\n", reinterpret_cast<void *>(core_ctx->x[30]));
-                }
+            /* Print registers and user backtrace. */
+            KDebug::PrintRegister();
+            KDebug::PrintBacktrace();
 
-                /* Print backtrace. */
-                MESOSPHERE_RELEASE_LOG("    Backtrace:\n");
+            #ifdef ATMOSPHERE_ARCH_ARM64
+                /* Print kernel backtrace. */
+                MESOSPHERE_RELEASE_LOG("Backtrace:\n");
                 uintptr_t fp = core_ctx != nullptr ? core_ctx->x[29] : reinterpret_cast<uintptr_t>(__builtin_frame_address(0));
                 for (size_t i = 0; i < 32 && fp && util::IsAligned(fp, 0x10) && cpu::GetPhysicalAddressWritable(nullptr, fp, true); i++) {
                     struct {
                         uintptr_t fp;
                         uintptr_t lr;
                     } *stack_frame = reinterpret_cast<decltype(stack_frame)>(fp);
-                    MESOSPHERE_RELEASE_LOG("        [%02zx]: %p\n", i, reinterpret_cast<void *>(stack_frame->lr));
+                    MESOSPHERE_RELEASE_LOG("   [%02zx]: %p\n", i, reinterpret_cast<void *>(stack_frame->lr));
                     fp = stack_frame->fp;
                 }
             #endif
@@ -137,7 +132,7 @@ namespace ams::kern {
 
     }
 
-    NORETURN void PanicImpl(const char *file, int line, const char *format, ...) {
+    NORETURN WEAK_SYMBOL void PanicImpl(const char *file, int line, const char *format, ...) {
         #ifdef MESOSPHERE_BUILD_FOR_DEBUGGING
             /* Wait for it to be our turn to print. */
             WaitCoreTicket();
@@ -158,7 +153,7 @@ namespace ams::kern {
         StopSystem();
     }
 
-    NORETURN void PanicImpl() {
+    NORETURN WEAK_SYMBOL void PanicImpl() {
         StopSystem();
     }
 

libraries/libmesosphere/source/svc/kern_svc_exception.cpp

@@ -21,16 +21,18 @@ namespace ams::kern::svc {
 
     namespace {
 
-        [[maybe_unused]] void PrintBreak(ams::svc::BreakReason break_reason) {
+        #if defined(MESOSPHERE_BUILD_FOR_DEBUGGING)
+        void PrintBreak(ams::svc::BreakReason break_reason) {
             /* Print that break was called. */
             MESOSPHERE_RELEASE_LOG("%s: svc::Break(%d) was called, pid=%ld, tid=%ld\n", GetCurrentProcess().GetName(), static_cast<s32>(break_reason), GetCurrentProcess().GetId(), GetCurrentThread().GetId());
 
             /* Print the current thread's registers. */
-            /* TODO: KDebug::PrintRegisters(); */
+            KDebug::PrintRegister();
 
             /* Print a backtrace. */
-            /* TODO: KDebug::PrintBacktrace(); */
+            KDebug::PrintBacktrace();
         }
+        #endif
 
         void Break(ams::svc::BreakReason break_reason, uintptr_t address, size_t size) {
             /* Determine whether the break is only a notification. */
@@ -38,7 +40,7 @@ namespace ams::kern::svc {
 
             /* If the break isn't a notification, print it. */
             if (!is_notification) {
-                #ifdef MESOSPHERE_BUILD_FOR_DEBUGGING
+                #if defined(MESOSPHERE_BUILD_FOR_DEBUGGING)
                 PrintBreak(break_reason);
                 #endif
             }

libraries/libmesosphere/source/svc/kern_svc_info.cpp

@@ -59,6 +59,7 @@ namespace ams::kern::svc {
                 case ams::svc::InfoType_TotalNonSystemMemorySize:
                 case ams::svc::InfoType_UsedNonSystemMemorySize:
                 case ams::svc::InfoType_IsApplication:
+                case ams::svc::InfoType_FreeThreadCount:
                     {
                         /* These info types don't support non-zero subtypes. */
                         R_UNLESS(info_subtype == 0,  svc::ResultInvalidCombination());
@@ -125,6 +126,15 @@ namespace ams::kern::svc {
                             case ams::svc::InfoType_IsApplication:
                                 *out = process->IsApplication();
                                 break;
+                            case ams::svc::InfoType_FreeThreadCount:
+                                if (KResourceLimit *resource_limit = process->GetResourceLimit(); resource_limit != nullptr) {
+                                    const auto current_value = resource_limit->GetCurrentValue(ams::svc::LimitableResource_ThreadCountMax);
+                                    const auto limit_value   = resource_limit->GetLimitValue(ams::svc::LimitableResource_ThreadCountMax);
+                                    *out = limit_value - current_value;
+                                } else {
+                                    *out = 0;
+                                }
+                                break;
                             MESOSPHERE_UNREACHABLE_DEFAULT_CASE();
                         }
                     }

libraries/libmesosphere/source/svc/kern_svc_kernel_debug.cpp

@@ -22,19 +22,85 @@ namespace ams::kern::svc {
     namespace {
 
         void KernelDebug(ams::svc::KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2) {
-            #ifdef ATMOSPHERE_BUILD_FOR_DEBUGGING
+            MESOSPHERE_UNUSED(kern_debug_type, arg0, arg1, arg2);
+
+            #ifdef MESOSPHERE_BUILD_FOR_DEBUGGING
             {
-                /* TODO: Implement Kernel Debugging. */
-            }
-            #else
-            {
-                MESOSPHERE_UNUSED(kern_debug_type, arg0, arg1, arg2);
+                switch (kern_debug_type) {
+                    case ams::svc::KernelDebugType_Thread:
+                        if (arg0 == static_cast<u64>(-1)) {
+                            KDumpObject::DumpThread();
+                        } else {
+                            KDumpObject::DumpThread(arg0);
+                        }
+                        break;
+                    case ams::svc::KernelDebugType_ThreadCallStack:
+                        if (arg0 == static_cast<u64>(-1)) {
+                            KDumpObject::DumpThreadCallStack();
+                        } else {
+                            KDumpObject::DumpThreadCallStack(arg0);
+                        }
+                        break;
+                    case ams::svc::KernelDebugType_KernelObject:
+                        KDumpObject::DumpKernelObject();
+                        break;
+                    case ams::svc::KernelDebugType_Handle:
+                        if (arg0 == static_cast<u64>(-1)) {
+                            KDumpObject::DumpHandle();
+                        } else {
+                            KDumpObject::DumpHandle(arg0);
+                        }
+                        break;
+                    case ams::svc::KernelDebugType_Memory:
+                        if (arg0 == static_cast<u64>(-2)) {
+                            KDumpObject::DumpKernelMemory();
+                        } else if (arg0 == static_cast<u64>(-1)) {
+                            KDumpObject::DumpMemory();
+                        } else {
+                            KDumpObject::DumpMemory(arg0);
+                        }
+                        break;
+                    case ams::svc::KernelDebugType_Process:
+                        if (arg0 == static_cast<u64>(-1)) {
+                            KDumpObject::DumpProcess();
+                        } else {
+                            KDumpObject::DumpProcess(arg0);
+                        }
+                        break;
+                    case ams::svc::KernelDebugType_SuspendProcess:
+                        if (KProcess *process = KProcess::GetProcessFromId(arg0); process != nullptr) {
+                            ON_SCOPE_EXIT { process->Close(); };
+
+                            if (R_SUCCEEDED(process->SetActivity(ams::svc::ProcessActivity_Paused))) {
+                                MESOSPHERE_RELEASE_LOG("Suspend Process ID=%3lu\n", process->GetId());
+                            }
+                        }
+                        break;
+                    case ams::svc::KernelDebugType_ResumeProcess:
+                        if (KProcess *process = KProcess::GetProcessFromId(arg0); process != nullptr) {
+                            ON_SCOPE_EXIT { process->Close(); };
+
+                            if (R_SUCCEEDED(process->SetActivity(ams::svc::ProcessActivity_Runnable))) {
+                                MESOSPHERE_RELEASE_LOG("Resume Process ID=%3lu\n", process->GetId());
+                            }
+                        }
+                        break;
+                    case ams::svc::KernelDebugType_Port:
+                        if (arg0 == static_cast<u64>(-1)) {
+                            KDumpObject::DumpPort();
+                        } else {
+                            KDumpObject::DumpPort(arg0);
+                        }
+                        break;
+                    default:
+                        break;
+                }
             }
             #endif
         }
 
         void ChangeKernelTraceState(ams::svc::KernelTraceState kern_trace_state) {
-            #ifdef ATMOSPHERE_BUILD_FOR_DEBUGGING
+            #ifdef MESOSPHERE_BUILD_FOR_DEBUGGING
             {
                 switch (kern_trace_state) {
                     case ams::svc::KernelTraceState_Enabled:

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

@@ -25,17 +25,17 @@ namespace ams::erpt::sf {
     #define AMS_ERPT_I_CONTEXT_INTERFACE_INFO(C, H)                                                                                                                                                                                                                                                \
         AMS_SF_METHOD_INFO(C, H,  0, Result, SubmitContext,                             (const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer))                                                                                                                                \
         AMS_SF_METHOD_INFO(C, H,  1, Result, CreateReportV0,                            (ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer))                                                                  \
-        AMS_SF_METHOD_INFO(C, H,  2, Result, SetInitialLaunchSettingsCompletionTime,    (const time::SteadyClockTimePoint &time_point),                                                                                                                  hos::Version_3_0_0)                       \
-        AMS_SF_METHOD_INFO(C, H,  3, Result, ClearInitialLaunchSettingsCompletionTime,  (),                                                                                                                                                              hos::Version_3_0_0)                       \
-        AMS_SF_METHOD_INFO(C, H,  4, Result, UpdatePowerOnTime,                         (),                                                                                                                                                              hos::Version_3_0_0)                       \
-        AMS_SF_METHOD_INFO(C, H,  5, Result, UpdateAwakeTime,                           (),                                                                                                                                                              hos::Version_3_0_0)                       \
-        AMS_SF_METHOD_INFO(C, H,  6, Result, SubmitMultipleCategoryContext,             (const MultipleCategoryContextEntry &ctx_entry, const ams::sf::InBuffer &str_buffer),                                                                            hos::Version_5_0_0)                       \
-        AMS_SF_METHOD_INFO(C, H,  7, Result, UpdateApplicationLaunchTime,               (),                                                                                                                                                              hos::Version_6_0_0)                       \
-        AMS_SF_METHOD_INFO(C, H,  8, Result, ClearApplicationLaunchTime,                (),                                                                                                                                                              hos::Version_6_0_0)                       \
-        AMS_SF_METHOD_INFO(C, H,  9, Result, SubmitAttachment,                          (ams::sf::Out<AttachmentId> out, const ams::sf::InBuffer &attachment_name, const ams::sf::InBuffer &attachment_data),                                            hos::Version_8_0_0)                       \
-        AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachmentsDeprecated,     (ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer),              hos::Version_8_0_0,  hos::Version_10_2_0) \
-        AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachments,               (ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer, u32 context), hos::Version_11_0_0)                      \
-        AMS_SF_METHOD_INFO(C, H, 11, Result, CreateReport,                              (ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer, u32 context),           hos::Version_11_0_0)
+        AMS_SF_METHOD_INFO(C, H,  2, Result, SetInitialLaunchSettingsCompletionTime,    (const time::SteadyClockTimePoint &time_point),                                                                                                                    hos::Version_3_0_0)                       \
+        AMS_SF_METHOD_INFO(C, H,  3, Result, ClearInitialLaunchSettingsCompletionTime,  (),                                                                                                                                                                hos::Version_3_0_0)                       \
+        AMS_SF_METHOD_INFO(C, H,  4, Result, UpdatePowerOnTime,                         (),                                                                                                                                                                hos::Version_3_0_0)                       \
+        AMS_SF_METHOD_INFO(C, H,  5, Result, UpdateAwakeTime,                           (),                                                                                                                                                                hos::Version_3_0_0)                       \
+        AMS_SF_METHOD_INFO(C, H,  6, Result, SubmitMultipleCategoryContext,             (const MultipleCategoryContextEntry &ctx_entry, const ams::sf::InBuffer &str_buffer),                                                                              hos::Version_5_0_0)                       \
+        AMS_SF_METHOD_INFO(C, H,  7, Result, UpdateApplicationLaunchTime,               (),                                                                                                                                                                hos::Version_6_0_0)                       \
+        AMS_SF_METHOD_INFO(C, H,  8, Result, ClearApplicationLaunchTime,                (),                                                                                                                                                                hos::Version_6_0_0)                       \
+        AMS_SF_METHOD_INFO(C, H,  9, Result, SubmitAttachment,                          (ams::sf::Out<AttachmentId> out, const ams::sf::InBuffer &attachment_name, const ams::sf::InBuffer &attachment_data),                                              hos::Version_8_0_0)                       \
+        AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachmentsDeprecated,     (ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer),                hos::Version_8_0_0,  hos::Version_10_2_0) \
+        AMS_SF_METHOD_INFO(C, H, 10, Result, CreateReportWithAttachments,               (ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &attachment_ids_buffer, Result result), hos::Version_11_0_0)                      \
+        AMS_SF_METHOD_INFO(C, H, 11, Result, CreateReport,                              (ReportType report_type, const ams::sf::InBuffer &ctx_buffer, const ams::sf::InBuffer &str_buffer, const ams::sf::InBuffer &meta_buffer, Result result),           hos::Version_11_0_0)
 
 
     AMS_SF_DEFINE_INTERFACE(IContext, AMS_ERPT_I_CONTEXT_INTERFACE_INFO)

libraries/libstratosphere/include/stratosphere/err/err_error_context.hpp

@@ -42,4 +42,52 @@ namespace ams::err {
     static_assert(sizeof(ErrorContext) == 0x200);
     static_assert(util::is_pod<ErrorContext>::value);
 
+    struct ContextDescriptor {
+        int value;
+
+        constexpr ALWAYS_INLINE bool operator==(const ContextDescriptor &rhs) const { return this->value == rhs.value; }
+        constexpr ALWAYS_INLINE bool operator!=(const ContextDescriptor &rhs) const { return this->value != rhs.value; }
+        constexpr ALWAYS_INLINE bool operator< (const ContextDescriptor &rhs) const { return this->value <  rhs.value; }
+        constexpr ALWAYS_INLINE bool operator<=(const ContextDescriptor &rhs) const { return this->value <= rhs.value; }
+        constexpr ALWAYS_INLINE bool operator> (const ContextDescriptor &rhs) const { return this->value >  rhs.value; }
+        constexpr ALWAYS_INLINE bool operator>=(const ContextDescriptor &rhs) const { return this->value >= rhs.value; }
+    };
+
+    constexpr inline const ContextDescriptor InvalidContextDescriptor{ -1 };
+
+    namespace impl {
+
+        constexpr inline const ContextDescriptor ContextDescriptorMin{ 0x001 };
+        constexpr inline const ContextDescriptor ContextDescriptorMax{ 0x1FF };
+
+    }
+
+    constexpr Result MakeResultWithContextDescriptor(Result result, ContextDescriptor descriptor) {
+        /* Check pre-conditions. */
+        AMS_ASSERT(R_FAILED(result));
+        AMS_ASSERT(descriptor != InvalidContextDescriptor);
+        AMS_ASSERT(impl::ContextDescriptorMin <= descriptor && descriptor <= impl::ContextDescriptorMax);
+
+        return result::impl::ResultInternalAccessor::MergeReserved(result, descriptor.value | 0x200);
+    }
+
+    constexpr ContextDescriptor GetContextDescriptorFromResult(Result result) {
+        /* Check pre-conditions. */
+        AMS_ASSERT(R_FAILED(result));
+
+        /* Get reserved bits. */
+        const auto reserved = result::impl::ResultInternalAccessor::GetReserved(result);
+        if ((reserved & 0x200) != 0x200) {
+            return InvalidContextDescriptor;
+        }
+
+        /* Check the descriptor value. */
+        const ContextDescriptor descriptor{static_cast<decltype(ContextDescriptor{}.value)>(reserved & ~0x200)};
+        if (!(impl::ContextDescriptorMin <= descriptor && descriptor <= impl::ContextDescriptorMax)) {
+            return InvalidContextDescriptor;
+        }
+
+        return descriptor;
+    }
+
 }

libraries/libstratosphere/include/stratosphere/fs.hpp

@@ -35,12 +35,11 @@
 #include <stratosphere/fs/fs_substorage.hpp>
 #include <stratosphere/fs/fs_memory_storage.hpp>
 #include <stratosphere/fs/fs_remote_storage.hpp>
-#include <stratosphere/fs/fs_file_storage.hpp>
+#include <stratosphere/fs/common/fs_file_storage.hpp>
 #include <stratosphere/fs/fs_query_range.hpp>
 #include <stratosphere/fs/fs_speed_emulation.hpp>
 #include <stratosphere/fs/impl/fs_common_mount_name.hpp>
 #include <stratosphere/fs/fs_mount.hpp>
-#include <stratosphere/fs/fs_path_tool.hpp>
 #include <stratosphere/fs/fs_path_utils.hpp>
 #include <stratosphere/fs/fs_filesystem_utils.hpp>
 #include <stratosphere/fs/fs_romfs_filesystem.hpp>
@@ -60,4 +59,5 @@
 #include <stratosphere/fs/fs_sd_card.hpp>
 #include <stratosphere/fs/fs_signed_system_partition.hpp>
 #include <stratosphere/fs/fs_system_data.hpp>
+#include <stratosphere/fs/fs_program_index_map_info.hpp>
 #include <stratosphere/fs/impl/fs_access_log_impl.hpp>