git subrepo push libraries

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

README.md

@@ -3,7 +3,7 @@
 =====
 
 ![License](https://img.shields.io/badge/License-GPLv2-blue.svg)
-[![Chat on Discord](https://camo.githubusercontent.com/b4175720ede4f2621aa066ffbabb70ae30044679/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f636861742d446973636f72642d627269676874677265656e2e737667)](https://discordapp.com/invite/ZdqEhed)
+[![Chat on Discord](https://img.shields.io/badge/Discord-5865f2?logo=discord&logoColor=white)](https://discordapp.com/invite/ZdqEhed)
 
 Atmosphère is a work-in-progress customized firmware for the Nintendo Switch.
 
@@ -27,7 +27,6 @@ This software is licensed under the terms of the GPLv2, with exemptions for spec
 You can find a copy of the license in the [LICENSE file](LICENSE).
 
 Exemptions:
-* The [yuzu Nintendo Switch emulator](https://github.com/yuzu-emu/yuzu) and the [Ryujinx Team and Contributors](https://github.com/orgs/Ryujinx) are exempt from GPLv2 licensing. They are permitted, each at their individual discretion, to instead license any source code authored for the Atmosphère project as either GPLv2 or later or the [MIT license](https://github.com/Atmosphere-NX/Atmosphere/blob/master/docs/licensing_exemptions/MIT_LICENSE). In doing so, they may alter, supplement, or entirely remove the copyright notice for each file they choose to relicense. Neither the Atmosphère project nor its individual contributors shall assert their moral rights against any of the aforementioned projects.
 * [Nintendo](https://github.com/Nintendo) is exempt from GPLv2 licensing and may (at its option) instead license any source code authored for the Atmosphère project under the Zero-Clause BSD license.
 
 Credits

atmosphere.mk

@@ -84,7 +84,7 @@ dist-no-debug: package3 $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000034
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000036
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000037
-	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000003c
+	#mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000003c
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000042
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000420
 	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000b240
@@ -98,7 +98,7 @@ dist-no-debug: package3 $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
 	cp stratosphere/fatal/$(ATMOSPHERE_OUT_DIR)/fatal.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000034/exefs.nsp
 	cp stratosphere/creport/$(ATMOSPHERE_OUT_DIR)/creport.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000036/exefs.nsp
 	cp stratosphere/ro/$(ATMOSPHERE_OUT_DIR)/ro.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000037/exefs.nsp
-	cp stratosphere/jpegdec/$(ATMOSPHERE_OUT_DIR)/jpegdec.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000003c/exefs.nsp
+	#cp stratosphere/jpegdec/$(ATMOSPHERE_OUT_DIR)/jpegdec.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000003c/exefs.nsp
 	cp stratosphere/pgl/$(ATMOSPHERE_OUT_DIR)/pgl.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000042/exefs.nsp
 	cp stratosphere/LogManager/$(ATMOSPHERE_OUT_DIR)/LogManager.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000420/exefs.nsp
 	cp stratosphere/htc/$(ATMOSPHERE_OUT_DIR)/htc.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000b240/exefs.nsp

docs/changelog.md

@@ -1,4 +1,26 @@
 # Changelog
+## 1.7.0
++ Basic support was added for 18.0.0.
+  + The console should boot and atmosphère should be fully functional. However, not all modules have been fully updated to reflect the latest changes.
+    + There shouldn't be anything user visible resulting from this, but it will be addressed in a future atmosphère update, once I am not traveling so much.
+  + `exosphère` was updated to reflect the latest official secure monitor behavior.
+  + `mesosphère` was updated to reflect the latest official kernel behavior.
+  + `spl` was updated to reflect the latest official behavior.
++ `fusee`'s no longer supports applying IPS patches to KIPs.
+  + The only KIPs that are ever present are a) atmosphère modules, b) custom system modules, or c) FS.
+  + The IPS subsystem was originally designed to make nogc patches work for FS, but these are now internal, and it appears the literal only kip patches that exist are for piracy.
+    + I could not find any kip patches posted anywhere made for any other purpose.
+  + It fundamentally does not make sense to slow down boot for every normal user for a feature that has no actual use-case, especially when `fusee` seeks to be a minimal bootloader.
++ Minor improvements were made to atmosphere's gdbstub, including:
+  + Support was added for QStartNoAckMode.
+  + An issue was fixed that could cause a fatal error when creating too many breakpoints.
++ A number of minor issues were fixed and improvements were made, including:
+  + `pt-BR` (`PortugueseBr`) is now accepted as a valid language when overriding game locales.
+  + A bug was fixed that could cause atmosphere to incorrectly serialize output object IDs over IPC when using domain objects.
+  + A bug was fixed in `pm`'s resource limit boost logic that could potentially cause legitimate boosts to fail in certain circumstances.
+  + `loader`/`ro` will now throw a fatal error when using invalid IPS patches that go out of bounds, instead of corrupting memory.
+  + Support was fixed for booting using a memory configuration of half of the true available memory (e.g. forcing a 4GB configuration on an 8GB board).
++ General system stability improvements to enhance the user's experience.
 ## 1.6.2
 + Support was finished for 17.0.0.
   + `erpt` was updated to support the latest official behavior.

emummc/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/m4xw/emummc
 	branch = develop
-	commit = 9513a5412057b1f1bc44ed8e717c57c726763a88
-	parent = e4d08ae0c5342cdb0875d164522a63ec9d233052
+	commit = 832b2442685b45b086697ffe09c5fde05d7444e9
+	parent = 3ccb0ae02bc06769f44d61233bf177301ba9d5f3
 	method = merge
 	cmdver = 0.4.1

emummc/README.md

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

emummc/source/FS/FS_offsets.c

@@ -69,6 +69,8 @@
 #include "offsets/1603_exfat.h"
 #include "offsets/1700.h"
 #include "offsets/1700_exfat.h"
+#include "offsets/1800.h"
+#include "offsets/1800_exfat.h"
 #include "../utils/fatal.h"
 
 #define GET_OFFSET_STRUCT_NAME(vers) g_offsets##vers
@@ -149,6 +151,8 @@ DEFINE_OFFSET_STRUCT(_1603);
 DEFINE_OFFSET_STRUCT(_1603_EXFAT);
 DEFINE_OFFSET_STRUCT(_1700);
 DEFINE_OFFSET_STRUCT(_1700_EXFAT);
+DEFINE_OFFSET_STRUCT(_1800);
+DEFINE_OFFSET_STRUCT(_1800_EXFAT);
 
 const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
     switch (version) {
@@ -258,6 +262,10 @@ const fs_offsets_t *get_fs_offsets(enum FS_VER version) {
             return &(GET_OFFSET_STRUCT_NAME(_1700));
         case FS_VER_17_0_0_EXFAT:
             return &(GET_OFFSET_STRUCT_NAME(_1700_EXFAT));
+        case FS_VER_18_0_0:
+            return &(GET_OFFSET_STRUCT_NAME(_1800));
+        case FS_VER_18_0_0_EXFAT:
+            return &(GET_OFFSET_STRUCT_NAME(_1800_EXFAT));
         default:
             fatal_abort(Fatal_UnknownVersion);
     }

emummc/source/FS/FS_versions.h

@@ -101,6 +101,9 @@ enum FS_VER
     FS_VER_17_0_0,
     FS_VER_17_0_0_EXFAT,
 
+    FS_VER_18_0_0,
+    FS_VER_18_0_0_EXFAT,
+
     FS_VER_MAX,
 };
 

emummc/source/FS/offsets/1800.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019 m4xw <m4x@m4xw.net>
+ * Copyright (c) 2019 Atmosphere-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __FS_1800_H__
+#define __FS_1800_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_1800_SDMMC_ACCESSOR_GC   0x18AB00
+#define FS_OFFSET_1800_SDMMC_ACCESSOR_SD   0x18C800
+#define FS_OFFSET_1800_SDMMC_ACCESSOR_NAND 0x18AFE0
+
+// Hooks
+#define FS_OFFSET_1800_SDMMC_WRAPPER_READ  0x186A50
+#define FS_OFFSET_1800_SDMMC_WRAPPER_WRITE 0x186AB0
+#define FS_OFFSET_1800_RTLD                0x2A3A4
+#define FS_OFFSET_1800_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x44)))
+
+#define FS_OFFSET_1800_CLKRST_SET_MIN_V_CLK_RATE 0x1A77D0
+
+// Misc funcs
+#define FS_OFFSET_1800_LOCK_MUTEX          0x17FCC0
+#define FS_OFFSET_1800_UNLOCK_MUTEX        0x17FD10
+
+#define FS_OFFSET_1800_SDMMC_WRAPPER_CONTROLLER_OPEN  0x186A10
+#define FS_OFFSET_1800_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x186A30
+
+// Misc Data
+#define FS_OFFSET_1800_SD_MUTEX            0xFD13F0
+#define FS_OFFSET_1800_NAND_MUTEX          0xFCCB28
+#define FS_OFFSET_1800_ACTIVE_PARTITION    0xFCCB68
+#define FS_OFFSET_1800_SDMMC_DAS_HANDLE    0xFB1950
+
+// NOPs
+#define FS_OFFSET_1800_SD_DAS_INIT         0x28F24
+
+// Nintendo Paths
+#define FS_OFFSET_1800_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x00068B08, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x000758DC, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0007C77C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x000905C4, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_1800_H__

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019 m4xw <m4x@m4xw.net>
+ * Copyright (c) 2019 Atmosphere-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __FS_1800_EXFAT_H__
+#define __FS_1800_EXFAT_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_1800_EXFAT_SDMMC_ACCESSOR_GC   0x195B90
+#define FS_OFFSET_1800_EXFAT_SDMMC_ACCESSOR_SD   0x197890
+#define FS_OFFSET_1800_EXFAT_SDMMC_ACCESSOR_NAND 0x196070
+
+// Hooks
+#define FS_OFFSET_1800_EXFAT_SDMMC_WRAPPER_READ  0x191AE0
+#define FS_OFFSET_1800_EXFAT_SDMMC_WRAPPER_WRITE 0x191B40
+#define FS_OFFSET_1800_EXFAT_RTLD                0x2A3A4
+#define FS_OFFSET_1800_EXFAT_RTLD_DESTINATION    ((uintptr_t)(INT64_C(-0x44)))
+
+#define FS_OFFSET_1800_EXFAT_CLKRST_SET_MIN_V_CLK_RATE 0x1B2860
+
+// Misc funcs
+#define FS_OFFSET_1800_EXFAT_LOCK_MUTEX          0x18AD50
+#define FS_OFFSET_1800_EXFAT_UNLOCK_MUTEX        0x18ADA0
+
+#define FS_OFFSET_1800_EXFAT_SDMMC_WRAPPER_CONTROLLER_OPEN  0x191AA0
+#define FS_OFFSET_1800_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x191AC0
+
+// Misc Data
+#define FS_OFFSET_1800_EXFAT_SD_MUTEX            0xFE33F0
+#define FS_OFFSET_1800_EXFAT_NAND_MUTEX          0xFDEB28
+#define FS_OFFSET_1800_EXFAT_ACTIVE_PARTITION    0xFDEB68
+#define FS_OFFSET_1800_EXFAT_SDMMC_DAS_HANDLE    0xFBE950
+
+// NOPs
+#define FS_OFFSET_1800_EXFAT_SD_DAS_INIT         0x28F24
+
+// Nintendo Paths
+#define FS_OFFSET_1800_EXFAT_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x00068B08, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x000758DC, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0007C77C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x000905C4, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_1800_EXFAT_H__

exosphere/program/source/boot/secmon_boot_key_data.s

@@ -85,10 +85,10 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 /* We can get away with only including latest because exosphere supports newer-than-expected master key in engine. */
 /* TODO: Update on next change of keys. */
 /* Mariko Development Master Kek Source. */
-.byte 0x43, 0xDB, 0x9D, 0x88, 0xDB, 0x38, 0xE9, 0xBF, 0x3D, 0xD7, 0x83, 0x39, 0xEF, 0xB1, 0x4F, 0xA7
+.byte 0xE4, 0x45, 0xD0, 0x14, 0xA0, 0xE5, 0xE9, 0x4B, 0xFE, 0x76, 0xF4, 0x29, 0x41, 0xBB, 0x64, 0xED
 
 /* Mariko Production Master Kek Source. */
-.byte 0x8D, 0xEE, 0x9E, 0x11, 0x36, 0x3A, 0x9B, 0x0A, 0x6A, 0xC7, 0xBB, 0xE9, 0xD1, 0x03, 0xF7, 0x80
+.byte 0x4F, 0x41, 0x3C, 0x3B, 0xFB, 0x6A, 0x01, 0x2A, 0x68, 0x9F, 0x83, 0xE9, 0x53, 0xBD, 0x16, 0xD2
 
 /* Development Master Key Vectors. */
 .byte 0x46, 0x22, 0xB4, 0x51, 0x9A, 0x7E, 0xA7, 0x7F, 0x62, 0xA1, 0x1F, 0x8F, 0xC5, 0x3A, 0xDB, 0xFE /* Zeroes encrypted with Master Key 00. */
@@ -108,6 +108,7 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0xD6, 0x80, 0x98, 0xC0, 0xFA, 0xC7, 0x13, 0xCB, 0x93, 0xD2, 0x0B, 0x82, 0x4C, 0xA1, 0x7B, 0x8D /* Master key 0D encrypted with Master key 0E. */
 .byte 0x78, 0x66, 0x19, 0xBD, 0x86, 0xE7, 0xC1, 0x09, 0x9B, 0x6F, 0x92, 0xB2, 0x58, 0x7D, 0xCF, 0x26 /* Master key 0E encrypted with Master key 0F. */
 .byte 0x39, 0x1E, 0x7E, 0xF8, 0x7E, 0x73, 0xEA, 0x6F, 0xAF, 0x00, 0x3A, 0xB4, 0xAA, 0xB8, 0xB7, 0x59 /* Master key 0F encrypted with Master key 10. */
+.byte 0x0C, 0x75, 0x39, 0x15, 0x53, 0xEA, 0x81, 0x11, 0xA3, 0xE0, 0xDC, 0x3D, 0x0E, 0x76, 0xC6, 0xB8 /* Master key 10 encrypted with Master key 11. */
 
 /* Production Master Key Vectors. */
 .byte 0x0C, 0xF0, 0x59, 0xAC, 0x85, 0xF6, 0x26, 0x65, 0xE1, 0xE9, 0x19, 0x55, 0xE6, 0xF2, 0x67, 0x3D /* Zeroes encrypted with Master Key 00. */
@@ -127,6 +128,7 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0xB1, 0x81, 0xA6, 0x0D, 0x72, 0xC7, 0xEE, 0x15, 0x21, 0xF3, 0xC0, 0xB5, 0x6B, 0x61, 0x6D, 0xE7 /* Master key 0D encrypted with Master key 0E. */
 .byte 0xAF, 0x11, 0x4C, 0x67, 0x17, 0x7A, 0x52, 0x43, 0xF7, 0x70, 0x2F, 0xC7, 0xEF, 0x81, 0x72, 0x16 /* Master key 0E encrypted with Master key 0F. */
 .byte 0x25, 0x12, 0x8B, 0xCB, 0xB5, 0x46, 0xA1, 0xF8, 0xE0, 0x52, 0x15, 0xB7, 0x0B, 0x57, 0x00, 0xBD /* Master key 0F encrypted with Master key 10. */
+.byte 0x58, 0x15, 0xD2, 0xF6, 0x8A, 0xE8, 0x19, 0xAB, 0xFB, 0x2D, 0x52, 0x9D, 0xE7, 0x55, 0xF3, 0x93 /* Master key 10 encrypted with Master key 11. */
 
 /* Device Master Key Source Sources. */
 .byte 0x8B, 0x4E, 0x1C, 0x22, 0x42, 0x07, 0xC8, 0x73, 0x56, 0x94, 0x08, 0x8B, 0xCC, 0x47, 0x0F, 0x5D /* 4.0.0  Device Master Key Source Source. */
@@ -143,6 +145,7 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0x5E, 0xC9, 0xC5, 0x0A, 0xD0, 0x5F, 0x8B, 0x7B, 0xA7, 0x39, 0xEA, 0xBC, 0x60, 0x0F, 0x74, 0xE6 /* 15.0.0 Device Master Key Source Source. */
 .byte 0xEA, 0x90, 0x6E, 0xA8, 0xAE, 0x92, 0x99, 0x64, 0x36, 0xC1, 0xF3, 0x1C, 0xC6, 0x32, 0x83, 0x8C /* 16.0.0 Device Master Key Source Source. */
 .byte 0xDA, 0xB9, 0xD6, 0x77, 0x52, 0x2D, 0x1F, 0x78, 0x73, 0xC9, 0x98, 0x5B, 0x06, 0xFE, 0xA0, 0x52 /* 17.0.0 Device Master Key Source Source. */
+.byte 0x14, 0xF5, 0xA5, 0xD0, 0x73, 0x6D, 0x44, 0x80, 0x5F, 0x31, 0x5A, 0x8F, 0x1E, 0xD4, 0x0D, 0x63 /* 18.0.0 Device Master Key Source Source. */
 
 /* Development Device Master Kek Sources. */
 .byte 0xD6, 0xBD, 0x9F, 0xC6, 0x18, 0x09, 0xE1, 0x96, 0x20, 0x39, 0x60, 0xD2, 0x89, 0x83, 0x31, 0x34 /* 4.0.0  Device Master Kek Source. */
@@ -159,6 +162,7 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0xAE, 0x05, 0x48, 0x65, 0xAB, 0x17, 0x9D, 0x3D, 0x51, 0xB7, 0x56, 0xBD, 0x9B, 0x0B, 0x5B, 0x6E /* 15.0.0 Device Master Kek Source. */
 .byte 0xFF, 0xF6, 0x4B, 0x0F, 0xFF, 0x0D, 0xC0, 0x4F, 0x56, 0x8A, 0x40, 0x74, 0x67, 0xC5, 0xFE, 0x9F /* 16.0.0 Device Master Kek Source. */
 .byte 0x4E, 0xCE, 0x7B, 0x2A, 0xEA, 0x2E, 0x3D, 0x16, 0xD5, 0x2A, 0xDE, 0xF6, 0xF8, 0x6A, 0x7D, 0x43 /* 17.0.0 Device Master Kek Source. */
+.byte 0x3B, 0x00, 0x89, 0xD7, 0xA9, 0x9E, 0xB7, 0x70, 0x86, 0x00, 0xC3, 0x49, 0x52, 0x8C, 0xA4, 0xAF /* 18.0.0 Device Master Kek Source. */
 
 /* Production Device Master Kek Sources. */
 .byte 0x88, 0x62, 0x34, 0x6E, 0xFA, 0xF7, 0xD8, 0x3F, 0xE1, 0x30, 0x39, 0x50, 0xF0, 0xB7, 0x5D, 0x5D /* 4.0.0  Device Master Kek Source. */
@@ -175,3 +179,4 @@ _ZN3ams6secmon4boot15VolatileKeyDataE:
 .byte 0x7C, 0x30, 0xED, 0x8B, 0x39, 0x25, 0x2C, 0x08, 0x8F, 0x48, 0xDC, 0x28, 0xE6, 0x1A, 0x6B, 0x49 /* 15.0.0 Device Master Kek Source. */
 .byte 0xF0, 0xF3, 0xFF, 0x52, 0x75, 0x2F, 0xBA, 0x4D, 0x09, 0x72, 0x30, 0x89, 0xA9, 0xDF, 0xFE, 0x1F /* 16.0.0 Device Master Kek Source. */
 .byte 0x21, 0xD6, 0x35, 0xF1, 0x0F, 0x7A, 0xF0, 0x5D, 0xDF, 0x79, 0x1C, 0x7A, 0xE4, 0x32, 0x82, 0x9E /* 17.0.0 Device Master Kek Source. */
+.byte 0xE7, 0x85, 0x8C, 0xA2, 0xF4, 0x49, 0xCB, 0x07, 0xD1, 0x8E, 0x48, 0x1B, 0xE8, 0x1E, 0x28, 0x3B /* 18.0.0 Device Master Kek Source. */

exosphere/program/source/boot/secmon_package2.cpp

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

fusee/loader_stub/source/fusee_loader_uncompress.cpp

@@ -96,7 +96,7 @@ namespace ams::nxboot::loader {
     }
 
     void Uncompress(void *dst, size_t dst_size, const void *src, size_t src_size) {
-        /* Create an execute a decompressor. */
+        /* Create and execute a decompressor. */
         Lz4Uncompressor(dst, dst_size, src, src_size).Uncompress();
     }
 

fusee/program/source/fusee_key_derivation.cpp

@@ -23,17 +23,17 @@ namespace ams::nxboot {
 
         alignas(se::AesBlockSize) constexpr inline const u8 MarikoMasterKekSource[se::AesBlockSize] = {
             /* TODO: Update on next change of keys. */
-            0x8D, 0xEE, 0x9E, 0x11, 0x36, 0x3A, 0x9B, 0x0A, 0x6A, 0xC7, 0xBB, 0xE9, 0xD1, 0x03, 0xF7, 0x80
+            0x4F, 0x41, 0x3C, 0x3B, 0xFB, 0x6A, 0x01, 0x2A, 0x68, 0x9F, 0x83, 0xE9, 0x53, 0xBD, 0x16, 0xD2
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 MarikoMasterKekSourceDev[se::AesBlockSize] = {
             /* TODO: Update on next change of keys. */
-            0x43, 0xDB, 0x9D, 0x88, 0xDB, 0x38, 0xE9, 0xBF, 0x3D, 0xD7, 0x83, 0x39, 0xEF, 0xB1, 0x4F, 0xA7
+            0xE4, 0x45, 0xD0, 0x14, 0xA0, 0xE5, 0xE9, 0x4B, 0xFE, 0x76, 0xF4, 0x29, 0x41, 0xBB, 0x64, 0xED
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 EristaMasterKekSource[se::AesBlockSize] = {
             /* TODO: Update on next change of keys. */
-            0x71, 0xB9, 0xA6, 0xC0, 0xFF, 0x97, 0x6B, 0x0C, 0xB4, 0x40, 0xB9, 0xD5, 0x81, 0x5D, 0x81, 0x90
+            0x00, 0x04, 0x5D, 0xF0, 0x4D, 0xCD, 0x14, 0xA3, 0x1C, 0xBF, 0xDE, 0x48, 0x55, 0xBA, 0x35, 0xC1
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 KeyblobKeySource[se::AesBlockSize] = {
@@ -71,6 +71,7 @@ namespace ams::nxboot {
             { 0x5E, 0xC9, 0xC5, 0x0A, 0xD0, 0x5F, 0x8B, 0x7B, 0xA7, 0x39, 0xEA, 0xBC, 0x60, 0x0F, 0x74, 0xE6 }, /* 15.0.0 Device Master Key Source Source. */
             { 0xEA, 0x90, 0x6E, 0xA8, 0xAE, 0x92, 0x99, 0x64, 0x36, 0xC1, 0xF3, 0x1C, 0xC6, 0x32, 0x83, 0x8C }, /* 16.0.0 Device Master Key Source Source. */
             { 0xDA, 0xB9, 0xD6, 0x77, 0x52, 0x2D, 0x1F, 0x78, 0x73, 0xC9, 0x98, 0x5B, 0x06, 0xFE, 0xA0, 0x52 }, /* 17.0.0 Device Master Key Source Source. */
+            { 0x14, 0xF5, 0xA5, 0xD0, 0x73, 0x6D, 0x44, 0x80, 0x5F, 0x31, 0x5A, 0x8F, 0x1E, 0xD4, 0x0D, 0x63 }, /* 18.0.0 Device Master Key Source Source. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 DeviceMasterKekSources[pkg1::OldDeviceMasterKeyCount][se::AesBlockSize] = {
@@ -88,6 +89,7 @@ namespace ams::nxboot {
             { 0x7C, 0x30, 0xED, 0x8B, 0x39, 0x25, 0x2C, 0x08, 0x8F, 0x48, 0xDC, 0x28, 0xE6, 0x1A, 0x6B, 0x49 }, /* 15.0.0 Device Master Kek Source. */
             { 0xF0, 0xF3, 0xFF, 0x52, 0x75, 0x2F, 0xBA, 0x4D, 0x09, 0x72, 0x30, 0x89, 0xA9, 0xDF, 0xFE, 0x1F }, /* 16.0.0 Device Master Kek Source. */
             { 0x21, 0xD6, 0x35, 0xF1, 0x0F, 0x7A, 0xF0, 0x5D, 0xDF, 0x79, 0x1C, 0x7A, 0xE4, 0x32, 0x82, 0x9E }, /* 17.0.0 Device Master Kek Source. */
+            { 0xE7, 0x85, 0x8C, 0xA2, 0xF4, 0x49, 0xCB, 0x07, 0xD1, 0x8E, 0x48, 0x1B, 0xE8, 0x1E, 0x28, 0x3B }, /* 18.0.0 Device Master Kek Source. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 DeviceMasterKekSourcesDev[pkg1::OldDeviceMasterKeyCount][se::AesBlockSize] = {
@@ -105,6 +107,7 @@ namespace ams::nxboot {
             { 0xAE, 0x05, 0x48, 0x65, 0xAB, 0x17, 0x9D, 0x3D, 0x51, 0xB7, 0x56, 0xBD, 0x9B, 0x0B, 0x5B, 0x6E }, /* 15.0.0 Device Master Kek Source. */
             { 0xFF, 0xF6, 0x4B, 0x0F, 0xFF, 0x0D, 0xC0, 0x4F, 0x56, 0x8A, 0x40, 0x74, 0x67, 0xC5, 0xFE, 0x9F }, /* 16.0.0 Device Master Kek Source. */
             { 0x4E, 0xCE, 0x7B, 0x2A, 0xEA, 0x2E, 0x3D, 0x16, 0xD5, 0x2A, 0xDE, 0xF6, 0xF8, 0x6A, 0x7D, 0x43 }, /* 17.0.0 Device Master Kek Source. */
+            { 0x3B, 0x00, 0x89, 0xD7, 0xA9, 0x9E, 0xB7, 0x70, 0x86, 0x00, 0xC3, 0x49, 0x52, 0x8C, 0xA4, 0xAF }, /* 18.0.0 Device Master Kek Source. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 MasterKeySources[pkg1::KeyGeneration_Count][se::AesBlockSize] = {
@@ -125,6 +128,7 @@ namespace ams::nxboot {
             { 0xB1, 0x81, 0xA6, 0x0D, 0x72, 0xC7, 0xEE, 0x15, 0x21, 0xF3, 0xC0, 0xB5, 0x6B, 0x61, 0x6D, 0xE7 }, /* Master key 0D encrypted with Master key 0E. */
             { 0xAF, 0x11, 0x4C, 0x67, 0x17, 0x7A, 0x52, 0x43, 0xF7, 0x70, 0x2F, 0xC7, 0xEF, 0x81, 0x72, 0x16 }, /* Master key 0E encrypted with Master key 0F. */
             { 0x25, 0x12, 0x8B, 0xCB, 0xB5, 0x46, 0xA1, 0xF8, 0xE0, 0x52, 0x15, 0xB7, 0x0B, 0x57, 0x00, 0xBD }, /* Master key 0F encrypted with Master key 10. */
+            { 0x58, 0x15, 0xD2, 0xF6, 0x8A, 0xE8, 0x19, 0xAB, 0xFB, 0x2D, 0x52, 0x9D, 0xE7, 0x55, 0xF3, 0x93 }, /* Master key 10 encrypted with Master key 11. */
         };
 
         alignas(se::AesBlockSize) constexpr inline const u8 MasterKeySourcesDev[pkg1::KeyGeneration_Count][se::AesBlockSize] = {
@@ -145,6 +149,7 @@ namespace ams::nxboot {
             { 0xD6, 0x80, 0x98, 0xC0, 0xFA, 0xC7, 0x13, 0xCB, 0x93, 0xD2, 0x0B, 0x82, 0x4C, 0xA1, 0x7B, 0x8D }, /* Master key 0D encrypted with Master key 0E. */
             { 0x78, 0x66, 0x19, 0xBD, 0x86, 0xE7, 0xC1, 0x09, 0x9B, 0x6F, 0x92, 0xB2, 0x58, 0x7D, 0xCF, 0x26 }, /* Master key 0E encrypted with Master key 0F. */
             { 0x39, 0x1E, 0x7E, 0xF8, 0x7E, 0x73, 0xEA, 0x6F, 0xAF, 0x00, 0x3A, 0xB4, 0xAA, 0xB8, 0xB7, 0x59 }, /* Master key 0F encrypted with Master key 10. */
+            { 0x0C, 0x75, 0x39, 0x15, 0x53, 0xEA, 0x81, 0x11, 0xA3, 0xE0, 0xDC, 0x3D, 0x0E, 0x76, 0xC6, 0xB8 }, /* Master key 10 encrypted with Master key 11. */
         };
 
         alignas(se::AesBlockSize) constinit u8 MasterKeys[pkg1::OldMasterKeyCount][se::AesBlockSize] = {};

fusee/program/source/fusee_package2.cpp

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

fusee/program/source/fusee_setup_horizon.cpp

@@ -259,6 +259,8 @@ namespace ams::nxboot {
                         return ams::TargetFirmware_16_0_0;
                     } else if (std::memcmp(package1 + 0x10, "20230906", 8) == 0) {
                         return ams::TargetFirmware_17_0_0;
+                    } else if (std::memcmp(package1 + 0x10, "20240207", 8) == 0) {
+                        return ams::TargetFirmware_18_0_0;
                     }
                     break;
                 default:

fusee/program/source/fusee_stratosphere.cpp

@@ -171,6 +171,9 @@ namespace ams::nxboot {
             FsVersion_17_0_0,
             FsVersion_17_0_0_Exfat,
 
+            FsVersion_18_0_0,
+            FsVersion_18_0_0_Exfat,
+
             FsVersion_Count,
         };
 
@@ -254,6 +257,9 @@ namespace ams::nxboot {
 
             { 0x27, 0x07, 0x3B, 0xF0, 0xA1, 0xB8, 0xCE, 0x61 }, /* FsVersion_17_0_0 */
             { 0xEE, 0x0F, 0x4B, 0xAC, 0x6D, 0x1F, 0xFC, 0x4B }, /* FsVersion_17_0_0_Exfat */
+
+            { 0x79, 0x5F, 0x5A, 0x5E, 0xB0, 0xC6, 0x77, 0x9E }, /* FsVersion_18_0_0 */
+            { 0x1E, 0x2C, 0x64, 0xB1, 0xCC, 0xE2, 0x78, 0x24 }, /* FsVersion_18_0_0_Exfat */
         };
 
         const InitialProcessBinaryHeader *FindInitialProcessBinary(const pkg2::Package2Header *header, const u8 *data, ams::TargetFirmware target_firmware) {
@@ -385,15 +391,6 @@ namespace ams::nxboot {
             return nullptr;
         }
 
-        InitialProcessMeta *FindInitialProcess(const se::Sha256Hash &hash) {
-            for (InitialProcessMeta *cur = std::addressof(g_initial_process_meta); cur != nullptr; cur = cur->next) {
-                if (std::memcmp(std::addressof(cur->kip_hash), std::addressof(hash), sizeof(hash)) == 0) {
-                    return cur;
-                }
-            }
-            return nullptr;
-        }
-
         u32 GetPatchSegments(const InitialProcessHeader *kip, u32 offset, size_t size) {
             /* Create segment mask. */
             u32 segments = 0;
@@ -474,78 +471,6 @@ namespace ams::nxboot {
             meta->patches_tail = new_patch;
         }
 
-        void AddIps24PatchToKip(InitialProcessMeta *meta, const u8 *ips, s32 size) {
-            while (size > 0) {
-                /* Read offset, stopping at EOF */
-                const u32 offset = (static_cast<u32>(ips[0]) << 16) | (static_cast<u32>(ips[1]) <<  8) | (static_cast<u32>(ips[2]) <<  0);
-                if (offset == 0x454F46) {
-                    break;
-                }
-
-                /* Read size. */
-                const u16 cur_size = (static_cast<u32>(ips[3]) << 8) | (static_cast<u32>(ips[4]) << 0);
-
-                if (cur_size > 0) {
-                    /* Add patch. */
-                    AddPatch(meta, offset, ips + 5, cur_size, false);
-
-                    /*  Advance. */
-                    ips  += (5 + cur_size);
-                    size -= (5 + cur_size);
-                } else {
-                    /* Read RLE size */
-                    const u16 rle_size = (static_cast<u32>(ips[5]) << 8) | (static_cast<u32>(ips[6]) << 0);
-
-                    /* Add patch. */
-                    AddPatch(meta, offset, ips + 7, rle_size, true);
-
-                    /*  Advance. */
-                    ips  += 8;
-                    size -= 8;
-                }
-            }
-        }
-
-        void AddIps32PatchToKip(InitialProcessMeta *meta, const u8 *ips, s32 size) {
-            while (size > 0) {
-                /* Read offset, stopping at EOF */
-                const u32 offset = (static_cast<u32>(ips[0]) << 24) | (static_cast<u32>(ips[1]) << 16) | (static_cast<u32>(ips[2]) <<  8) | (static_cast<u32>(ips[3]) <<  0);
-                if (offset == 0x45454F46) {
-                    break;
-                }
-
-                /* Read size. */
-                const u16 cur_size = (static_cast<u32>(ips[4]) << 8) | (static_cast<u32>(ips[5]) << 0);
-
-                if (cur_size > 0) {
-                    /* Add patch. */
-                    AddPatch(meta, offset, ips + 6, cur_size, false);
-
-                    /*  Advance. */
-                    ips  += (6 + cur_size);
-                    size -= (6 + cur_size);
-                } else {
-                    /* Read RLE size */
-                    const u16 rle_size = (static_cast<u32>(ips[6]) << 8) | (static_cast<u32>(ips[7]) << 0);
-
-                    /* Add patch. */
-                    AddPatch(meta, offset, ips + 8, rle_size, true);
-
-                    /*  Advance. */
-                    ips  += 9;
-                    size -= 9;
-                }
-            }
-        }
-
-        void AddIpsPatchToKip(InitialProcessMeta *meta, const u8 *ips, s32 size) {
-            if (std::memcmp(ips, "PATCH", 5) == 0) {
-                AddIps24PatchToKip(meta, ips + 5, size - 5);
-            } else if (std::memcmp(ips, "IPS32", 5) == 0) {
-                AddIps32PatchToKip(meta, ips + 5, size - 5);
-            }
-        }
-
         constexpr const u8 NogcPatch0[] = {
             0x80
         };
@@ -698,6 +623,14 @@ namespace ams::nxboot {
                     AddPatch(fs_meta, 0x195FA9, NogcPatch0, sizeof(NogcPatch0));
                     AddPatch(fs_meta, 0x170060, NogcPatch1, sizeof(NogcPatch1));
                     break;
+                case FsVersion_18_0_0:
+                    AddPatch(fs_meta, 0x18AF49, NogcPatch0, sizeof(NogcPatch0));
+                    AddPatch(fs_meta, 0x164B50, NogcPatch1, sizeof(NogcPatch1));
+                    break;
+                case FsVersion_18_0_0_Exfat:
+                    AddPatch(fs_meta, 0x195FD9, NogcPatch0, sizeof(NogcPatch0));
+                    AddPatch(fs_meta, 0x16FBE0, NogcPatch1, sizeof(NogcPatch1));
+                    break;
                 default:
                     break;
             }
@@ -891,106 +824,6 @@ namespace ams::nxboot {
             }
 
             /* TODO ams.tma2: add mount_host patches. */
-
-            /* Add generic patches. */
-            {
-                /* Create patch path. */
-                char patch_path[0x220];
-                std::memcpy(patch_path, "sdmc:/atmosphere/kip_patches", 0x1D);
-
-                fs::DirectoryHandle patch_root_dir;
-                if (R_SUCCEEDED(fs::OpenDirectory(std::addressof(patch_root_dir), patch_path))) {
-                    ON_SCOPE_EXIT { fs::CloseDirectory(patch_root_dir); };
-
-                    s64 count;
-                    fs::DirectoryEntry entries[1];
-                    while (R_SUCCEEDED(fs::ReadDirectory(std::addressof(count), entries, patch_root_dir, util::size(entries))) && count > 0) {
-                        /* Check that dir is a dir. */
-                        if (fs::GetEntryType(entries[0]) != fs::DirectoryEntryType_Directory) {
-                            continue;
-                        }
-
-                        /* For compatibility, ignore the old "default_nogc" patches. */
-                        if (std::strcmp(entries[0].file_name, "default_nogc") == 0) {
-                            continue;
-                        }
-
-                        /* Get filename length. */
-                        const int dir_len = std::strlen(entries[0].file_name);
-
-                        /* Adjust patch path. */
-                        patch_path[0x1C] = '/';
-                        std::memcpy(patch_path + 0x1D, entries[0].file_name, dir_len + 1);
-
-                        /* Try to open the patch subdirectory. */
-                        fs::DirectoryHandle patch_dir;
-                        if (R_SUCCEEDED(fs::OpenDirectory(std::addressof(patch_dir), patch_path))) {
-                            ON_SCOPE_EXIT { fs::CloseDirectory(patch_dir); };
-
-                            /* Read patches. */
-                            while (R_SUCCEEDED(fs::ReadDirectory(std::addressof(count), entries, patch_dir, util::size(entries))) && count > 0) {
-                                /* Check that file is a file. */
-                                if (fs::GetEntryType(entries[0]) != fs::DirectoryEntryType_File) {
-                                    continue;
-                                }
-
-                                /* Get filename length. */
-                                const int name_len = std::strlen(entries[0].file_name);
-
-                                /* Adjust patch path. */
-                                patch_path[0x1D + dir_len] = '/';
-                                std::memcpy(patch_path + 0x1D + dir_len + 1, entries[0].file_name, name_len + 1);
-
-                                /* Check that file is "{hex}.ips" file. */
-                                const int path_len = 0x1D + dir_len + 1 + name_len;
-                                if (name_len != 0x44 || std::memcmp(patch_path + path_len - 4, ".ips", 5) != 0) {
-                                    continue;
-                                }
-
-                                /* Check that the filename is hex. */
-                                bool valid_name = true;
-                                se::Sha256Hash patch_name = {};
-                                u32 shift = 4;
-                                for (int i = 0; i < name_len - 4; ++i) {
-                                    const char c = entries[0].file_name[i];
-
-                                    u8 val;
-                                    if ('0' <= c && c <= '9') {
-                                        val = (c - '0');
-                                    } else if ('a' <= c && c <= 'f') {
-                                        val = (c - 'a') + 10;
-                                    } else if ('A' <= c && c <= 'F') {
-                                        val = (c - 'A') + 10;
-                                    } else {
-                                        valid_name = false;
-                                        break;
-                                    }
-
-                                    patch_name.bytes[i >> 1] |= val << shift;
-                                    shift ^= 4;
-                                }
-
-                                /* Ignore invalid patches. */
-                                if (!valid_name) {
-                                    continue;
-                                }
-
-                                /* Find kip for the patch. */
-                                auto *kip_meta = FindInitialProcess(patch_name);
-                                if (kip_meta == nullptr) {
-                                    continue;
-                                }
-
-                                /* Read the ips patch. */
-                                s64 file_size;
-                                if (u8 *ips = static_cast<u8 *>(ReadFile(std::addressof(file_size), patch_path)); ips != nullptr) {
-                                    AddIpsPatchToKip(kip_meta, ips, static_cast<s32>(file_size));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
         }
 
         /* Return the fs version we're using. */

libraries/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/Atmosphere-NX/Atmosphere-libs
 	branch = master
-	commit = 80bf6aeeed03df0871329e1ec32da073a62bf102
-	parent = 9f26419b1a669762d995ebf21ff83b6e1cf56153
+	commit = fadec2981727636ec7ba81d6c83995b7b9782190
+	parent = 410f23035efeb9e1bd399a020334793bba95bf91
 	method = merge
 	cmdver = 0.4.1

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

@@ -37,6 +37,7 @@ namespace ams::pkg1 {
         KeyGeneration_15_0_0 = 0x0E,
         KeyGeneration_16_0_0 = 0x0F,
         KeyGeneration_17_0_0 = 0x10,
+        KeyGeneration_18_0_0 = 0x11,
 
         KeyGeneration_Count,
 

libraries/libexosphere/include/exosphere/pkg2.hpp

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

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

@@ -178,7 +178,7 @@ namespace ams::kern::arch::arm64 {
             }
 
             NOINLINE Result InitializeForKernel(void *table, KVirtualAddress start, KVirtualAddress end);
-            NOINLINE Result InitializeForProcess(ams::svc::CreateProcessFlag as_type, bool enable_aslr, bool enable_das_merge, bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit);
+            NOINLINE Result InitializeForProcess(ams::svc::CreateProcessFlag flags, bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit);
             Result Finalize();
         private:
             Result MapL1Blocks(KProcessAddress virt_addr, KPhysicalAddress phys_addr, size_t num_pages, PageTableEntry entry_template, bool disable_head_merge, PageLinkedList *page_list, bool reuse_ll);

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

@@ -30,6 +30,7 @@ namespace ams::kern::arch::arm64 {
                 KPhysicalAddress phys_addr;
                 size_t block_size;
                 u8 sw_reserved_bits;
+                u8 attr;
 
                 constexpr bool IsHeadMergeDisabled() const { return (this->sw_reserved_bits & PageTableEntry::SoftwareReservedBit_DisableMergeHead) != 0; }
                 constexpr bool IsHeadAndBodyMergeDisabled() const { return (this->sw_reserved_bits & PageTableEntry::SoftwareReservedBit_DisableMergeHeadAndBody) != 0; }

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

@@ -28,8 +28,8 @@ namespace ams::kern::arch::arm64 {
                 m_page_table.Activate(id);
             }
 
-            Result Initialize(ams::svc::CreateProcessFlag as_type, bool enable_aslr, bool enable_das_merge, bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit) {
-                R_RETURN(m_page_table.InitializeForProcess(as_type, enable_aslr, enable_das_merge, from_back, pool, code_address, code_size, system_resource, resource_limit));
+            Result Initialize(ams::svc::CreateProcessFlag flags, bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit) {
+                R_RETURN(m_page_table.InitializeForProcess(flags, from_back, pool, code_address, code_size, system_resource, resource_limit));
             }
 
             void Finalize() { m_page_table.Finalize(); }
@@ -110,12 +110,12 @@ namespace ams::kern::arch::arm64 {
                 R_RETURN(m_page_table.MapRegion(region_type, perm));
             }
 
-            Result MapInsecureMemory(KProcessAddress address, size_t size) {
-                R_RETURN(m_page_table.MapInsecureMemory(address, size));
+            Result MapInsecurePhysicalMemory(KProcessAddress address, size_t size) {
+                R_RETURN(m_page_table.MapInsecurePhysicalMemory(address, size));
             }
 
-            Result UnmapInsecureMemory(KProcessAddress address, size_t size) {
-                R_RETURN(m_page_table.UnmapInsecureMemory(address, size));
+            Result UnmapInsecurePhysicalMemory(KProcessAddress address, size_t size) {
+                R_RETURN(m_page_table.UnmapInsecurePhysicalMemory(address, size));
             }
 
             Result MapPageGroup(KProcessAddress addr, const KPageGroup &pg, KMemoryState state, KMemoryPermission perm) {
@@ -316,6 +316,8 @@ namespace ams::kern::arch::arm64 {
             size_t GetKernelMapRegionSize() const { return m_page_table.GetKernelMapRegionSize(); }
             size_t GetAliasCodeRegionSize() const { return m_page_table.GetAliasCodeRegionSize(); }
 
+            size_t GetAliasRegionExtraSize() const { return m_page_table.GetAliasRegionExtraSize(); }
+
             size_t GetNormalMemorySize() const { return m_page_table.GetNormalMemorySize(); }
 
             size_t GetCodeSize() const { return m_page_table.GetCodeSize(); }

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

@@ -16,11 +16,10 @@
 #pragma once
 #include <mesosphere/kern_common.hpp>
 #include <mesosphere/kern_select_cpu.hpp>
-#include <mesosphere/kern_select_interrupt_manager.hpp>
 
 namespace ams::kern::arch::arm64::smc {
 
-    template<int SmcId, bool DisableInterrupt>
+    template<int SmcId>
     void SecureMonitorCall(u64 *buf) {
         /* Load arguments into registers. */
         register u64 x0 asm("x0") = buf[0];
@@ -32,34 +31,18 @@ namespace ams::kern::arch::arm64::smc {
         register u64 x6 asm("x6") = buf[6];
         register u64 x7 asm("x7") = buf[7];
 
+        /* Backup the current thread pointer. */
+        const uintptr_t current_thread_pointer_value = cpu::GetCurrentThreadPointerValue();
+
         /* Perform the call. */
-        if constexpr (DisableInterrupt) {
-            KScopedInterruptDisable di;
+        __asm__ __volatile__("smc %c[smc_id]"
+                            : "+r"(x0), "+r"(x1), "+r"(x2), "+r"(x3), "+r"(x4), "+r"(x5), "+r"(x6), "+r"(x7)
+                            : [smc_id]"i"(SmcId)
+                            : "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "cc", "memory"
+                            );
 
-            /* Backup the current thread pointer. */
-            const uintptr_t current_thread_pointer_value = cpu::GetCurrentThreadPointerValue();
-
-            __asm__ __volatile__("smc %c[smc_id]"
-                                : "+r"(x0), "+r"(x1), "+r"(x2), "+r"(x3), "+r"(x4), "+r"(x5), "+r"(x6), "+r"(x7)
-                                : [smc_id]"i"(SmcId)
-                                : "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "cc", "memory"
-                                );
-
-            /* Restore the current thread pointer into X18. */
-            cpu::SetCurrentThreadPointerValue(current_thread_pointer_value);
-        } else {
-            /* Backup the current thread pointer. */
-            const uintptr_t current_thread_pointer_value = cpu::GetCurrentThreadPointerValue();
-
-            __asm__ __volatile__("smc %c[smc_id]"
-                                : "+r"(x0), "+r"(x1), "+r"(x2), "+r"(x3), "+r"(x4), "+r"(x5), "+r"(x6), "+r"(x7)
-                                : [smc_id]"i"(SmcId)
-                                : "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "cc", "memory"
-                                );
-
-            /* Restore the current thread pointer into X18. */
-            cpu::SetCurrentThreadPointerValue(current_thread_pointer_value);
-        }
+        /* Restore the current thread pointer into X18. */
+        cpu::SetCurrentThreadPointerValue(current_thread_pointer_value);
 
         /* Store arguments to output. */
         buf[0] = x0;
@@ -78,18 +61,18 @@ namespace ams::kern::arch::arm64::smc {
         PsciFunction_CpuOn      = 0xC4000003,
     };
 
-    template<int SmcId, bool DisableInterrupt>
+    template<int SmcId>
     u64 PsciCall(PsciFunction function, u64 x1 = 0, u64 x2 = 0, u64 x3 = 0, u64 x4 = 0, u64 x5 = 0, u64 x6 = 0, u64 x7 = 0) {
         ams::svc::lp64::SecureMonitorArguments args = { { function, x1, x2, x3, x4, x5, x6, x7 } };
 
-        SecureMonitorCall<SmcId, DisableInterrupt>(args.r);
+        SecureMonitorCall<SmcId>(args.r);
 
         return args.r[0];
     }
 
-    template<int SmcId, bool DisableInterrupt>
+    template<int SmcId>
     u64 CpuOn(u64 core_id, uintptr_t entrypoint, uintptr_t arg) {
-        return PsciCall<SmcId, DisableInterrupt>(PsciFunction_CpuOn, core_id, entrypoint, arg);
+        return PsciCall<SmcId>(PsciFunction_CpuOn, core_id, entrypoint, arg);
     }
 
 }

libraries/libmesosphere/include/mesosphere/kern_initial_process.hpp

@@ -32,6 +32,7 @@ namespace ams::kern {
     struct InitialProcessBinaryLayout {
         uintptr_t address;
         uintptr_t _08;
+        uintptr_t kern_address;
     };
 
     struct InitialProcessBinaryLayoutWithSize {

libraries/libmesosphere/include/mesosphere/kern_k_auto_object.hpp

@@ -358,7 +358,7 @@ namespace ams::kern {
             void Detach() {
                 /* Close our object, if we have one. */
                 if (T * const object = m_object; AMS_LIKELY(object != nullptr)) {
-                    /* Set our object to a debug sentinel value, which will cause crash if accessed. */
+                    /* Set our object to a debug sentinel value, which will cause a crash if accessed. */
                     m_object = reinterpret_cast<T *>(1);
 
                     /* Close reference to our object. */

libraries/libmesosphere/include/mesosphere/kern_k_memory_block.hpp

@@ -177,7 +177,7 @@ namespace ams::kern {
     };
 
     constexpr KMemoryPermission ConvertToKMemoryPermission(ams::svc::MemoryPermission perm) {
-        return static_cast<KMemoryPermission>((util::ToUnderlying(perm) & KMemoryPermission_UserMask) | KMemoryPermission_KernelRead | ((util::ToUnderlying(perm) & KMemoryPermission_UserWrite) << KMemoryPermission_KernelShift) | (perm == ams::svc::MemoryPermission_None ? KMemoryPermission_NotMapped : KMemoryPermission_None));
+        return static_cast<KMemoryPermission>((util::ToUnderlying(perm) & KMemoryPermission_UserMask) | KMemoryPermission_KernelRead | ((util::ToUnderlying(perm) & ams::svc::MemoryPermission_Write) ? KMemoryPermission_KernelWrite : KMemoryPermission_None) | (perm == ams::svc::MemoryPermission_None ? KMemoryPermission_NotMapped : KMemoryPermission_None));
     }
 
     enum KMemoryAttribute : u8 {

libraries/libmesosphere/include/mesosphere/kern_k_memory_manager.hpp

@@ -185,7 +185,7 @@ namespace ams::kern {
                 }
             }
 
-            Result AllocatePageGroupImpl(KPageGroup *out, size_t num_pages, Pool pool, Direction dir, bool unoptimized, bool random);
+            Result AllocatePageGroupImpl(KPageGroup *out, size_t num_pages, Pool pool, Direction dir, bool unoptimized, bool random, s32 min_heap_index);
         public:
             KMemoryManager()
                 : m_pool_locks(), m_pool_managers_head(), m_pool_managers_tail(), m_managers(), m_num_managers(), m_optimized_process_ids(), m_has_optimized_process()
@@ -199,7 +199,7 @@ namespace ams::kern {
             NOINLINE void FinalizeOptimizedMemory(u64 process_id, Pool pool);
 
             NOINLINE KPhysicalAddress AllocateAndOpenContinuous(size_t num_pages, size_t align_pages, u32 option);
-            NOINLINE Result AllocateAndOpen(KPageGroup *out, size_t num_pages, u32 option);
+            NOINLINE Result AllocateAndOpen(KPageGroup *out, size_t num_pages, size_t align_pages, u32 option);
             NOINLINE Result AllocateForProcess(KPageGroup *out, size_t num_pages, u32 option, u64 process_id, u8 fill_pattern);
 
             Pool GetPool(KPhysicalAddress address) const {

libraries/libmesosphere/include/mesosphere/kern_k_page_group.hpp

@@ -145,6 +145,8 @@ namespace ams::kern {
 
             bool IsEquivalentTo(const KPageGroup &rhs) const;
 
+            Result CopyRangeTo(KPageGroup &out, size_t offset, size_t size) const;
+
             ALWAYS_INLINE bool operator==(const KPageGroup &rhs) const {
                 return this->IsEquivalentTo(rhs);
             }

libraries/libmesosphere/include/mesosphere/kern_k_page_table_base.hpp

@@ -62,18 +62,21 @@ namespace ams::kern {
                     KPhysicalAddress m_address;
                     size_t m_size;
                     bool m_heap;
+                    u8 m_attr;
                 public:
-                    constexpr MemoryRange() : m_address(Null<KPhysicalAddress>), m_size(0), m_heap(false) { /* ... */ }
+                    constexpr MemoryRange() : m_address(Null<KPhysicalAddress>), m_size(0), m_heap(false), m_attr(0) { /* ... */ }
 
-                    void Set(KPhysicalAddress address, size_t size, bool heap) {
+                    void Set(KPhysicalAddress address, size_t size, bool heap, u8 attr) {
                         m_address = address;
                         m_size    = size;
                         m_heap    = heap;
+                        m_attr    = attr;
                     }
 
                     constexpr KPhysicalAddress GetAddress() const { return m_address; }
                     constexpr size_t GetSize() const { return m_size; }
                     constexpr bool IsHeap() const { return m_heap; }
+                    constexpr u8 GetAttribute() const { return m_attr; }
 
                     void Open();
                     void Close();
@@ -86,6 +89,15 @@ namespace ams::kern {
                 MemoryFillValue_Heap  = 'Z',
             };
 
+            enum RegionType {
+                RegionType_KernelMap = 0,
+                RegionType_Stack     = 1,
+                RegionType_Alias     = 2,
+                RegionType_Heap      = 3,
+
+                RegionType_Count,
+            };
+
             enum OperationType {
                 OperationType_Map                                 = 0,
                 OperationType_MapGroup                            = 1,
@@ -165,15 +177,9 @@ namespace ams::kern {
         private:
             KProcessAddress m_address_space_start;
             KProcessAddress m_address_space_end;
-            KProcessAddress m_heap_region_start;
-            KProcessAddress m_heap_region_end;
+            KProcessAddress m_region_starts[RegionType_Count];
+            KProcessAddress m_region_ends[RegionType_Count];
             KProcessAddress m_current_heap_end;
-            KProcessAddress m_alias_region_start;
-            KProcessAddress m_alias_region_end;
-            KProcessAddress m_stack_region_start;
-            KProcessAddress m_stack_region_end;
-            KProcessAddress m_kernel_map_region_start;
-            KProcessAddress m_kernel_map_region_end;
             KProcessAddress m_alias_code_region_start;
             KProcessAddress m_alias_code_region_end;
             KProcessAddress m_code_region_start;
@@ -183,6 +189,7 @@ namespace ams::kern {
             size_t m_mapped_unsafe_physical_memory;
             size_t m_mapped_insecure_memory;
             size_t m_mapped_ipc_server_memory;
+            size_t m_alias_region_extra_size;
             mutable KLightLock m_general_lock;
             mutable KLightLock m_map_physical_memory_lock;
             KLightLock m_device_map_lock;
@@ -203,12 +210,12 @@ namespace ams::kern {
             MemoryFillValue m_stack_fill_value;
         public:
             constexpr explicit KPageTableBase(util::ConstantInitializeTag)
-                : m_address_space_start(Null<KProcessAddress>), m_address_space_end(Null<KProcessAddress>), m_heap_region_start(Null<KProcessAddress>),
-                  m_heap_region_end(Null<KProcessAddress>), m_current_heap_end(Null<KProcessAddress>), m_alias_region_start(Null<KProcessAddress>),
-                  m_alias_region_end(Null<KProcessAddress>), m_stack_region_start(Null<KProcessAddress>), m_stack_region_end(Null<KProcessAddress>),
-                  m_kernel_map_region_start(Null<KProcessAddress>), m_kernel_map_region_end(Null<KProcessAddress>), m_alias_code_region_start(Null<KProcessAddress>),
+                : m_address_space_start(Null<KProcessAddress>), m_address_space_end(Null<KProcessAddress>),
+                  m_region_starts{Null<KProcessAddress>, Null<KProcessAddress>, Null<KProcessAddress>, Null<KProcessAddress>},
+                  m_region_ends{Null<KProcessAddress>, Null<KProcessAddress>, Null<KProcessAddress>, Null<KProcessAddress>},
+                  m_current_heap_end(Null<KProcessAddress>), m_alias_code_region_start(Null<KProcessAddress>),
                   m_alias_code_region_end(Null<KProcessAddress>), m_code_region_start(Null<KProcessAddress>), m_code_region_end(Null<KProcessAddress>),
-                  m_max_heap_size(), m_mapped_physical_memory_size(), m_mapped_unsafe_physical_memory(), m_mapped_insecure_memory(), m_mapped_ipc_server_memory(),
+                  m_max_heap_size(), m_mapped_physical_memory_size(), m_mapped_unsafe_physical_memory(), m_mapped_insecure_memory(), m_mapped_ipc_server_memory(), m_alias_region_extra_size(),
                   m_general_lock(), m_map_physical_memory_lock(), m_device_map_lock(), m_impl(util::ConstantInitialize), m_memory_block_manager(util::ConstantInitialize),
                   m_allocate_option(), m_address_space_width(), m_is_kernel(), m_enable_aslr(), m_enable_device_address_space_merge(),
                   m_memory_block_slab_manager(), m_block_info_manager(), m_resource_limit(), m_cached_physical_linear_region(), m_cached_physical_heap_region(),
@@ -220,7 +227,7 @@ namespace ams::kern {
             explicit KPageTableBase() { /* ... */ }
 
             NOINLINE Result InitializeForKernel(bool is_64_bit, void *table, KVirtualAddress start, KVirtualAddress end);
-            NOINLINE Result InitializeForProcess(ams::svc::CreateProcessFlag as_type, bool enable_aslr, bool enable_device_address_space_merge, bool from_back, KMemoryManager::Pool pool, void *table, KProcessAddress start, KProcessAddress end, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit);
+            NOINLINE Result InitializeForProcess(ams::svc::CreateProcessFlag flags, bool from_back, KMemoryManager::Pool pool, void *table, KProcessAddress start, KProcessAddress end, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit);
 
             void Finalize();
 
@@ -236,7 +243,7 @@ namespace ams::kern {
             }
 
             constexpr bool IsInAliasRegion(KProcessAddress addr, size_t size) const {
-                return this->Contains(addr, size) && m_alias_region_start <= addr && addr + size - 1 <= m_alias_region_end - 1;
+                return this->Contains(addr, size) && m_region_starts[RegionType_Alias] <= addr && addr + size - 1 <= m_region_ends[RegionType_Alias] - 1;
             }
 
             bool IsInUnsafeAliasRegion(KProcessAddress addr, size_t size) const {
@@ -328,7 +335,7 @@ namespace ams::kern {
 
             Result QueryMappingImpl(KProcessAddress *out, KPhysicalAddress address, size_t size, ams::svc::MemoryState state) const;
 
-            Result AllocateAndMapPagesImpl(PageLinkedList *page_list, KProcessAddress address, size_t num_pages, KMemoryPermission perm);
+            Result AllocateAndMapPagesImpl(PageLinkedList *page_list, KProcessAddress address, size_t num_pages, const KPageProperties &properties);
             Result MapPageGroupImpl(PageLinkedList *page_list, KProcessAddress address, const KPageGroup &pg, const KPageProperties properties, bool reuse_ll);
 
             void RemapPageGroup(PageLinkedList *page_list, KProcessAddress address, size_t size, const KPageGroup &pg);
@@ -387,8 +394,8 @@ namespace ams::kern {
             Result UnmapIoRegion(KProcessAddress dst_address, KPhysicalAddress phys_addr, size_t size, ams::svc::MemoryMapping mapping);
             Result MapStatic(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm);
             Result MapRegion(KMemoryRegionType region_type, KMemoryPermission perm);
-            Result MapInsecureMemory(KProcessAddress address, size_t size);
-            Result UnmapInsecureMemory(KProcessAddress address, size_t size);
+            Result MapInsecurePhysicalMemory(KProcessAddress address, size_t size);
+            Result UnmapInsecurePhysicalMemory(KProcessAddress address, size_t size);
 
             Result MapPages(KProcessAddress *out_addr, size_t num_pages, size_t alignment, KPhysicalAddress phys_addr, KProcessAddress region_start, size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
                 R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true, region_start, region_num_pages, state, perm));
@@ -479,24 +486,30 @@ namespace ams::kern {
             }
         public:
             KProcessAddress GetAddressSpaceStart()    const { return m_address_space_start; }
-            KProcessAddress GetHeapRegionStart()      const { return m_heap_region_start; }
-            KProcessAddress GetAliasRegionStart()     const { return m_alias_region_start; }
-            KProcessAddress GetStackRegionStart()     const { return m_stack_region_start; }
-            KProcessAddress GetKernelMapRegionStart() const { return m_kernel_map_region_start; }
+
+            KProcessAddress GetHeapRegionStart()      const { return m_region_starts[RegionType_Heap]; }
+            KProcessAddress GetAliasRegionStart()     const { return m_region_starts[RegionType_Alias]; }
+            KProcessAddress GetStackRegionStart()     const { return m_region_starts[RegionType_Stack]; }
+            KProcessAddress GetKernelMapRegionStart() const { return m_region_starts[RegionType_KernelMap]; }
+
             KProcessAddress GetAliasCodeRegionStart() const { return m_alias_code_region_start; }
 
-            size_t GetAddressSpaceSize()    const { return m_address_space_end     - m_address_space_start; }
-            size_t GetHeapRegionSize()      const { return m_heap_region_end       - m_heap_region_start; }
-            size_t GetAliasRegionSize()     const { return m_alias_region_end      - m_alias_region_start; }
-            size_t GetStackRegionSize()     const { return m_stack_region_end      - m_stack_region_start; }
-            size_t GetKernelMapRegionSize() const { return m_kernel_map_region_end - m_kernel_map_region_start; }
+            size_t GetAddressSpaceSize()    const { return m_address_space_end - m_address_space_start; }
+
+            size_t GetHeapRegionSize()      const { return m_region_ends[RegionType_Heap]      - m_region_starts[RegionType_Heap]; }
+            size_t GetAliasRegionSize()     const { return m_region_ends[RegionType_Alias]     - m_region_starts[RegionType_Alias]; }
+            size_t GetStackRegionSize()     const { return m_region_ends[RegionType_Stack]     - m_region_starts[RegionType_Stack]; }
+            size_t GetKernelMapRegionSize() const { return m_region_ends[RegionType_KernelMap] - m_region_starts[RegionType_KernelMap]; }
+
             size_t GetAliasCodeRegionSize() const { return m_alias_code_region_end - m_alias_code_region_start; }
 
+            size_t GetAliasRegionExtraSize() const { return m_alias_region_extra_size; }
+
             size_t GetNormalMemorySize() const {
                 /* Lock the table. */
                 KScopedLightLock lk(m_general_lock);
 
-                return (m_current_heap_end - m_heap_region_start) + m_mapped_physical_memory_size;
+                return (m_current_heap_end - m_region_starts[RegionType_Heap]) + m_mapped_physical_memory_size;
             }
 
             size_t GetCodeSize() const;

libraries/libmesosphere/include/mesosphere/kern_k_system_control_base.hpp

@@ -53,7 +53,7 @@ namespace ams::kern {
                     static size_t GetRealMemorySize();
                     static size_t GetIntendedMemorySize();
                     static KPhysicalAddress GetKernelPhysicalBaseAddress(KPhysicalAddress base_address);
-                    static void GetInitialProcessBinaryLayout(InitialProcessBinaryLayout *out);
+                    static void GetInitialProcessBinaryLayout(InitialProcessBinaryLayout *out, KPhysicalAddress kern_base_address);
                     static bool ShouldIncreaseThreadResourceLimit();
                     static void TurnOnCpu(u64 core_id, const ams::kern::init::KInitArguments *args);
                     static size_t GetApplicationPoolSize();

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

@@ -223,6 +223,13 @@ namespace ams::kern::arch::arm64 {
                             type = ams::svc::ExceptionType_InstructionAbort;
                             break;
                         case EsrEc_DataAbortEl0:
+                            /* If esr.IFSC is "Alignment Fault", return UnalignedData instead of DataAbort. */
+                            if ((esr & 0x3F) == 0b100001) {
+                                type = ams::svc::ExceptionType_UnalignedData;
+                            } else {
+                                type = ams::svc::ExceptionType_DataAbort;
+                            }
+                            break;
                         default:
                             type = ams::svc::ExceptionType_DataAbort;
                             break;

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

@@ -365,7 +365,7 @@ namespace ams::kern::arch::arm64 {
                 value = 0;
             }
 
-            /* Set the watchkpoint. */
+            /* Set the watchpoint. */
             switch (name) {
                 case ams::svc::HardwareBreakPointRegisterName_D0:  MESOSPHERE_SET_HW_WATCH_POINT( 0, flags, value);  break;
                 case ams::svc::HardwareBreakPointRegisterName_D1:  MESOSPHERE_SET_HW_WATCH_POINT( 1, flags, value);  break;

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

@@ -207,7 +207,7 @@ namespace ams::kern::arch::arm64 {
         R_SUCCEED();
     }
 
-    Result KPageTable::InitializeForProcess(ams::svc::CreateProcessFlag as_type, bool enable_aslr, bool enable_das_merge, bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit) {
+    Result KPageTable::InitializeForProcess(ams::svc::CreateProcessFlag flags, bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit) {
         /* Get an ASID */
         m_asid = g_asid_manager.Reserve();
         ON_RESULT_FAILURE { g_asid_manager.Release(m_asid); };
@@ -222,10 +222,10 @@ namespace ams::kern::arch::arm64 {
         ON_RESULT_FAILURE_2 { m_manager->Free(new_table); };
 
         /* Initialize our base table. */
-        const size_t as_width = GetAddressSpaceWidth(as_type);
+        const size_t as_width = GetAddressSpaceWidth(flags);
         const KProcessAddress as_start = 0;
         const KProcessAddress as_end   = (1ul << as_width);
-        R_TRY(KPageTableBase::InitializeForProcess(as_type, enable_aslr, enable_das_merge, from_back, pool, GetVoidPointer(new_table), as_start, as_end, code_address, code_size, system_resource, resource_limit));
+        R_TRY(KPageTableBase::InitializeForProcess(flags, from_back, pool, GetVoidPointer(new_table), as_start, as_end, code_address, code_size, system_resource, resource_limit));
 
         /* Note that we've updated the table (since we created it). */
         this->NoteUpdated();
@@ -258,7 +258,7 @@ namespace ams::kern::arch::arm64 {
 
                 /* Begin the traversal. */
                 TraversalContext context;
-                TraversalEntry   cur_entry  = { .phys_addr = Null<KPhysicalAddress>, .block_size = 0, .sw_reserved_bits = 0 };
+                TraversalEntry   cur_entry  = { .phys_addr = Null<KPhysicalAddress>, .block_size = 0, .sw_reserved_bits = 0, .attr = 0 };
                 bool             cur_valid  = false;
                 TraversalEntry   next_entry;
                 bool             next_valid;
@@ -268,7 +268,9 @@ namespace ams::kern::arch::arm64 {
 
                 /* Iterate over entries. */
                 while (true) {
-                    if ((!next_valid && !cur_valid) || (next_valid && cur_valid && next_entry.phys_addr == cur_entry.phys_addr + cur_entry.block_size)) {
+                    /* NOTE: Nintendo really does check next_entry.attr == (cur_entry.attr != 0)...but attr is always zero as of 18.0.0, and this is "probably" for the new console or debug-only anyway, */
+                    /* so we'll implement the weird logic verbatim even though it doesn't match the GetContiguousRange logic. */
+                    if ((!next_valid && !cur_valid) || (next_valid && cur_valid && next_entry.phys_addr == cur_entry.phys_addr + cur_entry.block_size && next_entry.attr == (cur_entry.attr ? 1 : 0))) {
                         cur_entry.block_size += next_entry.block_size;
                     } else {
                         if (cur_valid && IsHeapPhysicalAddressForFinalize(cur_entry.phys_addr)) {

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

@@ -46,12 +46,14 @@ namespace ams::kern::arch::arm64 {
                 out_entry->block_size = L3BlockSize;
             }
             out_entry->sw_reserved_bits = l3_entry->GetSoftwareReservedBits();
+            out_entry->attr             = 0;
 
             return true;
         } else {
             out_entry->phys_addr        = Null<KPhysicalAddress>;
             out_entry->block_size       = L3BlockSize;
             out_entry->sw_reserved_bits = 0;
+            out_entry->attr             = 0;
             return false;
         }
     }
@@ -69,6 +71,7 @@ namespace ams::kern::arch::arm64 {
                 out_entry->block_size = L2BlockSize;
             }
             out_entry->sw_reserved_bits = l2_entry->GetSoftwareReservedBits();
+            out_entry->attr             = 0;
 
             /* Set the output context. */
             out_context->l3_entry = nullptr;
@@ -79,6 +82,8 @@ namespace ams::kern::arch::arm64 {
             out_entry->phys_addr        = Null<KPhysicalAddress>;
             out_entry->block_size       = L2BlockSize;
             out_entry->sw_reserved_bits = 0;
+            out_entry->attr             = 0;
+
             out_context->l3_entry = nullptr;
             return false;
         }
@@ -108,6 +113,8 @@ namespace ams::kern::arch::arm64 {
             out_entry->phys_addr        = Null<KPhysicalAddress>;
             out_entry->block_size       = L1BlockSize;
             out_entry->sw_reserved_bits = 0;
+            out_entry->attr             = 0;
+
             out_context->l2_entry = nullptr;
             out_context->l3_entry = nullptr;
             return false;
@@ -119,6 +126,7 @@ namespace ams::kern::arch::arm64 {
         out_entry->phys_addr        = Null<KPhysicalAddress>;
         out_entry->block_size       = L1BlockSize;
         out_entry->sw_reserved_bits = 0;
+        out_entry->attr             = 0;
         out_context->l1_entry = m_table + m_num_entries;
         out_context->l2_entry = nullptr;
         out_context->l3_entry = nullptr;
@@ -220,6 +228,7 @@ namespace ams::kern::arch::arm64 {
                 out_entry->phys_addr        = Null<KPhysicalAddress>;
                 out_entry->block_size       = L1BlockSize;
                 out_entry->sw_reserved_bits = 0;
+                out_entry->attr             = 0;
                 context->l1_entry = m_table + m_num_entries;
                 context->l2_entry = nullptr;
                 context->l3_entry = nullptr;

libraries/libmesosphere/source/arch/arm64/svc/kern_svc_handlers_asm.s

@@ -68,7 +68,8 @@ _ZN3ams4kern4arch5arm6412SvcHandler64Ev:
 
     /* Check if our disable count allows us to call SVCs. */
     mrs     x10, tpidrro_el0
-    ldrh    w10, [x10, #(THREAD_LOCAL_REGION_DISABLE_COUNT)]
+    add     x10, x10, #(THREAD_LOCAL_REGION_DISABLE_COUNT)
+    ldtrh   w10, [x10]
     cbz     w10, 1f
 
     /* It might not, so check the stack params to see if we must not allow the SVC. */
@@ -352,7 +353,8 @@ _ZN3ams4kern4arch5arm6412SvcHandler32Ev:
 
     /* Check if our disable count allows us to call SVCs. */
     mrs     x10, tpidrro_el0
-    ldrh    w10, [x10, #(THREAD_LOCAL_REGION_DISABLE_COUNT)]
+    add     x10, x10, #(THREAD_LOCAL_REGION_DISABLE_COUNT)
+    ldtrh   w10, [x10]
     cbz     w10, 1f
 
     /* It might not, so check the stack params to see if we must not allow the SVC. */

libraries/libmesosphere/source/arch/arm64/svc/kern_svc_tables.cpp

@@ -142,10 +142,10 @@ namespace ams::kern::svc {
                     /* Get the target firmware. */
                     const auto target_fw = kern::GetTargetFirmware();
 
-                    /* 10.0.0 broke the ABI for QueryIoMapping. */
+                    /* 10.0.0 broke the ABI for QueryIoMapping, and renamed it to QueryMemoryMapping. */
                     if (target_fw < TargetFirmware_10_0_0) {
-                        if (table_64)         { ::ams::kern::svc::PatchSvcTableEntry(table_64,         svc::SvcId_QueryIoMapping, LegacyQueryIoMapping::Call64); }
-                        if (table_64_from_32) { ::ams::kern::svc::PatchSvcTableEntry(table_64_from_32, svc::SvcId_QueryIoMapping, LegacyQueryIoMapping::Call64From32); }
+                        if (table_64)         { ::ams::kern::svc::PatchSvcTableEntry(table_64,         svc::SvcId_QueryMemoryMapping, LegacyQueryIoMapping::Call64); }
+                        if (table_64_from_32) { ::ams::kern::svc::PatchSvcTableEntry(table_64_from_32, svc::SvcId_QueryMemoryMapping, LegacyQueryIoMapping::Call64From32); }
                     }
 
                     /* 6.0.0 broke the ABI for GetFutureThreadInfo, and renamed it to GetDebugFutureThreadInfo. */

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

@@ -296,7 +296,7 @@ namespace ams::kern::board::nintendo::nx {
         /* TODO: Move this into a header for the MC in general. */
         constexpr u32 MemoryControllerConfigurationRegister = 0x70019050;
         u32 config_value;
-        MESOSPHERE_INIT_ABORT_UNLESS(smc::init::ReadWriteRegister(&config_value, MemoryControllerConfigurationRegister, 0, 0));
+        smc::init::ReadWriteRegister(std::addressof(config_value), MemoryControllerConfigurationRegister, 0, 0);
         return static_cast<size_t>(config_value & 0x3FFF) << 20;
     }
 
@@ -387,7 +387,7 @@ namespace ams::kern::board::nintendo::nx {
     }
 
     void KSystemControl::Init::CpuOnImpl(u64 core_id, uintptr_t entrypoint, uintptr_t arg) {
-        MESOSPHERE_INIT_ABORT_UNLESS((::ams::kern::arch::arm64::smc::CpuOn<smc::SmcId_Supervisor, false>(core_id, entrypoint, arg)) == 0);
+        MESOSPHERE_INIT_ABORT_UNLESS((::ams::kern::arch::arm64::smc::CpuOn<smc::SmcId_Supervisor>(core_id, entrypoint, arg)) == 0);
     }
 
     /* Randomness for Initialization. */
@@ -601,8 +601,9 @@ namespace ams::kern::board::nintendo::nx {
 
         if (g_call_smc_on_panic) {
             /* If we should, instruct the secure monitor to display a panic screen. */
-            smc::Panic(0xF00);
+            smc::ShowError(0xF00);
         }
+
         AMS_INFINITE_LOOP();
     }
 

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

@@ -43,7 +43,7 @@ namespace ams::kern::board::nintendo::nx::smc {
         enum FunctionId : u32 {
             FunctionId_GetConfig           = 0xC3000004,
             FunctionId_GenerateRandomBytes = 0xC3000005,
-            FunctionId_Panic               = 0xC3000006,
+            FunctionId_ShowError           = 0xC3000006,
             FunctionId_ConfigureCarveout   = 0xC3000007,
             FunctionId_ReadWriteRegister   = 0xC3000008,
 
@@ -51,122 +51,187 @@ namespace ams::kern::board::nintendo::nx::smc {
             FunctionId_SetConfig           = 0xC3000409,
         };
 
+        constexpr size_t GenerateRandomBytesSizeMax = sizeof(::ams::svc::lp64::SecureMonitorArguments) - sizeof(::ams::svc::lp64::SecureMonitorArguments{}.r[0]);
+
         /* Global lock for generate random bytes. */
         constinit KSpinLock g_generate_random_lock;
 
+        bool TryGetConfigImpl(u64 *out, size_t num_qwords, ConfigItem config_item) {
+            /* Create the arguments .*/
+            ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_GetConfig, static_cast<u32>(config_item) } };
+
+            /* Call into the secure monitor. */
+            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor>(args.r);
+
+            /* If successful, copy the output. */
+            const bool success = static_cast<SmcResult>(args.r[0]) == SmcResult::Success;
+            if (AMS_LIKELY(success)) {
+                for (size_t i = 0; i < num_qwords && i < 7; i++) {
+                    out[i] = args.r[1 + i];
+                }
+            }
+
+            return success;
+        }
+
+        bool SetConfigImpl(ConfigItem config_item, u64 value) {
+            /* Create the arguments .*/
+            ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_SetConfig, static_cast<u32>(config_item), 0, value } };
+
+            /* Call into the secure monitor. */
+            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor>(args.r);
+
+            /* Return whether the call was successful. */
+            return static_cast<SmcResult>(args.r[0]) == SmcResult::Success;
+        }
+
+        bool ReadWriteRegisterImpl(u32 *out, u64 address, u32 mask, u32 value) {
+            /* Create the arguments .*/
+            ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_ReadWriteRegister, address, mask, value } };
+
+            /* Call into the secure monitor. */
+            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor>(args.r);
+
+            /* Unconditionally write the output. */
+            *out = static_cast<u32>(args.r[1]);
+
+            /* Return whether the call was successful. */
+            return static_cast<SmcResult>(args.r[0]) == SmcResult::Success;
+        }
+
+        bool GenerateRandomBytesImpl(void *dst, size_t size) {
+            /* Create the arguments. */
+            ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_GenerateRandomBytes, size } };
+
+            /* Call into the secure monitor. */
+            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor>(args.r);
+
+            /* If successful, copy the output. */
+            const bool success = static_cast<SmcResult>(args.r[0]) == SmcResult::Success;
+            if (AMS_LIKELY(success)) {
+                std::memcpy(dst, std::addressof(args.r[1]), size);
+            }
+
+            return success;
+        }
+
+        bool ConfigureCarveoutImpl(size_t which, uintptr_t address, size_t size) {
+            /* Create the arguments .*/
+            ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_ConfigureCarveout, static_cast<u64>(which), static_cast<u64>(address), static_cast<u64>(size) } };
+
+            /* Call into the secure monitor. */
+            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor>(args.r);
+
+            /* Return whether the call was successful. */
+            return static_cast<SmcResult>(args.r[0]) == SmcResult::Success;
+        }
+
+        bool ShowErrorImpl(u32 color) {
+            /* Create the arguments .*/
+            ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_ShowError, color } };
+
+            /* Call into the secure monitor. */
+            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor>(args.r);
+
+            /* Return whether the call was successful. */
+            return static_cast<SmcResult>(args.r[0]) == SmcResult::Success;
+        }
+
+        void CallSecureMonitorFromUserImpl(ams::svc::lp64::SecureMonitorArguments *args) {
+            /* Call into the secure monitor. */
+            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_User>(args->r);
+        }
+
     }
 
     /* SMC functionality needed for init. */
     namespace init {
 
         void GetConfig(u64 *out, size_t num_qwords, ConfigItem config_item) {
-            ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_GetConfig, static_cast<u32>(config_item) } };
-
-            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor, false>(args.r);
-            MESOSPHERE_INIT_ABORT_UNLESS((static_cast<SmcResult>(args.r[0]) == SmcResult::Success));
-
-            for (size_t i = 0; i < num_qwords && i < 7; i++) {
-                out[i] = args.r[1 + i];
-            }
+            /* Ensure we successfully get the config. */
+            MESOSPHERE_INIT_ABORT_UNLESS(TryGetConfigImpl(out, num_qwords, config_item));
         }
 
         void GenerateRandomBytes(void *dst, size_t size) {
-            /* Call SmcGenerateRandomBytes() */
-            ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_GenerateRandomBytes, size } };
-            MESOSPHERE_INIT_ABORT_UNLESS(size <= sizeof(args) - sizeof(args.r[0]));
+            /* Check that the size is valid. */
+            MESOSPHERE_INIT_ABORT_UNLESS(0 < size && size <= GenerateRandomBytesSizeMax);
 
-            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor, false>(args.r);
-            MESOSPHERE_INIT_ABORT_UNLESS((static_cast<SmcResult>(args.r[0]) == SmcResult::Success));
-
-            /* Copy output. */
-            std::memcpy(dst, std::addressof(args.r[1]), size);
+            /* Ensure we successfully generate the random bytes. */
+            MESOSPHERE_INIT_ABORT_UNLESS(GenerateRandomBytesImpl(dst, size));
         }
 
-        bool ReadWriteRegister(u32 *out, u64 address, u32 mask, u32 value) {
-            ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_ReadWriteRegister, address, mask, value } };
-
-            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor, false>(args.r);
-            MESOSPHERE_INIT_ABORT_UNLESS((static_cast<SmcResult>(args.r[0]) == SmcResult::Success));
-
-            *out = args.r[1];
-
-            return static_cast<SmcResult>(args.r[0]) == SmcResult::Success;
+        void ReadWriteRegister(u32 *out, u64 address, u32 mask, u32 value) {
+            /* Ensure we successfully access the register. */
+            MESOSPHERE_INIT_ABORT_UNLESS(ReadWriteRegisterImpl(out, address, mask, value));
         }
 
     }
 
     bool TryGetConfig(u64 *out, size_t num_qwords, ConfigItem config_item) {
-        ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_GetConfig, static_cast<u32>(config_item) } };
+        /* Disable interrupts. */
+        KScopedInterruptDisable di;
 
-        ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor, true>(args.r);
-        if (AMS_UNLIKELY(static_cast<SmcResult>(args.r[0]) != SmcResult::Success)) {
-            return false;
-        }
-
-        for (size_t i = 0; i < num_qwords && i < 7; i++) {
-            out[i] = args.r[1 + i];
-        }
-
-        return true;
+        /* Get the config. */
+        return TryGetConfigImpl(out, num_qwords, config_item);
     }
 
     void GetConfig(u64 *out, size_t num_qwords, ConfigItem config_item) {
+        /* Ensure we successfully get the config. */
         MESOSPHERE_ABORT_UNLESS(TryGetConfig(out, num_qwords, config_item));
     }
 
     bool SetConfig(ConfigItem config_item, u64 value) {
-        ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_SetConfig, static_cast<u32>(config_item), 0, value } };
+        /* Disable interrupts. */
+        KScopedInterruptDisable di;
 
-        ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor, true>(args.r);
-
-        return static_cast<SmcResult>(args.r[0]) == SmcResult::Success;
+        /* Set the config. */
+        return SetConfigImpl(config_item, value);
     }
 
     bool ReadWriteRegister(u32 *out, ams::svc::PhysicalAddress address, u32 mask, u32 value) {
-        ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_ReadWriteRegister, address, mask, value } };
+        /* Disable interrupts. */
+        KScopedInterruptDisable di;
 
-        ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor, true>(args.r);
-
-        *out = static_cast<u32>(args.r[1]);
-        return static_cast<SmcResult>(args.r[0]) == SmcResult::Success;
+        /* Access the register. */
+        return ReadWriteRegisterImpl(out, address, mask, value);
     }
 
     void ConfigureCarveout(size_t which, uintptr_t address, size_t size) {
-        ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_ConfigureCarveout, static_cast<u64>(which), static_cast<u64>(address), static_cast<u64>(size) } };
+        /* Disable interrupts. */
+        KScopedInterruptDisable di;
 
-        ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor, true>(args.r);
-
-        MESOSPHERE_ABORT_UNLESS((static_cast<SmcResult>(args.r[0]) == SmcResult::Success));
+        /* Ensure that we successfully configure the carveout. */
+        MESOSPHERE_ABORT_UNLESS(ConfigureCarveoutImpl(which, address, size));
     }
 
     void GenerateRandomBytes(void *dst, size_t size) {
-        /* Setup for call. */
-        ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_GenerateRandomBytes, size } };
-        MESOSPHERE_ABORT_UNLESS(size <= sizeof(args) - sizeof(args.r[0]));
+        /* Check that the size is valid. */
+        MESOSPHERE_ABORT_UNLESS(0 < size && size <= GenerateRandomBytesSizeMax);
 
-        /* Make call. */
-        {
-            KScopedInterruptDisable intr_disable;
-            KScopedSpinLock lk(g_generate_random_lock);
+        /* Disable interrupts. */
+        KScopedInterruptDisable di;
 
-            ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor, true>(args.r);
-        }
-        MESOSPHERE_ABORT_UNLESS((static_cast<SmcResult>(args.r[0]) == SmcResult::Success));
+        /* Acquire the exclusive right to generate random bytes. */
+        KScopedSpinLock lk(g_generate_random_lock);
 
-        /* Copy output. */
-        std::memcpy(dst, std::addressof(args.r[1]), size);
+        /* Ensure we successfully generate the random bytes. */
+        MESOSPHERE_ABORT_UNLESS(GenerateRandomBytesImpl(dst, size));
     }
 
-    void NORETURN Panic(u32 color) {
-        ams::svc::lp64::SecureMonitorArguments args = { { FunctionId_Panic, color } };
+    void ShowError(u32 color) {
+        /* Disable interrupts. */
+        KScopedInterruptDisable di;
 
-        ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_Supervisor, true>(args.r);
-
-        AMS_INFINITE_LOOP();
+        /* Ensure we successfully show the error. */
+        MESOSPHERE_ABORT_UNLESS(ShowErrorImpl(color));
     }
 
     void CallSecureMonitorFromUser(ams::svc::lp64::SecureMonitorArguments *args) {
-        ::ams::kern::arch::arm64::smc::SecureMonitorCall<SmcId_User, true>(args->r);
+        /* Disable interrupts. */
+        KScopedInterruptDisable di;
+
+        /* Perform the call. */
+        CallSecureMonitorFromUserImpl(args);
     }
 
 }

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

@@ -111,7 +111,7 @@ namespace ams::kern::board::nintendo::nx::smc {
 
     bool SetConfig(ConfigItem config_item, u64 value);
 
-    void NORETURN Panic(u32 color);
+    void ShowError(u32 color);
 
     void CallSecureMonitorFromUser(ams::svc::lp64::SecureMonitorArguments *args);
 
@@ -119,7 +119,7 @@ namespace ams::kern::board::nintendo::nx::smc {
 
         void GetConfig(u64 *out, size_t num_qwords, ConfigItem config_item);
         void GenerateRandomBytes(void *dst, size_t size);
-        bool ReadWriteRegister(u32 *out, u64 address, u32 mask, u32 value);
+        void ReadWriteRegister(u32 *out, u64 address, u32 mask, u32 value);
 
     }
 

libraries/libmesosphere/source/kern_initial_process.cpp

@@ -136,7 +136,7 @@ namespace ams::kern {
                     {
                         /* Allocate the previously unreserved pages. */
                         KPageGroup unreserve_pg(Kernel::GetSystemSystemResource().GetBlockInfoManagerPointer());
-                        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(unreserve_pg), unreserved_size / PageSize, KMemoryManager::EncodeOption(dst_pool, KMemoryManager::Direction_FromFront)));
+                        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(unreserve_pg), unreserved_size / PageSize, 1, KMemoryManager::EncodeOption(dst_pool, KMemoryManager::Direction_FromFront)));
 
                         /* Add the previously reserved pages. */
                         if (src_pool == dst_pool && binary_pages != 0) {
@@ -173,7 +173,7 @@ namespace ams::kern {
                     /* If the pool is the same, we need to use the workaround page group. */
                     if (src_pool == dst_pool) {
                         /* Allocate a new, usable group for the process. */
-                        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(workaround_pg), static_cast<size_t>(params.code_num_pages), KMemoryManager::EncodeOption(dst_pool, KMemoryManager::Direction_FromFront)));
+                        MESOSPHERE_R_ABORT_UNLESS(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(workaround_pg), static_cast<size_t>(params.code_num_pages), 1, KMemoryManager::EncodeOption(dst_pool, KMemoryManager::Direction_FromFront)));
 
                         /* Copy data from the working page group to the usable one. */
                         auto work_it = pg.begin();

libraries/libmesosphere/source/kern_k_capabilities.cpp

@@ -184,6 +184,11 @@ namespace ams::kern {
                 case RegionType::NoMapping:
                     break;
                 case RegionType::KernelTraceBuffer:
+                    /* NOTE: This does not match official, but is used to make pre-processing hbl capabilities in userland unnecessary. */
+                    /* If ktrace isn't enabled, allow ktrace to succeed without mapping anything. */
+                    if constexpr (!ams::kern::IsKTraceEnabled) {
+                        break;
+                    }
                 case RegionType::OnMemoryBootImage:
                 case RegionType::DTB:
                     R_TRY(f(MemoryRegions[static_cast<u32>(type)], perm));

libraries/libmesosphere/source/kern_k_client_port.cpp

@@ -107,7 +107,6 @@ namespace ams::kern {
                     R_UNLESS(cur_sessions < max, svc::ResultOutOfSessions());
                     new_sessions = cur_sessions + 1;
                 } while (!m_num_sessions.CompareExchangeWeak<std::memory_order_relaxed>(cur_sessions, new_sessions));
-
             }
 
             /* Atomically update the peak session tracking. */
@@ -182,7 +181,6 @@ namespace ams::kern {
                     R_UNLESS(cur_sessions < max, svc::ResultOutOfSessions());
                     new_sessions = cur_sessions + 1;
                 } while (!m_num_sessions.CompareExchangeWeak<std::memory_order_relaxed>(cur_sessions, new_sessions));
-
             }
 
             /* Atomically update the peak session tracking. */

libraries/libmesosphere/source/kern_k_initial_process_reader.cpp

@@ -79,29 +79,7 @@ namespace ams::kern {
 
             /* Create a page group representing the segment. */
             KPageGroup segment_pg(Kernel::GetSystemSystemResource().GetBlockInfoManagerPointer());
-            if (size_t remaining_size = util::AlignUp(seg_size, PageSize); remaining_size != 0) {
-                /* Find the pages whose data corresponds to the segment. */
-                size_t cur_offset = 0;
-                for (auto it = pg.begin(); it != pg.end() && remaining_size > 0; ++it) {
-                    /* Get the current size. */
-                    const size_t cur_size = it->GetSize();
-
-                    /* Determine if the offset is in range. */
-                    const size_t rel_diff = seg_offset - cur_offset;
-                    const bool is_before  = cur_offset <= seg_offset;
-                    cur_offset += cur_size;
-                    if (is_before && seg_offset < cur_offset) {
-                        /* It is, so add the block. */
-                        const size_t block_size = std::min<size_t>(cur_size - rel_diff, remaining_size);
-                        MESOSPHERE_R_ABORT_UNLESS(segment_pg.AddBlock(it->GetAddress() + rel_diff, block_size / PageSize));
-
-                        /* Advance. */
-                        cur_offset      = seg_offset + block_size;
-                        remaining_size -= block_size;
-                        seg_offset     += block_size;
-                    }
-                }
-            }
+            MESOSPHERE_R_ABORT_UNLESS(pg.CopyRangeTo(segment_pg, seg_offset, util::AlignUp(seg_size, PageSize)));
 
             /* Setup the new page group's memory so that we can load the segment. */
             {
@@ -226,6 +204,9 @@ namespace ams::kern {
         const uintptr_t map_end       = map_start + map_size;
         MESOSPHERE_ABORT_UNLESS(start_address == 0);
 
+        /* Default fields in parameter to zero. */
+        *out = {};
+
         /* Set fields in parameter. */
         out->code_address              = map_start + start_address;
         out->code_num_pages            = util::AlignUp(end_address - start_address, PageSize) / PageSize;

libraries/libmesosphere/source/kern_k_memory_manager.cpp

@@ -225,7 +225,7 @@ namespace ams::kern {
         return allocated_block;
     }
 
-    Result KMemoryManager::AllocatePageGroupImpl(KPageGroup *out, size_t num_pages, Pool pool, Direction dir, bool unoptimized, bool random) {
+    Result KMemoryManager::AllocatePageGroupImpl(KPageGroup *out, size_t num_pages, Pool pool, Direction dir, bool unoptimized, bool random, s32 min_heap_index) {
         /* Choose a heap based on our page size request. */
         const s32 heap_index = KPageHeap::GetBlockIndex(num_pages);
         R_UNLESS(0 <= heap_index, svc::ResultOutOfMemory());
@@ -241,7 +241,7 @@ namespace ams::kern {
         };
 
         /* Keep allocating until we've allocated all our pages. */
-        for (s32 index = heap_index; index >= 0 && num_pages > 0; index--) {
+        for (s32 index = heap_index; index >= min_heap_index && num_pages > 0; index--) {
             const size_t pages_per_alloc = KPageHeap::GetBlockNumPages(index);
             for (Impl *cur_manager = this->GetFirstManager(pool, dir); cur_manager != nullptr; cur_manager = this->GetNextManager(cur_manager, dir)) {
                 while (num_pages >= pages_per_alloc) {
@@ -274,7 +274,7 @@ namespace ams::kern {
         R_SUCCEED();
     }
 
-    Result KMemoryManager::AllocateAndOpen(KPageGroup *out, size_t num_pages, u32 option) {
+    Result KMemoryManager::AllocateAndOpen(KPageGroup *out, size_t num_pages, size_t align_pages, u32 option) {
         MESOSPHERE_ASSERT(out != nullptr);
         MESOSPHERE_ASSERT(out->GetNumPages() == 0);
 
@@ -285,8 +285,11 @@ namespace ams::kern {
         const auto [pool, dir] = DecodeOption(option);
         KScopedLightLock lk(m_pool_locks[pool]);
 
+        /* Choose a heap based on our alignment size request. */
+        const s32 heap_index = KPageHeap::GetAlignedBlockIndex(align_pages, align_pages);
+
         /* Allocate the page group. */
-        R_TRY(this->AllocatePageGroupImpl(out, num_pages, pool, dir, m_has_optimized_process[pool], true));
+        R_TRY(this->AllocatePageGroupImpl(out, num_pages, pool, dir, m_has_optimized_process[pool], true, heap_index));
 
         /* Open the first reference to the pages. */
         for (const auto &block : *out) {
@@ -326,8 +329,11 @@ namespace ams::kern {
             const bool has_optimized = m_has_optimized_process[pool];
             const bool is_optimized  = m_optimized_process_ids[pool] == process_id;
 
+            /* Always use the minimum alignment size. */
+            const s32 heap_index = 0;
+
             /* Allocate the page group. */
-            R_TRY(this->AllocatePageGroupImpl(out, num_pages, pool, dir, has_optimized && !is_optimized, false));
+            R_TRY(this->AllocatePageGroupImpl(out, num_pages, pool, dir, has_optimized && !is_optimized, false, heap_index));
 
             /* Set whether we should optimize. */
             optimized = has_optimized && is_optimized;

libraries/libmesosphere/source/kern_k_page_group.cpp

@@ -84,6 +84,58 @@ namespace ams::kern {
         R_SUCCEED();
     }
 
+    Result KPageGroup::CopyRangeTo(KPageGroup &out, size_t range_offset, size_t range_size) const {
+        /* Get the previous last block for the group. */
+        KBlockInfo * const out_last = out.m_last_block;
+        const auto out_last_addr = out_last != nullptr ? out_last->GetAddress()  : Null<KPhysicalAddress>;
+        const auto out_last_np   = out_last != nullptr ? out_last->GetNumPages() : 0;
+
+        /* Ensure we cleanup the group on failure. */
+        ON_RESULT_FAILURE {
+            KBlockInfo *cur = out_last != nullptr ? out_last->GetNext() : out.m_first_block;
+            while (cur != nullptr) {
+                KBlockInfo *next = cur->GetNext();
+                out.m_manager->Free(cur);
+                cur = next;
+            }
+
+            if (out_last != nullptr) {
+                out_last->Initialize(out_last_addr, out_last_np);
+                out_last->SetNext(nullptr);
+            } else {
+                out.m_first_block = nullptr;
+            }
+            out.m_last_block = out_last;
+        };
+
+        /* Find the pages within the requested range. */
+        size_t cur_offset = 0, remaining_size = range_size;
+        for (auto it = this->begin(); it != this->end() && remaining_size > 0; ++it) {
+            /* Get the current size. */
+            const size_t cur_size = it->GetSize();
+
+            /* Determine if the offset is in range. */
+            const size_t rel_diff = range_offset - cur_offset;
+            const bool is_before  = cur_offset <= range_offset;
+            cur_offset += cur_size;
+            if (is_before && range_offset < cur_offset) {
+                /* It is, so add the block. */
+                const size_t block_size = std::min<size_t>(cur_size - rel_diff, remaining_size);
+                R_TRY(out.AddBlock(it->GetAddress() + rel_diff, block_size / PageSize));
+
+                /* Advance. */
+                cur_offset      = range_offset + block_size;
+                remaining_size -= block_size;
+                range_offset   += block_size;
+            }
+        }
+
+        /* Check that we successfully copied the range. */
+        MESOSPHERE_ABORT_UNLESS(remaining_size == 0);
+
+        R_SUCCEED();
+    }
+
     void KPageGroup::Open() const {
         auto &mm = Kernel::GetMemoryManager();
 

libraries/libmesosphere/source/kern_k_page_table_base.cpp

@@ -97,15 +97,12 @@ namespace ams::kern {
         m_enable_aslr                       = true;
         m_enable_device_address_space_merge = false;
 
-        m_heap_region_start                 = 0;
-        m_heap_region_end                   = 0;
+        for (auto i = 0; i < RegionType_Count; ++i) {
+            m_region_starts[i] = 0;
+            m_region_ends[i]   = 0;
+        }
+
         m_current_heap_end                  = 0;
-        m_alias_region_start                = 0;
-        m_alias_region_end                  = 0;
-        m_stack_region_start                = 0;
-        m_stack_region_end                  = 0;
-        m_kernel_map_region_start           = 0;
-        m_kernel_map_region_end             = 0;
         m_alias_code_region_start           = 0;
         m_alias_code_region_end             = 0;
         m_code_region_start                 = 0;
@@ -115,6 +112,7 @@ namespace ams::kern {
         m_mapped_unsafe_physical_memory     = 0;
         m_mapped_insecure_memory            = 0;
         m_mapped_ipc_server_memory          = 0;
+        m_alias_region_extra_size           = 0;
 
         m_memory_block_slab_manager         = Kernel::GetSystemSystemResource().GetMemoryBlockSlabManagerPointer();
         m_block_info_manager                = Kernel::GetSystemSystemResource().GetBlockInfoManagerPointer();
@@ -135,7 +133,7 @@ namespace ams::kern {
         R_RETURN(m_memory_block_manager.Initialize(m_address_space_start, m_address_space_end, m_memory_block_slab_manager));
     }
 
-    Result KPageTableBase::InitializeForProcess(ams::svc::CreateProcessFlag as_type, bool enable_aslr, bool enable_das_merge, bool from_back, KMemoryManager::Pool pool, void *table, KProcessAddress start, KProcessAddress end, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit) {
+    Result KPageTableBase::InitializeForProcess(ams::svc::CreateProcessFlag flags, bool from_back, KMemoryManager::Pool pool, void *table, KProcessAddress start, KProcessAddress end, KProcessAddress code_address, size_t code_size, KSystemResource *system_resource, KResourceLimit *resource_limit) {
         /* Validate the region. */
         MESOSPHERE_ABORT_UNLESS(start <= code_address);
         MESOSPHERE_ABORT_UNLESS(code_address < code_address + code_size);
@@ -149,13 +147,16 @@ namespace ams::kern {
             return KAddressSpaceInfo::GetAddressSpaceSize(m_address_space_width, type);
         };
 
+        /* Default to zero alias region extra size. */
+        m_alias_region_extra_size = 0;
+
         /* Set our width and heap/alias sizes. */
-        m_address_space_width = GetAddressSpaceWidth(as_type);
+        m_address_space_width = GetAddressSpaceWidth(flags);
         size_t alias_region_size  = GetSpaceSize(KAddressSpaceInfo::Type_Alias);
         size_t heap_region_size   = GetSpaceSize(KAddressSpaceInfo::Type_Heap);
 
         /* Adjust heap/alias size if we don't have an alias region. */
-        if ((as_type & ams::svc::CreateProcessFlag_AddressSpaceMask) == ams::svc::CreateProcessFlag_AddressSpace32BitWithoutAlias) {
+        if ((flags & ams::svc::CreateProcessFlag_AddressSpaceMask) == ams::svc::CreateProcessFlag_AddressSpace32BitWithoutAlias) {
             heap_region_size += alias_region_size;
             alias_region_size = 0;
         }
@@ -165,35 +166,57 @@ namespace ams::kern {
         KProcessAddress process_code_end;
         size_t stack_region_size;
         size_t kernel_map_region_size;
+        KProcessAddress before_process_code_start, after_process_code_start;
+        size_t before_process_code_size, after_process_code_size;
         if (m_address_space_width == 39) {
-            alias_region_size               = GetSpaceSize(KAddressSpaceInfo::Type_Alias);
-            heap_region_size                = GetSpaceSize(KAddressSpaceInfo::Type_Heap);
-            stack_region_size               = GetSpaceSize(KAddressSpaceInfo::Type_Stack);
-            kernel_map_region_size          = GetSpaceSize(KAddressSpaceInfo::Type_MapSmall);
-            m_code_region_start             = GetSpaceStart(KAddressSpaceInfo::Type_Map39Bit);
-            m_code_region_end               = m_code_region_start + GetSpaceSize(KAddressSpaceInfo::Type_Map39Bit);
-            m_alias_code_region_start       = m_code_region_start;
-            m_alias_code_region_end         = m_code_region_end;
-            process_code_start              = util::AlignDown(GetInteger(code_address), RegionAlignment);
-            process_code_end                = util::AlignUp(GetInteger(code_address) + code_size, RegionAlignment);
+            stack_region_size                     = GetSpaceSize(KAddressSpaceInfo::Type_Stack);
+            kernel_map_region_size                = GetSpaceSize(KAddressSpaceInfo::Type_MapSmall);
+
+            m_code_region_start                   = GetSpaceStart(KAddressSpaceInfo::Type_Map39Bit);
+            m_code_region_end                     = m_code_region_start + GetSpaceSize(KAddressSpaceInfo::Type_Map39Bit);
+            m_alias_code_region_start             = m_code_region_start;
+            m_alias_code_region_end               = m_code_region_end;
+
+            process_code_start                    = util::AlignDown(GetInteger(code_address), RegionAlignment);
+            process_code_end                      = util::AlignUp(GetInteger(code_address) + code_size, RegionAlignment);
+
+            before_process_code_start             = m_code_region_start;
+            before_process_code_size              = process_code_start - before_process_code_start;
+            after_process_code_start              = process_code_end;
+            after_process_code_size               = m_code_region_end - process_code_end;
+
+            /* If we have a 39-bit address space and should, enable extra size to the alias region. */
+            if (flags & ams::svc::CreateProcessFlag_EnableAliasRegionExtraSize) {
+                /* Extra size is 1/8th of the address space. */
+                m_alias_region_extra_size = (static_cast<size_t>(1) << m_address_space_width) / 8;
+
+                alias_region_size += m_alias_region_extra_size;
+            }
         } else {
-            stack_region_size               = 0;
-            kernel_map_region_size          = 0;
-            m_code_region_start             = GetSpaceStart(KAddressSpaceInfo::Type_MapSmall);
-            m_code_region_end               = m_code_region_start + GetSpaceSize(KAddressSpaceInfo::Type_MapSmall);
-            m_stack_region_start            = m_code_region_start;
-            m_alias_code_region_start       = m_code_region_start;
-            m_alias_code_region_end         = GetSpaceStart(KAddressSpaceInfo::Type_MapLarge) + GetSpaceSize(KAddressSpaceInfo::Type_MapLarge);
-            m_stack_region_end              = m_code_region_end;
-            m_kernel_map_region_start       = m_code_region_start;
-            m_kernel_map_region_end         = m_code_region_end;
-            process_code_start              = m_code_region_start;
-            process_code_end                = m_code_region_end;
+            stack_region_size                     = 0;
+            kernel_map_region_size                = 0;
+
+            m_code_region_start                   = GetSpaceStart(KAddressSpaceInfo::Type_MapSmall);
+            m_code_region_end                     = m_code_region_start + GetSpaceSize(KAddressSpaceInfo::Type_MapSmall);
+            m_alias_code_region_start             = m_code_region_start;
+            m_alias_code_region_end               = GetSpaceStart(KAddressSpaceInfo::Type_MapLarge) + GetSpaceSize(KAddressSpaceInfo::Type_MapLarge);
+            m_region_starts[RegionType_Stack]     = m_code_region_start;
+            m_region_ends[RegionType_Stack]       = m_code_region_end;
+            m_region_starts[RegionType_KernelMap] = m_code_region_start;
+            m_region_ends[RegionType_KernelMap]   = m_code_region_end;
+
+            process_code_start                    = m_code_region_start;
+            process_code_end                      = m_code_region_end;
+
+            before_process_code_start             = m_code_region_start;
+            before_process_code_size              = 0;
+            after_process_code_start              = GetSpaceStart(KAddressSpaceInfo::Type_MapLarge);
+            after_process_code_size               = GetSpaceSize(KAddressSpaceInfo::Type_MapLarge);
         }
 
         /* Set other basic fields. */
-        m_enable_aslr                       = enable_aslr;
-        m_enable_device_address_space_merge = enable_das_merge;
+        m_enable_aslr                       = (flags & ams::svc::CreateProcessFlag_EnableAslr) != 0;
+        m_enable_device_address_space_merge = (flags & ams::svc::CreateProcessFlag_DisableDeviceAddressSpaceMerge) == 0;
         m_address_space_start               = start;
         m_address_space_end                 = end;
         m_is_kernel                         = false;
@@ -201,100 +224,285 @@ namespace ams::kern {
         m_block_info_manager                = system_resource->GetBlockInfoManagerPointer();
         m_resource_limit                    = resource_limit;
 
-        /* Determine the region we can place our undetermineds in. */
-        KProcessAddress alloc_start;
-        size_t alloc_size;
-        if ((GetInteger(process_code_start) - GetInteger(m_code_region_start)) >= (GetInteger(end) - GetInteger(process_code_end))) {
-            alloc_start = m_code_region_start;
-            alloc_size  = GetInteger(process_code_start) - GetInteger(m_code_region_start);
-        } else {
-            alloc_start = process_code_end;
-            alloc_size  = GetInteger(end) - GetInteger(process_code_end);
-        }
-        const size_t needed_size = (alias_region_size + heap_region_size + stack_region_size + kernel_map_region_size);
-        R_UNLESS(alloc_size >= needed_size, svc::ResultOutOfMemory());
+        /* Set up our undetermined regions. */
+        {
+            /* Declare helper structure for layout process. */
+            struct RegionLayoutInfo {
+                size_t size;
+                RegionType type;
+                s32 alloc_index; /* 0 for before process code, 1 for after process code */
+            };
 
-        const size_t remaining_size = alloc_size - needed_size;
+            /* Create region layout info array, and add regions to it. */
+            RegionLayoutInfo region_layouts[RegionType_Count] = {};
+            size_t num_regions = 0;
 
-        /* Determine random placements for each region. */
-        size_t alias_rnd = 0, heap_rnd = 0, stack_rnd = 0, kmap_rnd = 0;
-        if (enable_aslr) {
-            alias_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) * RegionAlignment;
-            heap_rnd  = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) * RegionAlignment;
-            stack_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) * RegionAlignment;
-            kmap_rnd  = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) * RegionAlignment;
-        }
+            if (kernel_map_region_size > 0) { region_layouts[num_regions++] = { .size = kernel_map_region_size, .type = RegionType_KernelMap, .alloc_index = 0, }; }
+            if (stack_region_size > 0)      { region_layouts[num_regions++] = { .size = stack_region_size,      .type = RegionType_Stack,     .alloc_index = 0, }; }
 
-        /* Setup heap and alias regions. */
-        m_alias_region_start = alloc_start + alias_rnd;
-        m_alias_region_end   = m_alias_region_start + alias_region_size;
-        m_heap_region_start  = alloc_start + heap_rnd;
-        m_heap_region_end    = m_heap_region_start + heap_region_size;
+            region_layouts[num_regions++] = { .size = alias_region_size, .type = RegionType_Alias, .alloc_index = 0, };
+            region_layouts[num_regions++] = { .size = heap_region_size,  .type = RegionType_Heap,  .alloc_index = 0, };
 
-        if (alias_rnd <= heap_rnd) {
-            m_heap_region_start  += alias_region_size;
-            m_heap_region_end    += alias_region_size;
-        } else {
-            m_alias_region_start += heap_region_size;
-            m_alias_region_end   += heap_region_size;
-        }
-
-        /* Setup stack region. */
-        if (stack_region_size) {
-            m_stack_region_start = alloc_start + stack_rnd;
-            m_stack_region_end   = m_stack_region_start + stack_region_size;
-
-            if (alias_rnd < stack_rnd) {
-                m_stack_region_start += alias_region_size;
-                m_stack_region_end   += alias_region_size;
-            } else {
-                m_alias_region_start += stack_region_size;
-                m_alias_region_end   += stack_region_size;
+            /* Selection-sort the regions by size largest-to-smallest. */
+            for (size_t i = 0; i < num_regions - 1; ++i) {
+                for (size_t j = i + 1; j < num_regions; ++j) {
+                    if (region_layouts[i].size < region_layouts[j].size) {
+                        std::swap(region_layouts[i], region_layouts[j]);
+                    }
+                }
             }
 
-            if (heap_rnd < stack_rnd) {
-                m_stack_region_start += heap_region_size;
-                m_stack_region_end   += heap_region_size;
-            } else {
-                m_heap_region_start  += stack_region_size;
-                m_heap_region_end    += stack_region_size;
-            }
-        }
+            /* Layout the regions. */
+            constexpr auto AllocIndexCount = 2;
+            KProcessAddress alloc_starts[AllocIndexCount] = { before_process_code_start, after_process_code_start };
+            size_t alloc_sizes[AllocIndexCount] = { before_process_code_size, after_process_code_size };
+            size_t alloc_counts[AllocIndexCount] = {};
+            for (size_t i = 0; i < num_regions; ++i) {
+                /* Get reference to the current region. */
+                auto &cur_region = region_layouts[i];
 
-        /* Setup kernel map region. */
-        if (kernel_map_region_size) {
-            m_kernel_map_region_start = alloc_start + kmap_rnd;
-            m_kernel_map_region_end   = m_kernel_map_region_start + kernel_map_region_size;
+                /* Determine where the current region should go. */
+                cur_region.alloc_index = alloc_sizes[1] >= alloc_sizes[0] ? 1 : 0;
+                ++alloc_counts[cur_region.alloc_index];
 
-            if (alias_rnd < kmap_rnd) {
-                m_kernel_map_region_start += alias_region_size;
-                m_kernel_map_region_end   += alias_region_size;
-            } else {
-                m_alias_region_start      += kernel_map_region_size;
-                m_alias_region_end        += kernel_map_region_size;
+                /* Check that the current region can fit. */
+                R_UNLESS(alloc_sizes[cur_region.alloc_index] >= cur_region.size, svc::ResultOutOfMemory());
+
+                /* Update our remaining size tracking. */
+                alloc_sizes[cur_region.alloc_index] -= cur_region.size;
             }
 
-            if (heap_rnd < kmap_rnd) {
-                m_kernel_map_region_start += heap_region_size;
-                m_kernel_map_region_end   += heap_region_size;
-            } else {
-                m_heap_region_start       += kernel_map_region_size;
-                m_heap_region_end         += kernel_map_region_size;
+            /* Selection sort the regions to coalesce them by alloc index. */
+            for (size_t i = 0; i < num_regions - 1; ++i) {
+                for (size_t j = i + 1; j < num_regions; ++j) {
+                    if (region_layouts[i].alloc_index > region_layouts[j].alloc_index) {
+                        std::swap(region_layouts[i], region_layouts[j]);
+                    }
+                }
             }
 
-            if (stack_region_size) {
-                if (stack_rnd < kmap_rnd) {
-                    m_kernel_map_region_start += stack_region_size;
-                    m_kernel_map_region_end   += stack_region_size;
+            /* Layout the regions for each alloc index. */
+            for (auto cur_alloc_index = 0; cur_alloc_index < AllocIndexCount; ++cur_alloc_index) {
+                /* If there are no regions to place, continue. */
+                const size_t cur_alloc_count = alloc_counts[cur_alloc_index];
+                if (cur_alloc_count == 0) {
+                    continue;
+                }
+
+                /* Determine the starting region index for the current alloc index. */
+                size_t cur_region_index = 0;
+                for (size_t i = 0; i < num_regions; ++i) {
+                    if (region_layouts[i].alloc_index == cur_alloc_index) {
+                        cur_region_index = i;
+                        break;
+                    }
+                }
+
+                /* If aslr is enabled, randomize the current region order. Otherwise, sort by type. */
+                if (m_enable_aslr) {
+                    for (size_t i = 0; i < cur_alloc_count - 1; ++i) {
+                        std::swap(region_layouts[cur_region_index + i], region_layouts[cur_region_index + KSystemControl::GenerateRandomRange(i, cur_alloc_count - 1)]);
+                    }
                 } else {
-                    m_stack_region_start      += kernel_map_region_size;
-                    m_stack_region_end        += kernel_map_region_size;
+                    for (size_t i = 0; i < cur_alloc_count - 1; ++i) {
+                        for (size_t j = i + 1; j < cur_alloc_count; ++j) {
+                            if (region_layouts[cur_region_index + i].type > region_layouts[cur_region_index + j].type) {
+                                std::swap(region_layouts[cur_region_index + i], region_layouts[cur_region_index + j]);
+                            }
+                        }
+                    }
+                }
+
+                /* Determine aslr offsets for the current space. */
+                size_t aslr_offsets[RegionType_Count] = {};
+                if (m_enable_aslr) {
+                    /* Generate the aslr offsets. */
+                    for (size_t i = 0; i < cur_alloc_count; ++i) {
+                        aslr_offsets[i] = KSystemControl::GenerateRandomRange(0, alloc_sizes[cur_alloc_index] / RegionAlignment) * RegionAlignment;
+                    }
+
+                    /* Sort the aslr offsets. */
+                    for (size_t i = 0; i < cur_alloc_count - 1; ++i) {
+                        for (size_t j = i + 1; j < cur_alloc_count; ++j) {
+                            if (aslr_offsets[i] > aslr_offsets[j]) {
+                                std::swap(aslr_offsets[i], aslr_offsets[j]);
+                            }
+                        }
+                    }
+                }
+
+                /* Calculate final region positions. */
+                KProcessAddress prev_region_end = alloc_starts[cur_alloc_index];
+                size_t prev_aslr_offset = 0;
+                for (size_t i = 0; i < cur_alloc_count; ++i) {
+                    /* Get the current region. */
+                    auto &cur_region = region_layouts[cur_region_index + i];
+
+                    /* Set the current region start/end. */
+                    m_region_starts[cur_region.type] = (aslr_offsets[i] - prev_aslr_offset) + GetInteger(prev_region_end);
+                    m_region_ends[cur_region.type]   = m_region_starts[cur_region.type] + cur_region.size;
+
+                    /* Update tracking variables. */
+                    prev_region_end  = m_region_ends[cur_region.type];
+                    prev_aslr_offset = aslr_offsets[i];
+                }
+            }
+
+            /* Declare helpers to check that regions are inside our address space. */
+            const KProcessAddress process_code_last = process_code_end - 1;
+            auto IsInAddressSpace = [&](KProcessAddress addr) ALWAYS_INLINE_LAMBDA { return m_address_space_start <= addr && addr <= m_address_space_end; };
+
+            /* Ensure that the KernelMap region is valid. */
+            for (size_t k = 0; k < num_regions; ++k) {
+                if (const auto &kmap_region = region_layouts[k]; kmap_region.type == RegionType_KernelMap) {
+                    /* If there's no kmap region, we have nothing to check. */
+                    if (kmap_region.size == 0) {
+                        break;
+                    }
+
+                    /* Check that the kmap region is within our address space. */
+                    MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_region_starts[RegionType_KernelMap]));
+                    MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_region_ends[RegionType_KernelMap]));
+
+                    /* Check for overlap with process code. */
+                    const KProcessAddress kmap_start  = m_region_starts[RegionType_KernelMap];
+                    const KProcessAddress kmap_last   = m_region_ends[RegionType_KernelMap] - 1;
+                    MESOSPHERE_ABORT_UNLESS(kernel_map_region_size == 0 || kmap_last < process_code_start || process_code_last < kmap_start);
+
+                    /* Check for overlap with stack. */
+                    for (size_t s = 0; s < num_regions; ++s) {
+                        if (const auto &stack_region = region_layouts[s]; stack_region.type == RegionType_Stack) {
+                            if (stack_region.size != 0) {
+                                const KProcessAddress stack_start = m_region_starts[RegionType_Stack];
+                                const KProcessAddress stack_last  = m_region_ends[RegionType_Stack] - 1;
+                                MESOSPHERE_ABORT_UNLESS((kernel_map_region_size == 0 && stack_region_size == 0) || kmap_last < stack_start || stack_last < kmap_start);
+                            }
+                            break;
+                        }
+                    }
+
+                    /* Check for overlap with alias. */
+                    for (size_t a = 0; a < num_regions; ++a) {
+                        if (const auto &alias_region = region_layouts[a]; alias_region.type == RegionType_Alias) {
+                            if (alias_region.size != 0) {
+                                const KProcessAddress alias_start = m_region_starts[RegionType_Alias];
+                                const KProcessAddress alias_last  = m_region_ends[RegionType_Alias] - 1;
+                                MESOSPHERE_ABORT_UNLESS(kmap_last < alias_start || alias_last < kmap_start);
+                            }
+                            break;
+                        }
+                    }
+
+                    /* Check for overlap with heap. */
+                    for (size_t h = 0; h < num_regions; ++h) {
+                        if (const auto &heap_region = region_layouts[h]; heap_region.type == RegionType_Heap) {
+                            if (heap_region.size != 0) {
+                                const KProcessAddress heap_start = m_region_starts[RegionType_Heap];
+                                const KProcessAddress heap_last  = m_region_ends[RegionType_Heap] - 1;
+                                MESOSPHERE_ABORT_UNLESS(kmap_last < heap_start || heap_last < kmap_start);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            /* Check that the Stack region is valid. */
+            for (size_t s = 0; s < num_regions; ++s) {
+                if (const auto &stack_region = region_layouts[s]; stack_region.type == RegionType_Stack) {
+                    /* If there's no stack region, we have nothing to check. */
+                    if (stack_region.size == 0) {
+                        break;
+                    }
+
+                    /* Check that the stack region is within our address space. */
+                    MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_region_starts[RegionType_Stack]));
+                    MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_region_ends[RegionType_Stack]));
+
+                    /* Check for overlap with process code. */
+                    const KProcessAddress stack_start = m_region_starts[RegionType_Stack];
+                    const KProcessAddress stack_last  = m_region_ends[RegionType_Stack] - 1;
+                    MESOSPHERE_ABORT_UNLESS(stack_region_size == 0 || stack_last < process_code_start || process_code_last < stack_start);
+
+                    /* Check for overlap with alias. */
+                    for (size_t a = 0; a < num_regions; ++a) {
+                        if (const auto &alias_region = region_layouts[a]; alias_region.type == RegionType_Alias) {
+                            if (alias_region.size != 0) {
+                                const KProcessAddress alias_start = m_region_starts[RegionType_Alias];
+                                const KProcessAddress alias_last  = m_region_ends[RegionType_Alias] - 1;
+                                MESOSPHERE_ABORT_UNLESS(stack_last < alias_start || alias_last < stack_start);
+                            }
+                            break;
+                        }
+                    }
+
+                    /* Check for overlap with heap. */
+                    for (size_t h = 0; h < num_regions; ++h) {
+                        if (const auto &heap_region = region_layouts[h]; heap_region.type == RegionType_Heap) {
+                            if (heap_region.size != 0) {
+                                const KProcessAddress heap_start = m_region_starts[RegionType_Heap];
+                                const KProcessAddress heap_last  = m_region_ends[RegionType_Heap] - 1;
+                                MESOSPHERE_ABORT_UNLESS(stack_last < heap_start || heap_last < stack_start);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            /* Check that the Alias region is valid. */
+            for (size_t a = 0; a < num_regions; ++a) {
+                if (const auto &alias_region = region_layouts[a]; alias_region.type == RegionType_Alias) {
+                    /* If there's no alias region, we have nothing to check. */
+                    if (alias_region.size == 0) {
+                        break;
+                    }
+
+                    /* Check that the alias region is within our address space. */
+                    MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_region_starts[RegionType_Alias]));
+                    MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_region_ends[RegionType_Alias]));
+
+                    /* Check for overlap with process code. */
+                    const KProcessAddress alias_start = m_region_starts[RegionType_Alias];
+                    const KProcessAddress alias_last  = m_region_ends[RegionType_Alias] - 1;
+                    MESOSPHERE_ABORT_UNLESS(alias_last < process_code_start || process_code_last < alias_start);
+
+                    /* Check for overlap with heap. */
+                    for (size_t h = 0; h < num_regions; ++h) {
+                        if (const auto &heap_region = region_layouts[h]; heap_region.type == RegionType_Heap) {
+                            if (heap_region.size != 0) {
+                                const KProcessAddress heap_start = m_region_starts[RegionType_Heap];
+                                const KProcessAddress heap_last  = m_region_ends[RegionType_Heap] - 1;
+                                MESOSPHERE_ABORT_UNLESS(alias_last < heap_start || heap_last < alias_start);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            /* Check that the Heap region is valid. */
+            for (size_t h = 0; h < num_regions; ++h) {
+                if (const auto &heap_region = region_layouts[h]; heap_region.type == RegionType_Heap) {
+                    /* If there's no heap region, we have nothing to check. */
+                    if (heap_region.size == 0) {
+                        break;
+                    }
+
+                    /* Check that the heap region is within our address space. */
+                    MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_region_starts[RegionType_Heap]));
+                    MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_region_ends[RegionType_Heap]));
+
+                    /* Check for overlap with process code. */
+                    const KProcessAddress heap_start = m_region_starts[RegionType_Heap];
+                    const KProcessAddress heap_last  = m_region_ends[RegionType_Heap] - 1;
+                    MESOSPHERE_ABORT_UNLESS(heap_last < process_code_start || process_code_last < heap_start);
                 }
             }
         }
 
         /* Set heap and fill members. */
-        m_current_heap_end              = m_heap_region_start;
+        m_current_heap_end              = m_region_starts[RegionType_Heap];
         m_max_heap_size                 = 0;
         m_mapped_physical_memory_size   = 0;
         m_mapped_unsafe_physical_memory = 0;
@@ -309,32 +517,6 @@ namespace ams::kern {
         /* Set allocation option. */
         m_allocate_option = KMemoryManager::EncodeOption(pool, from_back ? KMemoryManager::Direction_FromBack : KMemoryManager::Direction_FromFront);
 
-        /* Ensure that we regions inside our address space. */
-        auto IsInAddressSpace = [&](KProcessAddress addr) ALWAYS_INLINE_LAMBDA { return m_address_space_start <= addr && addr <= m_address_space_end; };
-        MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_alias_region_start));
-        MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_alias_region_end));
-        MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_heap_region_start));
-        MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_heap_region_end));
-        MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_stack_region_start));
-        MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_stack_region_end));
-        MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_kernel_map_region_start));
-        MESOSPHERE_ABORT_UNLESS(IsInAddressSpace(m_kernel_map_region_end));
-
-        /* Ensure that we selected regions that don't overlap. */
-        const KProcessAddress alias_start = m_alias_region_start;
-        const KProcessAddress alias_last  = m_alias_region_end - 1;
-        const KProcessAddress heap_start  = m_heap_region_start;
-        const KProcessAddress heap_last   = m_heap_region_end - 1;
-        const KProcessAddress stack_start = m_stack_region_start;
-        const KProcessAddress stack_last  = m_stack_region_end - 1;
-        const KProcessAddress kmap_start  = m_kernel_map_region_start;
-        const KProcessAddress kmap_last   = m_kernel_map_region_end - 1;
-        MESOSPHERE_ABORT_UNLESS(alias_last < heap_start  || heap_last  < alias_start);
-        MESOSPHERE_ABORT_UNLESS(alias_last < stack_start || stack_last < alias_start);
-        MESOSPHERE_ABORT_UNLESS(alias_last < kmap_start  || kmap_last  < alias_start);
-        MESOSPHERE_ABORT_UNLESS(heap_last  < stack_start || stack_last < heap_start);
-        MESOSPHERE_ABORT_UNLESS(heap_last  < kmap_start  || kmap_last  < heap_start);
-
         /* Initialize our implementation. */
         m_impl.InitializeForProcess(table, GetInteger(start), GetInteger(end));
 
@@ -374,16 +556,16 @@ namespace ams::kern {
             case ams::svc::MemoryState_Kernel:
                 return m_address_space_start;
             case ams::svc::MemoryState_Normal:
-                return m_heap_region_start;
+                return m_region_starts[RegionType_Heap];
             case ams::svc::MemoryState_Ipc:
             case ams::svc::MemoryState_NonSecureIpc:
             case ams::svc::MemoryState_NonDeviceIpc:
-                return m_alias_region_start;
+                return m_region_starts[RegionType_Alias];
             case ams::svc::MemoryState_Stack:
-                return m_stack_region_start;
+                return m_region_starts[RegionType_Stack];
             case ams::svc::MemoryState_Static:
             case ams::svc::MemoryState_ThreadLocal:
-                return m_kernel_map_region_start;
+                return m_region_starts[RegionType_KernelMap];
             case ams::svc::MemoryState_Io:
             case ams::svc::MemoryState_Shared:
             case ams::svc::MemoryState_AliasCode:
@@ -409,16 +591,16 @@ namespace ams::kern {
             case ams::svc::MemoryState_Kernel:
                 return m_address_space_end - m_address_space_start;
             case ams::svc::MemoryState_Normal:
-                return m_heap_region_end - m_heap_region_start;
+                return m_region_ends[RegionType_Heap] - m_region_starts[RegionType_Heap];
             case ams::svc::MemoryState_Ipc:
             case ams::svc::MemoryState_NonSecureIpc:
             case ams::svc::MemoryState_NonDeviceIpc:
-                return m_alias_region_end - m_alias_region_start;
+                return m_region_ends[RegionType_Alias] - m_region_starts[RegionType_Alias];
             case ams::svc::MemoryState_Stack:
-                return m_stack_region_end - m_stack_region_start;
+                return m_region_ends[RegionType_Stack] - m_region_starts[RegionType_Stack];
             case ams::svc::MemoryState_Static:
             case ams::svc::MemoryState_ThreadLocal:
-                return m_kernel_map_region_end - m_kernel_map_region_start;
+                return m_region_ends[RegionType_KernelMap] - m_region_starts[RegionType_KernelMap];
             case ams::svc::MemoryState_Io:
             case ams::svc::MemoryState_Shared:
             case ams::svc::MemoryState_AliasCode:
@@ -446,8 +628,8 @@ namespace ams::kern {
         const size_t region_size           = this->GetRegionSize(state);
 
         const bool is_in_region = region_start <= addr && addr < end && last <= region_start + region_size - 1;
-        const bool is_in_heap   = !(end <= m_heap_region_start || m_heap_region_end <= addr || m_heap_region_start == m_heap_region_end);
-        const bool is_in_alias  = !(end <= m_alias_region_start || m_alias_region_end <= addr || m_alias_region_start == m_alias_region_end);
+        const bool is_in_heap   = !(end <= m_region_starts[RegionType_Heap] || m_region_ends[RegionType_Heap] <= addr || m_region_starts[RegionType_Heap] == m_region_ends[RegionType_Heap]);
+        const bool is_in_alias  = !(end <= m_region_starts[RegionType_Alias] || m_region_ends[RegionType_Alias] <= addr || m_region_starts[RegionType_Alias] == m_region_ends[RegionType_Alias]);
         switch (state) {
             case ams::svc::MemoryState_Free:
             case ams::svc::MemoryState_Kernel:
@@ -734,7 +916,7 @@ namespace ams::kern {
 
         /* Begin traversal. */
         TraversalContext context;
-        TraversalEntry   cur_entry  = { .phys_addr = Null<KPhysicalAddress>, .block_size = 0, .sw_reserved_bits = 0 };
+        TraversalEntry   cur_entry  = { .phys_addr = Null<KPhysicalAddress>, .block_size = 0, .sw_reserved_bits = 0, .attr = 0 };
         bool             cur_valid  = false;
         TraversalEntry   next_entry;
         bool             next_valid;
@@ -1072,7 +1254,7 @@ namespace ams::kern {
         R_SUCCEED();
     }
 
-    Result KPageTableBase::MapInsecureMemory(KProcessAddress address, size_t size) {
+    Result KPageTableBase::MapInsecurePhysicalMemory(KProcessAddress address, size_t size) {
         /* Get the insecure memory resource limit and pool. */
         auto * const insecure_resource_limit = KSystemControl::GetInsecureMemoryResourceLimit();
         const auto insecure_pool             = static_cast<KMemoryManager::Pool>(KSystemControl::GetInsecureMemoryPool());
@@ -1084,7 +1266,7 @@ namespace ams::kern {
 
         /* Allocate pages for the insecure memory. */
         KPageGroup pg(m_block_info_manager);
-        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(pg), size / PageSize, KMemoryManager::EncodeOption(insecure_pool, KMemoryManager::Direction_FromFront)));
+        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(pg), size / PageSize, 1, KMemoryManager::EncodeOption(insecure_pool, KMemoryManager::Direction_FromFront)));
 
         /* Close the opened pages when we're done with them. */
         /* If the mapping succeeds, each page will gain an extra reference, otherwise they will be freed automatically. */
@@ -1128,7 +1310,7 @@ namespace ams::kern {
         R_SUCCEED();
     }
 
-    Result KPageTableBase::UnmapInsecureMemory(KProcessAddress address, size_t size) {
+    Result KPageTableBase::UnmapInsecurePhysicalMemory(KProcessAddress address, size_t size) {
         /* Lock the table. */
         KScopedLightLock lk(m_general_lock);
 
@@ -1237,14 +1419,14 @@ namespace ams::kern {
         return this->GetSize(KMemoryState_AliasCodeData);
     }
 
-    Result KPageTableBase::AllocateAndMapPagesImpl(PageLinkedList *page_list, KProcessAddress address, size_t num_pages, KMemoryPermission perm) {
+    Result KPageTableBase::AllocateAndMapPagesImpl(PageLinkedList *page_list, KProcessAddress address, size_t num_pages, const KPageProperties &properties) {
         MESOSPHERE_ASSERT(this->IsLockedByCurrentThread());
 
         /* Create a page group to hold the pages we allocate. */
         KPageGroup pg(m_block_info_manager);
 
         /* Allocate the pages. */
-        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(pg), num_pages, m_allocate_option));
+        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(pg), num_pages, 1, m_allocate_option));
 
         /* Ensure that the page group is closed when we're done working with it. */
         ON_SCOPE_EXIT { pg.Close(); };
@@ -1255,7 +1437,6 @@ namespace ams::kern {
         }
 
         /* Map the pages. */
-        const KPageProperties properties = { perm, false, false, DisableMergeAttribute_None };
         R_RETURN(this->Operate(page_list, address, num_pages, pg, properties, OperationType_MapGroup, false));
     }
 
@@ -1506,11 +1687,12 @@ namespace ams::kern {
 
         /* Begin a traversal. */
         TraversalContext context;
-        TraversalEntry cur_entry = { .phys_addr = Null<KPhysicalAddress>, .block_size = 0, .sw_reserved_bits = 0 };
+        TraversalEntry cur_entry = { .phys_addr = Null<KPhysicalAddress>, .block_size = 0, .sw_reserved_bits = 0, .attr = 0 };
         R_UNLESS(impl.BeginTraversal(std::addressof(cur_entry), std::addressof(context), address), svc::ResultInvalidCurrentMemory());
 
         /* Traverse until we have enough size or we aren't contiguous any more. */
         const KPhysicalAddress phys_address = cur_entry.phys_addr;
+        const u8 entry_attr = cur_entry.attr;
         size_t contig_size;
         for (contig_size = cur_entry.block_size - (GetInteger(phys_address) & (cur_entry.block_size - 1)); contig_size < size; contig_size += cur_entry.block_size) {
             if (!impl.ContinueTraversal(std::addressof(cur_entry), std::addressof(context))) {
@@ -1519,6 +1701,9 @@ namespace ams::kern {
             if (cur_entry.phys_addr != phys_address + contig_size) {
                 break;
             }
+            if (cur_entry.attr != entry_attr) {
+                break;
+            }
         }
 
         /* Take the minimum size for our region. */
@@ -1532,7 +1717,7 @@ namespace ams::kern {
         }
 
         /* The memory is contiguous, so set the output range. */
-        out->Set(phys_address, size, is_heap);
+        out->Set(phys_address, size, is_heap, attr);
         R_SUCCEED();
     }
 
@@ -1692,17 +1877,17 @@ namespace ams::kern {
             KScopedLightLock lk(m_general_lock);
 
             /* Validate that setting heap size is possible at all. */
-            R_UNLESS(!m_is_kernel,                                                         svc::ResultOutOfMemory());
-            R_UNLESS(size <= static_cast<size_t>(m_heap_region_end - m_heap_region_start), svc::ResultOutOfMemory());
-            R_UNLESS(size <= m_max_heap_size,                                              svc::ResultOutOfMemory());
+            R_UNLESS(!m_is_kernel,                                                                                   svc::ResultOutOfMemory());
+            R_UNLESS(size <= static_cast<size_t>(m_region_ends[RegionType_Heap] - m_region_starts[RegionType_Heap]), svc::ResultOutOfMemory());
+            R_UNLESS(size <= m_max_heap_size,                                                                        svc::ResultOutOfMemory());
 
-            if (size < static_cast<size_t>(m_current_heap_end - m_heap_region_start)) {
+            if (size < static_cast<size_t>(m_current_heap_end - m_region_starts[RegionType_Heap])) {
                 /* The size being requested is less than the current size, so we need to free the end of the heap. */
 
                 /* Validate memory state. */
                 size_t num_allocator_blocks;
                 R_TRY(this->CheckMemoryState(std::addressof(num_allocator_blocks),
-                                             m_heap_region_start + size, (m_current_heap_end - m_heap_region_start) - size,
+                                             m_region_starts[RegionType_Heap] + size, (m_current_heap_end - m_region_starts[RegionType_Heap]) - size,
                                              KMemoryState_All, KMemoryState_Normal,
                                              KMemoryPermission_All, KMemoryPermission_UserReadWrite,
                                              KMemoryAttribute_All,  KMemoryAttribute_None));
@@ -1716,30 +1901,30 @@ namespace ams::kern {
                 KScopedPageTableUpdater updater(this);
 
                 /* Unmap the end of the heap. */
-                const size_t num_pages = ((m_current_heap_end - m_heap_region_start) - size) / PageSize;
+                const size_t num_pages = ((m_current_heap_end - m_region_starts[RegionType_Heap]) - size) / PageSize;
                 const KPageProperties unmap_properties = { KMemoryPermission_None, false, false, DisableMergeAttribute_None };
-                R_TRY(this->Operate(updater.GetPageList(), m_heap_region_start + size, num_pages, Null<KPhysicalAddress>, false, unmap_properties, OperationType_Unmap, false));
+                R_TRY(this->Operate(updater.GetPageList(), m_region_starts[RegionType_Heap] + size, num_pages, Null<KPhysicalAddress>, false, unmap_properties, OperationType_Unmap, false));
 
                 /* Release the memory from the resource limit. */
                 m_resource_limit->Release(ams::svc::LimitableResource_PhysicalMemoryMax, num_pages * PageSize);
 
                 /* Apply the memory block update. */
-                m_memory_block_manager.Update(std::addressof(allocator), m_heap_region_start + size, num_pages, KMemoryState_Free, KMemoryPermission_None, KMemoryAttribute_None, KMemoryBlockDisableMergeAttribute_None, size == 0 ? KMemoryBlockDisableMergeAttribute_Normal : KMemoryBlockDisableMergeAttribute_None);
+                m_memory_block_manager.Update(std::addressof(allocator), m_region_starts[RegionType_Heap] + size, num_pages, KMemoryState_Free, KMemoryPermission_None, KMemoryAttribute_None, KMemoryBlockDisableMergeAttribute_None, size == 0 ? KMemoryBlockDisableMergeAttribute_Normal : KMemoryBlockDisableMergeAttribute_None);
 
                 /* Update the current heap end. */
-                m_current_heap_end = m_heap_region_start + size;
+                m_current_heap_end = m_region_starts[RegionType_Heap] + size;
 
                 /* Set the output. */
-                *out = m_heap_region_start;
+                *out = m_region_starts[RegionType_Heap];
                 R_SUCCEED();
-            } else if (size == static_cast<size_t>(m_current_heap_end - m_heap_region_start)) {
+            } else if (size == static_cast<size_t>(m_current_heap_end - m_region_starts[RegionType_Heap])) {
                 /* The size requested is exactly the current size. */
-                *out = m_heap_region_start;
+                *out = m_region_starts[RegionType_Heap];
                 R_SUCCEED();
             } else {
                 /* We have to allocate memory. Determine how much to allocate and where while the table is locked. */
                 cur_address     = m_current_heap_end;
-                allocation_size = size - (m_current_heap_end - m_heap_region_start);
+                allocation_size = size - (m_current_heap_end - m_region_starts[RegionType_Heap]);
             }
         }
 
@@ -1749,7 +1934,7 @@ namespace ams::kern {
 
         /* Allocate pages for the heap extension. */
         KPageGroup pg(m_block_info_manager);
-        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(pg), allocation_size / PageSize, m_allocate_option));
+        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(pg), allocation_size / PageSize, 1, m_allocate_option));
 
         /* Close the opened pages when we're done with them. */
         /* If the mapping succeeds, each page will gain an extra reference, otherwise they will be freed automatically. */
@@ -1782,20 +1967,20 @@ namespace ams::kern {
 
             /* Map the pages. */
             const size_t num_pages = allocation_size / PageSize;
-            const KPageProperties map_properties = { KMemoryPermission_UserReadWrite, false, false, (m_current_heap_end == m_heap_region_start) ? DisableMergeAttribute_DisableHead : DisableMergeAttribute_None };
+            const KPageProperties map_properties = { KMemoryPermission_UserReadWrite, false, false, (m_current_heap_end == m_region_starts[RegionType_Heap]) ? DisableMergeAttribute_DisableHead : DisableMergeAttribute_None };
             R_TRY(this->Operate(updater.GetPageList(), m_current_heap_end, num_pages, pg, map_properties, OperationType_MapGroup, false));
 
             /* We succeeded, so commit our memory reservation. */
             memory_reservation.Commit();
 
             /* Apply the memory block update. */
-            m_memory_block_manager.Update(std::addressof(allocator), m_current_heap_end, num_pages, KMemoryState_Normal, KMemoryPermission_UserReadWrite, KMemoryAttribute_None, m_heap_region_start == m_current_heap_end ? KMemoryBlockDisableMergeAttribute_Normal : KMemoryBlockDisableMergeAttribute_None, KMemoryBlockDisableMergeAttribute_None);
+            m_memory_block_manager.Update(std::addressof(allocator), m_current_heap_end, num_pages, KMemoryState_Normal, KMemoryPermission_UserReadWrite, KMemoryAttribute_None, m_region_starts[RegionType_Heap] == m_current_heap_end ? KMemoryBlockDisableMergeAttribute_Normal : KMemoryBlockDisableMergeAttribute_None, KMemoryBlockDisableMergeAttribute_None);
 
             /* Update the current heap end. */
-            m_current_heap_end = m_heap_region_start + size;
+            m_current_heap_end = m_region_starts[RegionType_Heap] + size;
 
             /* Set the output. */
-            *out = m_heap_region_start;
+            *out = m_region_starts[RegionType_Heap];
             R_SUCCEED();
         }
     }
@@ -1927,8 +2112,8 @@ namespace ams::kern {
         const KPhysicalAddress last = phys_addr + size - 1;
 
         /* Get region extents. */
-        const KProcessAddress region_start     = m_kernel_map_region_start;
-        const size_t          region_size      = m_kernel_map_region_end - m_kernel_map_region_start;
+        const KProcessAddress region_start     = m_region_starts[RegionType_KernelMap];
+        const size_t          region_size      = m_region_ends[RegionType_KernelMap] - m_region_starts[RegionType_KernelMap];
         const size_t          region_num_pages = region_size / PageSize;
 
         MESOSPHERE_ASSERT(this->CanContain(region_start, region_size, state));
@@ -2237,11 +2422,11 @@ namespace ams::kern {
         KScopedPageTableUpdater updater(this);
 
         /* Perform mapping operation. */
+        const KPageProperties properties = { perm, false, false, DisableMergeAttribute_DisableHead };
         if (is_pa_valid) {
-            const KPageProperties properties = { perm, false, false, DisableMergeAttribute_DisableHead };
             R_TRY(this->Operate(updater.GetPageList(), addr, num_pages, phys_addr, true, properties, OperationType_Map, false));
         } else {
-            R_TRY(this->AllocateAndMapPagesImpl(updater.GetPageList(), addr, num_pages, perm));
+            R_TRY(this->AllocateAndMapPagesImpl(updater.GetPageList(), addr, num_pages, properties));
         }
 
         /* Update the blocks. */
@@ -2273,7 +2458,8 @@ namespace ams::kern {
         KScopedPageTableUpdater updater(this);
 
         /* Map the pages. */
-        R_TRY(this->AllocateAndMapPagesImpl(updater.GetPageList(), address, num_pages, perm));
+        const KPageProperties properties = { perm, false, false, DisableMergeAttribute_DisableHead };
+        R_TRY(this->AllocateAndMapPagesImpl(updater.GetPageList(), address, num_pages, properties));
 
         /* Update the blocks. */
         m_memory_block_manager.Update(std::addressof(allocator), address, num_pages, state, perm, KMemoryAttribute_None, KMemoryBlockDisableMergeAttribute_Normal, KMemoryBlockDisableMergeAttribute_None);
@@ -2812,7 +2998,7 @@ namespace ams::kern {
             MESOSPHERE_ABORT_UNLESS(src_page_table.GetPhysicalAddressLocked(std::addressof(phys_addr), address));
 
             /* Determine the current read size. */
-            const size_t cur_size = std::min<size_t>(last_address - address + 1, util::AlignDown(GetInteger(address) + PageSize, PageSize) - GetInteger(address));
+            const size_t cur_size = std::min<size_t>(last_address - address + 1, PageSize - (GetInteger(address) & (PageSize - 1)));
 
             /* Read. */
             R_TRY(dst_page_table.ReadIoMemoryImpl(dst, phys_addr, cur_size, state));
@@ -2848,7 +3034,7 @@ namespace ams::kern {
             MESOSPHERE_ABORT_UNLESS(src_page_table.GetPhysicalAddressLocked(std::addressof(phys_addr), address));
 
             /* Determine the current read size. */
-            const size_t cur_size = std::min<size_t>(last_address - address + 1, util::AlignDown(GetInteger(address) + PageSize, PageSize) - GetInteger(address));
+            const size_t cur_size = std::min<size_t>(last_address - address + 1, PageSize - (GetInteger(address) & (PageSize - 1)));
 
             /* Read. */
             R_TRY(dst_page_table.WriteIoMemoryImpl(phys_addr, src, cur_size, state));
@@ -3624,7 +3810,7 @@ namespace ams::kern {
         R_UNLESS(this->Contains(address, size), svc::ResultInvalidCurrentMemory());
 
         /* Get the source permission. */
-        const auto src_perm = static_cast<KMemoryPermission>((test_perm == KMemoryPermission_UserReadWrite) ? KMemoryPermission_KernelReadWrite | KMemoryPermission_NotMapped : KMemoryPermission_UserRead);
+        const auto src_perm = static_cast<KMemoryPermission>((test_perm == KMemoryPermission_UserReadWrite) ? (KMemoryPermission_KernelReadWrite | KMemoryPermission_NotMapped) : KMemoryPermission_UserRead);
 
         /* Get aligned extents. */
         const KProcessAddress aligned_src_start = util::AlignDown(GetInteger(address), PageSize);
@@ -3720,8 +3906,8 @@ namespace ams::kern {
         MESOSPHERE_ASSERT(src_page_table.IsLockedByCurrentThread());
 
         /* Check that we can theoretically map. */
-        const KProcessAddress region_start = m_alias_region_start;
-        const size_t          region_size  = m_alias_region_end - m_alias_region_start;
+        const KProcessAddress region_start = m_region_starts[RegionType_Alias];
+        const size_t          region_size  = m_region_ends[RegionType_Alias] - m_region_starts[RegionType_Alias];
         R_UNLESS(size < region_size, svc::ResultOutOfAddressSpace());
 
         /* Get aligned source extents. */
@@ -3953,7 +4139,7 @@ namespace ams::kern {
         const size_t src_map_size           = src_map_end - src_map_start;
 
         /* Ensure that we clean up appropriately if we fail after this. */
-        const auto src_perm = static_cast<KMemoryPermission>((test_perm == KMemoryPermission_UserReadWrite) ? KMemoryPermission_KernelReadWrite | KMemoryPermission_NotMapped : KMemoryPermission_UserRead);
+        const auto src_perm = static_cast<KMemoryPermission>((test_perm == KMemoryPermission_UserReadWrite) ? (KMemoryPermission_KernelReadWrite | KMemoryPermission_NotMapped) : KMemoryPermission_UserRead);
         ON_RESULT_FAILURE {
             if (src_map_end > src_map_start) {
                 src_page_table.CleanupForIpcClientOnServerSetupFailure(updater.GetPageList(), src_map_start, src_map_size, src_perm);
@@ -4488,7 +4674,7 @@ namespace ams::kern {
                                     }
                                 }
 
-                                /* Map the papges. */
+                                /* Map the pages. */
                                 R_TRY(this->Operate(updater.GetPageList(), cur_address, map_pages, cur_pg, map_properties, OperationType_MapFirstGroup, false));
                             }
                         }
@@ -4662,7 +4848,7 @@ namespace ams::kern {
 
         /* Allocate the new memory. */
         const size_t num_pages = size / PageSize;
-        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(pg), num_pages, KMemoryManager::EncodeOption(KMemoryManager::Pool_Unsafe, KMemoryManager::Direction_FromFront)));
+        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(pg), num_pages, 1, KMemoryManager::EncodeOption(KMemoryManager::Pool_Unsafe, KMemoryManager::Direction_FromFront)));
 
         /* Close the page group when we're done with it. */
         ON_SCOPE_EXIT { pg.Close(); };

libraries/libmesosphere/source/kern_k_process.cpp

@@ -51,7 +51,7 @@ namespace ams::kern {
                 }
             }
 
-            /* Wait for all children threads to terminate.*/
+            /* Wait for all children threads to terminate. */
             while (true) {
                 /* Get the next child. */
                 KThread *cur_child = nullptr;
@@ -298,10 +298,8 @@ namespace ams::kern {
 
         /* Setup page table. */
         {
-            const auto as_type          = static_cast<ams::svc::CreateProcessFlag>(params.flags & ams::svc::CreateProcessFlag_AddressSpaceMask);
-            const bool enable_aslr      = (params.flags & ams::svc::CreateProcessFlag_EnableAslr) != 0;
-            const bool enable_das_merge = (params.flags & ams::svc::CreateProcessFlag_DisableDeviceAddressSpaceMerge) == 0;
-            R_TRY(m_page_table.Initialize(as_type, enable_aslr, enable_das_merge, !enable_aslr, pool, params.code_address, params.code_num_pages * PageSize, m_system_resource, res_limit));
+            const bool from_back = (params.flags & ams::svc::CreateProcessFlag_EnableAslr) == 0;
+            R_TRY(m_page_table.Initialize(static_cast<ams::svc::CreateProcessFlag>(params.flags), from_back, pool, params.code_address, params.code_num_pages * PageSize, m_system_resource, res_limit));
         }
         ON_RESULT_FAILURE_2 { m_page_table.Finalize(); };
 
@@ -379,10 +377,8 @@ namespace ams::kern {
 
         /* Setup page table. */
         {
-            const auto as_type          = static_cast<ams::svc::CreateProcessFlag>(params.flags & ams::svc::CreateProcessFlag_AddressSpaceMask);
-            const bool enable_aslr      = (params.flags & ams::svc::CreateProcessFlag_EnableAslr) != 0;
-            const bool enable_das_merge = (params.flags & ams::svc::CreateProcessFlag_DisableDeviceAddressSpaceMerge) == 0;
-            R_TRY(m_page_table.Initialize(as_type, enable_aslr, enable_das_merge, !enable_aslr, pool, params.code_address, code_size, m_system_resource, res_limit));
+            const bool from_back = (params.flags & ams::svc::CreateProcessFlag_EnableAslr) == 0;
+            R_TRY(m_page_table.Initialize(static_cast<ams::svc::CreateProcessFlag>(params.flags), from_back, pool, params.code_address, code_size, m_system_resource, res_limit));
         }
         ON_RESULT_FAILURE_2 { m_page_table.Finalize(); };
 
@@ -467,7 +463,7 @@ namespace ams::kern {
     void KProcess::Exit() {
         MESOSPHERE_ASSERT_THIS();
 
-        /* Determine whether we need to start terminating */
+        /* Determine whether we need to start terminating. */
         bool needs_terminate = false;
         {
             KScopedLightLock lk(m_state_lock);

libraries/libmesosphere/source/kern_k_server_port.cpp

@@ -36,7 +36,7 @@ namespace ams::kern {
 
         /* Cleanup the session list. */
         while (true) {
-            /* Get the last session in the list */
+            /* Get the last session in the list. */
             KServerSession *session = nullptr;
             {
                 KScopedSchedulerLock sl;
@@ -56,7 +56,7 @@ namespace ams::kern {
 
         /* Cleanup the light session list. */
         while (true) {
-            /* Get the last session in the list */
+            /* Get the last session in the list. */
             KLightServerSession *session = nullptr;
             {
                 KScopedSchedulerLock sl;

libraries/libmesosphere/source/kern_k_server_session.cpp

@@ -650,7 +650,7 @@ namespace ams::kern {
                     const auto src_state = src_user ? KMemoryState_FlagReferenceCounted : KMemoryState_FlagLinearMapped;
 
                     /* Determine the source permission. User buffer should be unmapped + read, TLS should be user readable. */
-                    const KMemoryPermission src_perm = static_cast<KMemoryPermission>(src_user ? KMemoryPermission_NotMapped | KMemoryPermission_KernelRead : KMemoryPermission_UserRead);
+                    const KMemoryPermission src_perm = static_cast<KMemoryPermission>(src_user ? (KMemoryPermission_NotMapped | KMemoryPermission_KernelRead) : KMemoryPermission_UserRead);
 
                     /* Perform the fast part of the copy. */
                     R_TRY(src_page_table.CopyMemoryFromLinearToKernel(reinterpret_cast<uintptr_t>(dst_msg_ptr) + offset_words, fast_size, src_message_buffer + offset_words,
@@ -753,7 +753,7 @@ namespace ams::kern {
                 /* Perform the pointer data copy. */
                 const bool dst_heap  = dst_user && dst_recv_list.IsToMessageBuffer();
                 const auto dst_state = dst_heap ? KMemoryState_FlagReferenceCounted : KMemoryState_FlagLinearMapped;
-                const KMemoryPermission dst_perm = static_cast<KMemoryPermission>(dst_heap ? KMemoryPermission_NotMapped | KMemoryPermission_KernelReadWrite : KMemoryPermission_UserReadWrite);
+                const KMemoryPermission dst_perm = static_cast<KMemoryPermission>(dst_heap ? (KMemoryPermission_NotMapped | KMemoryPermission_KernelReadWrite) : KMemoryPermission_UserReadWrite);
                 R_TRY(dst_page_table.CopyMemoryFromUserToLinear(recv_pointer, recv_size,
                                                                 dst_state, dst_state,
                                                                 dst_perm,
@@ -911,7 +911,7 @@ namespace ams::kern {
                         const auto dst_state = dst_user ? KMemoryState_FlagReferenceCounted : KMemoryState_FlagLinearMapped;
 
                         /* Determine the dst permission. User buffer should be unmapped + read, TLS should be user readable. */
-                        const KMemoryPermission dst_perm = static_cast<KMemoryPermission>(dst_user ? KMemoryPermission_NotMapped | KMemoryPermission_KernelReadWrite : KMemoryPermission_UserReadWrite);
+                        const KMemoryPermission dst_perm = static_cast<KMemoryPermission>(dst_user ? (KMemoryPermission_NotMapped | KMemoryPermission_KernelReadWrite) : KMemoryPermission_UserReadWrite);
 
                         /* Perform the fast part of the copy. */
                         R_TRY(dst_page_table.CopyMemoryFromKernelToLinear(dst_message_buffer + offset_words, fast_size,

libraries/libmesosphere/source/kern_k_shared_memory.cpp

@@ -37,7 +37,7 @@ namespace ams::kern {
         R_UNLESS(memory_reservation.Succeeded(), svc::ResultLimitReached());
 
         /* Allocate the memory. */
-        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(m_page_group), num_pages, owner->GetAllocateOption()));
+        R_TRY(Kernel::GetMemoryManager().AllocateAndOpen(std::addressof(m_page_group), num_pages, 1, owner->GetAllocateOption()));
 
         /* Commit our reservation. */
         memory_reservation.Commit();

libraries/libmesosphere/source/kern_k_system_control_base.cpp

@@ -39,17 +39,18 @@ namespace ams::kern {
     KPhysicalAddress KSystemControlBase::Init::GetKernelPhysicalBaseAddress(KPhysicalAddress base_address) {
         const size_t real_dram_size     = KSystemControl::Init::GetRealMemorySize();
         const size_t intended_dram_size = KSystemControl::Init::GetIntendedMemorySize();
-        if (intended_dram_size * 2 < real_dram_size) {
+        if (intended_dram_size * 2 <= real_dram_size) {
             return base_address;
         } else {
             return base_address + ((real_dram_size - intended_dram_size) / 2);
         }
     }
 
-    void KSystemControlBase::Init::GetInitialProcessBinaryLayout(InitialProcessBinaryLayout *out) {
+    void KSystemControlBase::Init::GetInitialProcessBinaryLayout(InitialProcessBinaryLayout *out, KPhysicalAddress kern_base_address) {
         *out = {
-            .address = GetInteger(KSystemControl::Init::GetKernelPhysicalBaseAddress(ams::kern::MainMemoryAddress)) + KSystemControl::Init::GetIntendedMemorySize() - InitialProcessBinarySizeMax,
-            ._08     = 0,
+            .address      = GetInteger(KSystemControl::Init::GetKernelPhysicalBaseAddress(ams::kern::MainMemoryAddress)) + KSystemControl::Init::GetIntendedMemorySize() - InitialProcessBinarySizeMax,
+            ._08          = 0,
+            .kern_address = GetInteger(kern_base_address),
         };
     }
 
@@ -77,7 +78,7 @@ namespace ams::kern {
 
     void KSystemControlBase::Init::CpuOnImpl(u64 core_id, uintptr_t entrypoint, uintptr_t arg) {
         #if defined(ATMOSPHERE_ARCH_ARM64)
-        MESOSPHERE_INIT_ABORT_UNLESS((::ams::kern::arch::arm64::smc::CpuOn<0, false>(core_id, entrypoint, arg)) == 0);
+        MESOSPHERE_INIT_ABORT_UNLESS((::ams::kern::arch::arm64::smc::CpuOn<0>(core_id, entrypoint, arg)) == 0);
         #else
         AMS_INFINITE_LOOP();
         #endif

libraries/libmesosphere/source/svc/kern_svc_address_translation.cpp

@@ -37,7 +37,7 @@ namespace ams::kern::svc {
             R_SUCCEED();
         }
 
-        Result QueryIoMapping(uintptr_t *out_address, size_t *out_size, uint64_t phys_addr, size_t size) {
+        Result QueryMemoryMapping(uintptr_t *out_address, size_t *out_size, uint64_t phys_addr, size_t size) {
             /* Declare variables we'll populate. */
             KProcessAddress found_address = Null<KProcessAddress>;
             size_t          found_size    = 0;
@@ -125,15 +125,15 @@ namespace ams::kern::svc {
         R_RETURN(QueryPhysicalAddress(out_info, address));
     }
 
-    Result QueryIoMapping64(ams::svc::Address *out_address, ams::svc::Size *out_size, ams::svc::PhysicalAddress physical_address, ams::svc::Size size) {
+    Result QueryMemoryMapping64(ams::svc::Address *out_address, ams::svc::Size *out_size, ams::svc::PhysicalAddress physical_address, ams::svc::Size size) {
         static_assert(sizeof(*out_address) == sizeof(uintptr_t));
         static_assert(sizeof(*out_size)    == sizeof(size_t));
-        R_RETURN(QueryIoMapping(reinterpret_cast<uintptr_t *>(out_address), reinterpret_cast<size_t *>(out_size), physical_address, size));
+        R_RETURN(QueryMemoryMapping(reinterpret_cast<uintptr_t *>(out_address), reinterpret_cast<size_t *>(out_size), physical_address, size));
     }
 
     Result LegacyQueryIoMapping64(ams::svc::Address *out_address, ams::svc::PhysicalAddress physical_address, ams::svc::Size size) {
         static_assert(sizeof(*out_address) == sizeof(uintptr_t));
-        R_RETURN(QueryIoMapping(reinterpret_cast<uintptr_t *>(out_address), nullptr, physical_address, size));
+        R_RETURN(QueryMemoryMapping(reinterpret_cast<uintptr_t *>(out_address), nullptr, physical_address, size));
     }
 
     /* ============================= 64From32 ABI ============================= */
@@ -150,15 +150,15 @@ namespace ams::kern::svc {
         R_SUCCEED();
     }
 
-    Result QueryIoMapping64From32(ams::svc::Address *out_address, ams::svc::Size *out_size, ams::svc::PhysicalAddress physical_address, ams::svc::Size size) {
+    Result QueryMemoryMapping64From32(ams::svc::Address *out_address, ams::svc::Size *out_size, ams::svc::PhysicalAddress physical_address, ams::svc::Size size) {
         static_assert(sizeof(*out_address) == sizeof(uintptr_t));
         static_assert(sizeof(*out_size)    == sizeof(size_t));
-        R_RETURN(QueryIoMapping(reinterpret_cast<uintptr_t *>(out_address), reinterpret_cast<size_t *>(out_size), physical_address, size));
+        R_RETURN(QueryMemoryMapping(reinterpret_cast<uintptr_t *>(out_address), reinterpret_cast<size_t *>(out_size), physical_address, size));
     }
 
     Result LegacyQueryIoMapping64From32(ams::svc::Address *out_address, ams::svc::PhysicalAddress physical_address, ams::svc::Size size) {
         static_assert(sizeof(*out_address) == sizeof(uintptr_t));
-        R_RETURN(QueryIoMapping(reinterpret_cast<uintptr_t *>(out_address), nullptr, physical_address, size));
+        R_RETURN(QueryMemoryMapping(reinterpret_cast<uintptr_t *>(out_address), nullptr, physical_address, size));
     }
 
 }

libraries/libmesosphere/source/svc/kern_svc_info.cpp

@@ -106,6 +106,9 @@ namespace ams::kern::svc {
                         *out = 0;
                     }
                     break;
+                case ams::svc::InfoType_AliasRegionExtraSize:
+                    *out = process->GetPageTable().GetAliasRegionExtraSize();
+                    break;
                 MESOSPHERE_UNREACHABLE_DEFAULT_CASE();
             }
 
@@ -134,6 +137,7 @@ namespace ams::kern::svc {
                 case ams::svc::InfoType_UsedNonSystemMemorySize:
                 case ams::svc::InfoType_IsApplication:
                 case ams::svc::InfoType_FreeThreadCount:
+                case ams::svc::InfoType_AliasRegionExtraSize:
                     {
                         /* These info types don't support non-zero subtypes. */
                         R_UNLESS(info_subtype == 0,  svc::ResultInvalidCombination());

libraries/libmesosphere/source/svc/kern_svc_insecure_memory.cpp

@@ -21,7 +21,7 @@ namespace ams::kern::svc {
 
     namespace {
 
-        Result MapInsecureMemory(uintptr_t address, size_t size) {
+        Result MapInsecurePhysicalMemory(uintptr_t address, size_t size) {
             /* Validate the address/size. */
             R_UNLESS(util::IsAligned(size,    PageSize), svc::ResultInvalidSize());
             R_UNLESS(size > 0,                           svc::ResultInvalidSize());
@@ -33,10 +33,10 @@ namespace ams::kern::svc {
             R_UNLESS(GetCurrentProcess().GetPageTable().CanContain(address, size, KMemoryState_Insecure), svc::ResultInvalidMemoryRegion());
 
             /* Map the insecure memory. */
-            R_RETURN(pt.MapInsecureMemory(address, size));
+            R_RETURN(pt.MapInsecurePhysicalMemory(address, size));
         }
 
-        Result UnmapInsecureMemory(uintptr_t address, size_t size) {
+        Result UnmapInsecurePhysicalMemory(uintptr_t address, size_t size) {
             /* Validate the address/size. */
             R_UNLESS(util::IsAligned(size,    PageSize), svc::ResultInvalidSize());
             R_UNLESS(size > 0,                           svc::ResultInvalidSize());
@@ -48,29 +48,29 @@ namespace ams::kern::svc {
             R_UNLESS(GetCurrentProcess().GetPageTable().CanContain(address, size, KMemoryState_Insecure), svc::ResultInvalidMemoryRegion());
 
             /* Map the insecure memory. */
-            R_RETURN(pt.UnmapInsecureMemory(address, size));
+            R_RETURN(pt.UnmapInsecurePhysicalMemory(address, size));
         }
 
     }
 
     /* =============================    64 ABI    ============================= */
 
-    Result MapInsecureMemory64(ams::svc::Address address, ams::svc::Size size) {
-        R_RETURN(MapInsecureMemory(address, size));
+    Result MapInsecurePhysicalMemory64(ams::svc::Address address, ams::svc::Size size) {
+        R_RETURN(MapInsecurePhysicalMemory(address, size));
     }
 
-    Result UnmapInsecureMemory64(ams::svc::Address address, ams::svc::Size size) {
-        R_RETURN(UnmapInsecureMemory(address, size));
+    Result UnmapInsecurePhysicalMemory64(ams::svc::Address address, ams::svc::Size size) {
+        R_RETURN(UnmapInsecurePhysicalMemory(address, size));
     }
 
     /* ============================= 64From32 ABI ============================= */
 
-    Result MapInsecureMemory64From32(ams::svc::Address address, ams::svc::Size size) {
-        R_RETURN(MapInsecureMemory(address, size));
+    Result MapInsecurePhysicalMemory64From32(ams::svc::Address address, ams::svc::Size size) {
+        R_RETURN(MapInsecurePhysicalMemory(address, size));
     }
 
-    Result UnmapInsecureMemory64From32(ams::svc::Address address, ams::svc::Size size) {
-        R_RETURN(UnmapInsecureMemory(address, size));
+    Result UnmapInsecurePhysicalMemory64From32(ams::svc::Address address, ams::svc::Size size) {
+        R_RETURN(UnmapInsecurePhysicalMemory(address, size));
     }
 
 }

libraries/libmesosphere/source/svc/kern_svc_ipc.cpp

@@ -143,7 +143,7 @@ namespace ams::kern::svc {
             /* Get the process page table. */
             auto &page_table = GetCurrentProcess().GetPageTable();
 
-            /* Lock the mesage buffer. */
+            /* Lock the message buffer. */
             R_TRY(page_table.LockForIpcUserBuffer(nullptr, message, buffer_size));
 
             {
@@ -186,7 +186,7 @@ namespace ams::kern::svc {
             /* Commit our reservation. */
             event_reservation.Commit();
 
-            /* At end of scope, kill the standing references to the sub events. */
+            /* At end of scope, kill the standing event references. */
             ON_SCOPE_EXIT {
                 event->GetReadableEvent().Close();
                 event->Close();
@@ -215,7 +215,7 @@ namespace ams::kern::svc {
             /* Get the process page table. */
             auto &page_table = GetCurrentProcess().GetPageTable();
 
-            /* Lock the mesage buffer. */
+            /* Lock the message buffer. */
             R_TRY(page_table.LockForIpcUserBuffer(nullptr, message, buffer_size));
 
             /* Ensure that if we fail and aren't terminating that we unlock the user buffer. */
@@ -242,7 +242,7 @@ namespace ams::kern::svc {
             /* Get the process page table. */
             auto &page_table = GetCurrentProcess().GetPageTable();
 
-            /* Lock the mesage buffer, getting its physical address. */
+            /* Lock the message buffer, getting its physical address. */
             KPhysicalAddress message_paddr;
             R_TRY(page_table.LockForIpcUserBuffer(std::addressof(message_paddr), message, buffer_size));
 

libraries/libmesosphere/source/svc/kern_svc_port.cpp

@@ -96,7 +96,7 @@ namespace ams::kern::svc {
             /* Add the client to the handle table. */
             R_TRY(handle_table.Add(out_client, std::addressof(port->GetClientPort())));
 
-            /* Ensure that we maintaing a clean handle state on exit. */
+            /* Ensure that we maintain a clean handle state on exit. */
             ON_RESULT_FAILURE { handle_table.Remove(*out_client); };
 
             /* Add the server to the handle table. */

libraries/libmesosphere/source/svc/kern_svc_process.cpp

@@ -162,6 +162,18 @@ namespace ams::kern::svc {
             /* Check that the number of extra resource pages is >= 0. */
             R_UNLESS(params.system_resource_num_pages >= 0, svc::ResultInvalidSize());
 
+            /* Validate that the alias region extra size is allowed, if enabled. */
+            if (params.flags & ams::svc::CreateProcessFlag_EnableAliasRegionExtraSize) {
+                /* Check that we have a 64-bit address space. */
+                R_UNLESS((params.flags & ams::svc::CreateProcessFlag_AddressSpaceMask) == ams::svc::CreateProcessFlag_AddressSpace64Bit, svc::ResultInvalidState());
+
+                /* Check that the system resource page count is non-zero. */
+                R_UNLESS(params.system_resource_num_pages > 0, svc::ResultInvalidState());
+
+                /* Check that debug mode is enabled. */
+                R_UNLESS(KTargetSystem::IsDebugMode(), svc::ResultInvalidState());
+            }
+
             /* Convert to sizes. */
             const size_t code_num_pages            = params.code_num_pages;
             const size_t system_resource_num_pages = params.system_resource_num_pages;

libraries/libstratosphere/include/stratosphere/erpt/erpt_types.hpp

@@ -34,7 +34,6 @@ namespace ams::erpt {
 
     enum CategoryId {
         AMS_ERPT_FOREACH_CATEGORY(GENERATE_ENUM)
-        CategoryId_Count,
     };
 
     #undef GENERATE_ENUM
@@ -43,7 +42,6 @@ namespace ams::erpt {
 
     enum FieldId {
         AMS_ERPT_FOREACH_FIELD(GENERATE_ENUM)
-        FieldId_Count,
     };
 
     #undef GENERATE_ENUM

libraries/libstratosphere/include/stratosphere/erpt/srv/erpt_srv_types.hpp

@@ -58,34 +58,88 @@ namespace ams::erpt::srv {
     };
     #undef STRINGIZE_HANDLER
 
-    #define GET_FIELD_CATEGORY(FIELD, ID, CATEGORY, TYPE, FLAG) [FieldId_##FIELD] = CategoryId_##CATEGORY,
-    constexpr inline const CategoryId FieldToCategoryMap[] = {
+    #define GET_FIELD_CATEGORY(FIELD, ID, CATEGORY, TYPE, FLAG) CategoryId_##CATEGORY,
+    constexpr inline const CategoryId FieldIndexToCategoryMap[] = {
         AMS_ERPT_FOREACH_FIELD(GET_FIELD_CATEGORY)
     };
     #undef GET_FIELD_CATEGORY
 
-    #define GET_FIELD_TYPE(FIELD, ID, CATEGORY, TYPE, FLAG) [FieldId_##FIELD] = TYPE,
-    constexpr inline const FieldType FieldToTypeMap[] = {
+    #define GET_FIELD_TYPE(FIELD, ID, CATEGORY, TYPE, FLAG) TYPE,
+    constexpr inline const FieldType FieldIndexToTypeMap[] = {
         AMS_ERPT_FOREACH_FIELD(GET_FIELD_TYPE)
     };
     #undef GET_FIELD_TYPE
 
-    #define GET_FIELD_FLAG(FIELD, ID, CATEGORY, TYPE, FLAG) [FieldId_##FIELD] = FLAG,
-    constexpr inline const FieldFlag FieldToFlagMap[] = {
+    #define GET_FIELD_FLAG(FIELD, ID, CATEGORY, TYPE, FLAG) FLAG,
+    constexpr inline const FieldFlag FieldIndexToFlagMap[] = {
         AMS_ERPT_FOREACH_FIELD(GET_FIELD_FLAG)
     };
     #undef GET_FIELD_FLAG
 
-    inline CategoryId ConvertFieldToCategory(FieldId id) {
-        return FieldToCategoryMap[id];
+    #define GET_FIELD_ID(FIELD, ...) FieldId_##FIELD,
+    constexpr inline const FieldId FieldIndexToFieldIdMap[] = {
+        AMS_ERPT_FOREACH_FIELD(GET_FIELD_ID)
+    };
+    #undef GET_FIELD_ID
+
+    #define GET_CATEGORY_ID(CATEGORY, ...) CategoryId_##CATEGORY,
+    constexpr inline const CategoryId CategoryIndexToCategoryIdMap[] = {
+        AMS_ERPT_FOREACH_CATEGORY(GET_CATEGORY_ID)
+    };
+    #undef GET_CATEGORY_ID
+
+    constexpr util::optional<size_t> FindFieldIndex(FieldId id) {
+        if (std::is_constant_evaluated()) {
+            for (size_t i = 0; i < util::size(FieldIndexToFieldIdMap); ++i) {
+                if (FieldIndexToFieldIdMap[i] == id) {
+                    return i;
+                }
+            }
+
+            return util::nullopt;
+        } else {
+            if (const auto it = std::lower_bound(std::begin(FieldIndexToFieldIdMap), std::end(FieldIndexToFieldIdMap), id); it != std::end(FieldIndexToFieldIdMap) && *it == id) {
+                return std::distance(FieldIndexToFieldIdMap, it);
+            } else {
+                return util::nullopt;
+            }
+        }
     }
 
-    inline FieldType ConvertFieldToType(FieldId id) {
-        return FieldToTypeMap[id];
+    constexpr util::optional<size_t> FindCategoryIndex(CategoryId id) {
+        if (std::is_constant_evaluated()) {
+            for (size_t i = 0; i < util::size(CategoryIndexToCategoryIdMap); ++i) {
+                if (CategoryIndexToCategoryIdMap[i] == id) {
+                    return i;
+                }
+            }
+
+            return util::nullopt;
+        } else {
+            if (const auto it = std::lower_bound(std::begin(CategoryIndexToCategoryIdMap), std::end(CategoryIndexToCategoryIdMap), id); it != std::end(CategoryIndexToCategoryIdMap) && *it == id) {
+                return std::distance(CategoryIndexToCategoryIdMap, it);
+            } else {
+                return util::nullopt;
+            }
+        }
     }
 
-    inline FieldFlag ConvertFieldToFlag(FieldId id) {
-        return FieldToFlagMap[id];
+    constexpr inline CategoryId ConvertFieldToCategory(FieldId id) {
+        const auto index = FindFieldIndex(id);
+        AMS_ASSERT(index.has_value());
+        return FieldIndexToCategoryMap[index.value()];
+    }
+
+    constexpr inline FieldType ConvertFieldToType(FieldId id) {
+        const auto index = FindFieldIndex(id);
+        AMS_ASSERT(index.has_value());
+        return FieldIndexToTypeMap[index.value()];
+    }
+
+    constexpr inline FieldFlag ConvertFieldToFlag(FieldId id) {
+        const auto index = FindFieldIndex(id);
+        AMS_ASSERT(index.has_value());
+        return FieldIndexToFlagMap[index.value()];
     }
 
     constexpr inline ReportFlagSet MakeNoReportFlags() {

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

@@ -81,6 +81,8 @@ namespace ams::hos {
         Version_16_0_3  = ::ams::TargetFirmware_16_0_3,
         Version_16_1_0  = ::ams::TargetFirmware_16_1_0,
         Version_17_0_0  = ::ams::TargetFirmware_17_0_0,
+        Version_17_0_1  = ::ams::TargetFirmware_17_0_1,
+        Version_18_0_0  = ::ams::TargetFirmware_18_0_0,
 
         Version_Current = ::ams::TargetFirmware_Current,
 

libraries/libstratosphere/include/stratosphere/settings/settings_types.hpp

@@ -53,7 +53,8 @@ namespace ams::settings {
         /* 4.0.0+ */
         Language_SimplifiedChinese,
         Language_TraditionalChinese,
-
+        /* 10.1.0+ */
+        Language_PortugueseBr,
         Language_Count,
     };
 
@@ -92,6 +93,8 @@ namespace ams::settings {
             /* 4.0.0+ */
             AMS_MATCH_LANGUAGE(SimplifiedChinese,       "zh-Hans")
             AMS_MATCH_LANGUAGE(TraditionalChinese,      "zh-Hant")
+            /* 10.1.0+ */
+            AMS_MATCH_LANGUAGE(PortugueseBr,            "pt-BR")
             #undef AMS_MATCH_LANGUAGE
             else { static_assert(Lang != Language_Japanese); }
         }
@@ -116,6 +119,8 @@ namespace ams::settings {
                 /* 4.0.0+ */
                 EncodeLanguage<Language_SimplifiedChinese>(),
                 EncodeLanguage<Language_TraditionalChinese>(),
+                /* 10.1.0+ */
+                EncodeLanguage<Language_PortugueseBr>(),
             };
             return EncodedLanguages[language];
         }
@@ -156,7 +161,11 @@ namespace ams::settings {
     }
 
     constexpr inline bool IsValidLanguageCodeDeprecated(const LanguageCode &lc) {
-        return impl::IsValidLanguageCode(lc, std::make_index_sequence<Language_Count - 2>{});
+        return impl::IsValidLanguageCode(lc, std::make_index_sequence<Language_Count - 3>{});
+    }
+
+    constexpr inline bool IsValidLanguageCodeDeprecated2(const LanguageCode &lc) {
+        return impl::IsValidLanguageCode(lc, std::make_index_sequence<Language_Count - 1>{});
     }
 
     constexpr inline bool IsValidLanguageCode(const LanguageCode &lc) {

libraries/libstratosphere/include/stratosphere/sf/cmif/sf_cmif_domain_service_object.hpp

@@ -62,7 +62,7 @@ namespace ams::sf::cmif {
             }
 
             constexpr size_t GetImplOutDataTotalSize() const {
-                return m_impl_metadata.GetOutDataSize() + m_impl_metadata.GetOutHeadersSize();
+                return m_impl_metadata.GetUnalignedOutDataSize() + m_impl_metadata.GetOutHeadersSize();
             }
         public:
             /* Used to enabled templated message processors. */
@@ -80,12 +80,12 @@ namespace ams::sf::cmif {
                 const auto runtime_metadata = m_impl_processor->GetRuntimeMetadata();
 
                 return ServerMessageRuntimeMetadata {
-                    .in_data_size      = static_cast<u16>(runtime_metadata.GetInDataSize()  + runtime_metadata.GetInObjectCount() * sizeof(DomainObjectId)),
-                    .out_data_size     = static_cast<u16>(runtime_metadata.GetOutDataSize() + runtime_metadata.GetOutObjectCount() * sizeof(DomainObjectId)),
-                    .in_headers_size   = static_cast<u8>(runtime_metadata.GetInHeadersSize()  + sizeof(CmifDomainInHeader)),
-                    .out_headers_size  = static_cast<u8>(runtime_metadata.GetOutHeadersSize() + sizeof(CmifDomainOutHeader)),
-                    .in_object_count   = 0,
-                    .out_object_count  = 0,
+                    .in_data_size            = static_cast<u16>(runtime_metadata.GetInDataSize()  + runtime_metadata.GetInObjectCount() * sizeof(DomainObjectId)),
+                    .unaligned_out_data_size = static_cast<u16>(runtime_metadata.GetOutDataSize() + runtime_metadata.GetOutObjectCount() * sizeof(DomainObjectId)),
+                    .in_headers_size         = static_cast<u8>(runtime_metadata.GetInHeadersSize()  + sizeof(CmifDomainInHeader)),
+                    .out_headers_size        = static_cast<u8>(runtime_metadata.GetOutHeadersSize() + sizeof(CmifDomainOutHeader)),
+                    .in_object_count         = 0,
+                    .out_object_count        = 0,
                 };
             }
 

libraries/libstratosphere/include/stratosphere/sf/cmif/sf_cmif_server_message_processor.hpp

@@ -28,7 +28,7 @@ namespace ams::sf::cmif {
     /* This is needed for non-templated domain message processing. */
     struct ServerMessageRuntimeMetadata {
         u16 in_data_size;
-        u16 out_data_size;
+        u16 unaligned_out_data_size;
         u8 in_headers_size;
         u8 out_headers_size;
         u8 in_object_count;
@@ -39,7 +39,11 @@ namespace ams::sf::cmif {
         }
 
         constexpr size_t GetOutDataSize() const {
-            return static_cast<size_t>(this->out_data_size);
+            return static_cast<size_t>(util::AlignUp(this->unaligned_out_data_size, sizeof(u32)));
+        }
+
+        constexpr size_t GetUnalignedOutDataSize() const {
+            return static_cast<size_t>(this->unaligned_out_data_size);
         }
 
         constexpr size_t GetInHeadersSize() const {

libraries/libstratosphere/include/stratosphere/sf/impl/sf_impl_command_serialization.hpp

@@ -472,6 +472,7 @@ namespace ams::sf::impl {
             static constexpr size_t InDataSize  = util::AlignUp(InDataOffsets[NumInDatas], alignof(u16));
 
             static constexpr std::array<size_t, NumOutDatas+1> OutDataOffsets = RawDataOffsetCalculator<OutDatas>::Offsets;
+            static constexpr size_t UnalignedOutDataSize = OutDataOffsets[NumOutDatas];
             static constexpr size_t OutDataSize = util::AlignUp(OutDataOffsets[NumOutDatas], alignof(u32));
             static constexpr size_t OutDataAlign = [] {
                 if constexpr (std::tuple_size<OutDatas>::value) {
@@ -492,12 +493,12 @@ namespace ams::sf::impl {
 
             /* Used by server message processor at runtime. */
             static constexpr inline const cmif::ServerMessageRuntimeMetadata RuntimeMetadata = cmif::ServerMessageRuntimeMetadata{
-                .in_data_size      = InDataSize,
-                .out_data_size     = OutDataSize,
-                .in_headers_size   = sizeof(CmifInHeader),
-                .out_headers_size  = sizeof(CmifOutHeader),
-                .in_object_count   = NumInObjects,
-                .out_object_count  = NumOutObjects,
+                .in_data_size            = InDataSize,
+                .unaligned_out_data_size = UnalignedOutDataSize,
+                .in_headers_size         = sizeof(CmifInHeader),
+                .out_headers_size        = sizeof(CmifOutHeader),
+                .in_object_count         = NumInObjects,
+                .out_object_count        = NumOutObjects,
             };
 
         /* Construction of argument serialization structs. */

libraries/libstratosphere/include/stratosphere/spl/impl/spl_api_impl.hpp

@@ -70,6 +70,7 @@ namespace ams::spl::impl {
     Result ModularExponentiateWithDrmDeviceCertKey(void *out, size_t out_size, const void *base, size_t base_size, const void *mod, size_t mod_size);
     Result PrepareEsArchiveKey(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation);
     Result LoadPreparedAesKey(s32 keyslot, const AccessKey &access_key);
+    Result PrepareEsUnknown2Key(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation);
 
     /* FS */
     Result DecryptAndStoreGcKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source, u32 option);

libraries/libstratosphere/include/stratosphere/spl/impl/spl_es_interface.hpp

@@ -28,6 +28,7 @@
     AMS_SF_METHOD_INFO(C, H, 28, Result, DecryptAndStoreDrmDeviceCertKey,         (const sf::InPointerBuffer &src, spl::AccessKey access_key, spl::KeySource key_source),                                                                             (src, access_key, key_source),                         hos::Version_5_0_0)                     \
     AMS_SF_METHOD_INFO(C, H, 29, Result, ModularExponentiateWithDrmDeviceCertKey, (const sf::OutPointerBuffer &out, const sf::InPointerBuffer &base, const sf::InPointerBuffer &mod),                                                                 (out, base, mod),                                      hos::Version_5_0_0)                     \
     AMS_SF_METHOD_INFO(C, H, 31, Result, PrepareEsArchiveKey,                     (sf::Out<spl::AccessKey> out_access_key, const sf::InPointerBuffer &base, const sf::InPointerBuffer &mod, const sf::InPointerBuffer &label_digest, u32 generation), (out_access_key, base, mod, label_digest, generation), hos::Version_6_0_0)                     \
-    AMS_SF_METHOD_INFO(C, H, 32, Result, LoadPreparedAesKey,                      (s32 keyslot, spl::AccessKey access_key),                                                                                                                           (keyslot, access_key),                                 hos::Version_6_0_0)
+    AMS_SF_METHOD_INFO(C, H, 32, Result, LoadPreparedAesKey,                      (s32 keyslot, spl::AccessKey access_key),                                                                                                                           (keyslot, access_key),                                 hos::Version_6_0_0)                     \
+    AMS_SF_METHOD_INFO(C, H, 33, Result, PrepareEsUnknown2Key,                    (sf::Out<spl::AccessKey> out_access_key, const sf::InPointerBuffer &base, const sf::InPointerBuffer &mod, const sf::InPointerBuffer &label_digest, u32 generation), (out_access_key, base, mod, label_digest, generation), hos::Version_18_0_0)
 
 AMS_SF_DEFINE_INTERFACE_WITH_BASE(ams::spl::impl, IEsInterface, ::ams::spl::impl::IDeviceUniqueDataInterface, AMS_SPL_I_ES_INTERFACE_INTERFACE_INFO, 0x346D5001)

libraries/libstratosphere/include/stratosphere/svc/svc_stratosphere_shims.hpp

@@ -331,8 +331,8 @@
                     R_RETURN(::svcQueryPhysicalAddress(reinterpret_cast<::PhysicalMemoryInfo *>(out_info), address));
                 }
 
-                ALWAYS_INLINE Result QueryIoMapping(::ams::svc::Address *out_address, ::ams::svc::Size *out_size, ::ams::svc::PhysicalAddress physical_address, ::ams::svc::Size size) {
-                    R_RETURN(::svcQueryIoMapping(reinterpret_cast<u64 *>(out_address), reinterpret_cast<u64 *>(out_size), physical_address, size));
+                ALWAYS_INLINE Result QueryMemoryMapping(::ams::svc::Address *out_address, ::ams::svc::Size *out_size, ::ams::svc::PhysicalAddress physical_address, ::ams::svc::Size size) {
+                    R_RETURN(::svcQueryMemoryMapping(reinterpret_cast<u64 *>(out_address), reinterpret_cast<u64 *>(out_size), physical_address, size));
                 }
 
                 ALWAYS_INLINE Result LegacyQueryIoMapping(::ams::svc::Address *out_address, ::ams::svc::PhysicalAddress physical_address, ::ams::svc::Size size) {
@@ -503,12 +503,12 @@
                     ::svcCallSecureMonitor(reinterpret_cast<::SecmonArgs *>(args));
                 }
 
-                ALWAYS_INLINE Result MapInsecureMemory(::ams::svc::Address address, ::ams::svc::Size size) {
-                    R_RETURN(::svcMapInsecureMemory(reinterpret_cast<void *>(static_cast<uintptr_t>(address)), size));
+                ALWAYS_INLINE Result MapInsecurePhysicalMemory(::ams::svc::Address address, ::ams::svc::Size size) {
+                    R_RETURN(::svcMapInsecurePhysicalMemory(reinterpret_cast<void *>(static_cast<uintptr_t>(address)), size));
                 }
 
-                ALWAYS_INLINE Result UnmapInsecureMemory(::ams::svc::Address address, ::ams::svc::Size size) {
-                    R_RETURN(::svcUnmapInsecureMemory(reinterpret_cast<void *>(static_cast<uintptr_t>(address)), size));
+                ALWAYS_INLINE Result UnmapInsecurePhysicalMemory(::ams::svc::Address address, ::ams::svc::Size size) {
+                    R_RETURN(::svcUnmapInsecurePhysicalMemory(reinterpret_cast<void *>(static_cast<uintptr_t>(address)), size));
                 }
 
             }

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

@@ -69,13 +69,13 @@ namespace ams::erpt::srv {
 
         auto guard = SCOPE_GUARD { m_ctx.field_count = 0; };
 
-        R_UNLESS(m_ctx.field_count <= FieldsPerContext,                    erpt::ResultInvalidArgument());
-        R_UNLESS(0 <= m_ctx.category && m_ctx.category < CategoryId_Count, erpt::ResultInvalidArgument());
+        R_UNLESS(m_ctx.field_count <= FieldsPerContext,         erpt::ResultInvalidArgument());
+        R_UNLESS(FindCategoryIndex(m_ctx.category).has_value(), erpt::ResultInvalidArgument());
 
         for (u32 i = 0; i < m_ctx.field_count; i++) {
             m_ctx.fields[i] = ctx_ptr->fields[i];
 
-            R_UNLESS(0 <= m_ctx.fields[i].id   && m_ctx.fields[i].id   < FieldId_Count,   erpt::ResultInvalidArgument());
+            R_UNLESS(FindFieldIndex(m_ctx.fields[i].id).has_value(),                      erpt::ResultInvalidArgument());
             R_UNLESS(0 <= m_ctx.fields[i].type && m_ctx.fields[i].type < FieldType_Count, erpt::ResultInvalidArgument());
 
             R_UNLESS(m_ctx.fields[i].type == ConvertFieldToType(m_ctx.fields[i].id),     erpt::ResultFieldTypeMismatch());

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

@@ -62,7 +62,10 @@ namespace ams::erpt::srv {
             static Result AddId(Report *report, FieldId field_id) {
                 static_assert(MaxFieldStringSize < ElementSize_256);
 
-                R_TRY(AddStringValue(report, FieldString[field_id], strnlen(FieldString[field_id], MaxFieldStringSize)));
+                const auto index = FindFieldIndex(field_id);
+                AMS_ASSERT(index.has_value());
+
+                R_TRY(AddStringValue(report, FieldString[index.value()], strnlen(FieldString[index.value()], MaxFieldStringSize)));
 
                 R_SUCCEED();
             }

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

@@ -105,8 +105,8 @@ namespace ams::erpt::srv {
 
         g_sf_allocator.Attach(g_heap_handle);
 
-        for (auto i = 0; i < CategoryId_Count; i++) {
-            Context *ctx = new Context(static_cast<CategoryId>(i));
+        for (const auto category_id : CategoryIndexToCategoryIdMap) {
+            Context *ctx = new Context(category_id);
             AMS_ABORT_UNLESS(ctx != nullptr);
         }
 

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

@@ -277,7 +277,7 @@ namespace ams::erpt::srv {
         void SaveSyslogReportIfRequired(const ContextEntry *ctx, const ReportId &report_id) {
             bool needs_save_syslog = true;
             for (u32 i = 0; i < ctx->field_count; i++) {
-                static_assert(FieldToTypeMap[FieldId_HasSyslogFlag] == FieldType_Bool);
+                static_assert(FieldIndexToTypeMap[*FindFieldIndex(FieldId_HasSyslogFlag)] == FieldType_Bool);
                 if (ctx->fields[i].id == FieldId_HasSyslogFlag && !ctx->fields[i].value_bool) {
                     needs_save_syslog = false;
                     break;

libraries/libstratosphere/source/fs/fs_romfs_filesystem.cpp

@@ -500,7 +500,7 @@ namespace ams::fs {
 
         R_UNLESS((mode & fs::OpenMode_All) == fs::OpenMode_Read, fs::ResultInvalidOpenMode());
 
-        RomFileTable::FileInfo file_info;
+        RomFileTable::FileInfo file_info{};
         R_TRY(this->GetFileInfo(std::addressof(file_info), path.GetString()));
 
         auto file = std::make_unique<RomFsFile>(this, m_entry_size + file_info.offset.Get(), m_entry_size + file_info.offset.Get() + file_info.size.Get());

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

@@ -21,7 +21,7 @@ namespace ams::fs::impl {
     #define ADD_ENUM_CASE(v) case v: return #v
 
     template<> const char *IdString::ToString<pkg1::KeyGeneration>(pkg1::KeyGeneration id) {
-        static_assert(pkg1::KeyGeneration_Current == pkg1::KeyGeneration_17_0_0);
+        static_assert(pkg1::KeyGeneration_Current == pkg1::KeyGeneration_18_0_0);
         switch (id) {
             using enum pkg1::KeyGeneration;
             case KeyGeneration_1_0_0:  return "1.0.0-2.3.0";
@@ -40,7 +40,8 @@ namespace ams::fs::impl {
             case KeyGeneration_14_0_0: return "14.0.0-14.1.2";
             case KeyGeneration_15_0_0: return "15.0.0-15.0.1";
             case KeyGeneration_16_0_0: return "16.0.0-16.0.3";
-            case KeyGeneration_17_0_0: return "17.0.0-";
+            case KeyGeneration_17_0_0: return "17.0.0-17.0.1";
+            case KeyGeneration_18_0_0: return "18.0.0-";
             default: return "Unknown";
         }
     }

libraries/libstratosphere/source/fssrv/fssrv_program_registry_impl.cpp

@@ -34,8 +34,8 @@ namespace ams::fssrv {
 
     void ProgramRegistryImpl::Initialize(ProgramRegistryServiceImpl *service) {
         /* Check pre-conditions. */
-        AMS_ASSERT(g_impl != nullptr);
-        AMS_ASSERT(g_impl == nullptr);
+        AMS_ASSERT(service != nullptr);
+        AMS_ASSERT(g_impl  == nullptr);
 
         /* Set the global service. */
         g_impl = service;

libraries/libstratosphere/source/htc/server/rpc/htc_rpc_client.cpp

@@ -288,7 +288,7 @@ namespace ams::htc::server::rpc {
             /* Get a task. */
             Task *task;
             u32 task_id{};
-            PacketCategory category;
+            PacketCategory category{};
             do {
                 /* Dequeue a task. */
                 R_TRY(m_task_queue.Take(std::addressof(task_id), std::addressof(category)));

libraries/libstratosphere/source/htcs/impl/htcs_manager.cpp

@@ -39,7 +39,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Socket(s32 *out_err, s32 *out_desc, bool enable_disconnection_emulation) {
         /* Invoke our implementation. */
-        s32 err, desc;
+        s32 err = -1, desc = -1;
         const Result result = m_impl->CreateSocket(std::addressof(err), std::addressof(desc), enable_disconnection_emulation);
 
         /* Set output. */
@@ -71,7 +71,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Connect(s32 *out_err, s32 *out_res, const SockAddrHtcs &address, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->Connect(std::addressof(err), desc, address);
 
         /* Set output. */
@@ -90,7 +90,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Bind(s32 *out_err, s32 *out_res, const SockAddrHtcs &address, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->Bind(std::addressof(err), desc, address);
 
         /* Set output. */
@@ -109,7 +109,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Listen(s32 *out_err, s32 *out_res, s32 backlog_count, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->Listen(std::addressof(err), desc, backlog_count);
 
         /* Set output. */
@@ -128,8 +128,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Recv(s32 *out_err, s64 *out_size, char *buffer, size_t size, s32 flags, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
-        s64 recv_size;
+        s32 err = -1;
+        s64 recv_size = -1;
         const Result result = m_impl->Receive(std::addressof(err), std::addressof(recv_size), buffer, size, desc, flags);
 
         /* Set output. */
@@ -148,8 +148,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Send(s32 *out_err, s64 *out_size, const char *buffer, size_t size, s32 flags, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
-        s64 send_size;
+        s32 err = -1;
+        s64 send_size = -1;
         const Result result = m_impl->Send(std::addressof(err), std::addressof(send_size), buffer, size, desc, flags);
 
         /* Set output. */
@@ -168,7 +168,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Shutdown(s32 *out_err, s32 *out_res, s32 how, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->Shutdown(std::addressof(err), desc, how);
 
         /* Set output. */
@@ -191,7 +191,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Fcntl(s32 *out_err, s32 *out_res, s32 command, s32 value, s32 desc) {
         /* Invoke our implementation. */
-        s32 err, res;
+        s32 err = -1, res = -1;
         const Result result = m_impl->Fcntl(std::addressof(err), std::addressof(res), desc, command, value);
 
         /* Set output. */
@@ -210,7 +210,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->AcceptResults(std::addressof(err), out_desc, out_address, task_id, desc);
 
         /* Set output. */
@@ -233,8 +233,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::RecvResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
-        s64 size;
+        s32 err = -1;
+        s64 size = -1;
         const Result result = m_impl->RecvResults(std::addressof(err), std::addressof(size), buffer, buffer_size, task_id, desc);
 
         /* Set output. */
@@ -265,8 +265,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
-        s64 size;
+        s32 err = -1;
+        s64 size = -1;
         const Result result = m_impl->SendResults(std::addressof(err), std::addressof(size), task_id, desc);
 
         /* Set output. */
@@ -293,7 +293,7 @@ namespace ams::htcs::impl {
 
     Result HtcsManager::ContinueSend(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s64 size;
+        s64 size = -1;
         R_TRY_CATCH(m_impl->ContinueSend(std::addressof(size), buffer, buffer_size, task_id, desc)) {
             R_CONVERT(htclow::ResultInvalidChannelState, tma::ResultUnknown())
             R_CONVERT(htc::ResultTaskCancelled,          tma::ResultUnknown())
@@ -306,8 +306,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::EndSend(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
-        s64 size;
+        s32 err = -1;
+        s64 size = -1;
         const Result result = m_impl->EndSend(std::addressof(err), std::addressof(size), task_id, desc);
 
         /* Set output. */
@@ -334,8 +334,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::EndRecv(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
-        s64 size;
+        s32 err = -1;
+        s64 size = -1;
         const Result result = m_impl->EndRecv(std::addressof(err), std::addressof(size), buffer, buffer_size, task_id, desc);
 
         /* Set output. */
@@ -367,8 +367,8 @@ namespace ams::htcs::impl {
 
     Result HtcsManager::EndSelect(s32 *out_err, s32 *out_count, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id) {
         /* Invoke our implementation. */
-        s32 err;
-        bool empty;
+        s32 err = -1;
+        bool empty = false;
         const Result result = m_impl->EndSelect(std::addressof(err), std::addressof(empty), read_handles, write_handles, exception_handles, task_id);
 
         /* Set output. */

libraries/libstratosphere/source/os/impl/os_insecure_memory_impl.os.horizon.cpp

@@ -23,7 +23,7 @@ namespace ams::os::impl {
         /* Map at a random address. */
         R_RETURN(impl::GetAslrSpaceManager().MapAtRandomAddress(out_address,
             [](uintptr_t map_address, size_t map_size) -> Result {
-                R_TRY_CATCH(svc::MapInsecureMemory(map_address, map_size)) {
+                R_TRY_CATCH(svc::MapInsecurePhysicalMemory(map_address, map_size)) {
                     R_CONVERT(svc::ResultOutOfMemory,          os::ResultOutOfMemory())
                     R_CONVERT(svc::ResultInvalidCurrentMemory, os::ResultInvalidCurrentMemoryState())
                 } R_END_TRY_CATCH_WITH_ABORT_UNLESS;
@@ -39,7 +39,7 @@ namespace ams::os::impl {
     }
 
     void InsecureMemoryImpl::FreeInsecureMemoryImpl(uintptr_t address, size_t size) {
-        R_ABORT_UNLESS(svc::UnmapInsecureMemory(address, size));
+        R_ABORT_UNLESS(svc::UnmapInsecurePhysicalMemory(address, size));
     }
 
 }

libraries/libstratosphere/source/os/impl/os_vamm_manager_impl.os.horizon.hpp

@@ -21,11 +21,12 @@ namespace ams::os::impl {
     class VammManagerHorizonImpl {
         public:
             static void GetReservedRegionImpl(uintptr_t *out_start, uintptr_t *out_size) {
-                u64 start, size;
-                R_ABORT_UNLESS(svc::GetInfo(std::addressof(start), svc::InfoType_AliasRegionAddress, svc::PseudoHandle::CurrentProcess, 0));
-                R_ABORT_UNLESS(svc::GetInfo(std::addressof(size),  svc::InfoType_AliasRegionSize,    svc::PseudoHandle::CurrentProcess, 0));
+                u64 start, size, extra_size;
+                R_ABORT_UNLESS(svc::GetInfo(std::addressof(start),      svc::InfoType_AliasRegionAddress,   svc::PseudoHandle::CurrentProcess, 0));
+                R_ABORT_UNLESS(svc::GetInfo(std::addressof(size),       svc::InfoType_AliasRegionSize,      svc::PseudoHandle::CurrentProcess, 0));
+                R_ABORT_UNLESS(svc::GetInfo(std::addressof(extra_size), svc::InfoType_AliasRegionExtraSize, svc::PseudoHandle::CurrentProcess, 0));
                 *out_start = start;
-                *out_size  = size;
+                *out_size  = size - extra_size;
             }
 
             static Result AllocatePhysicalMemoryImpl(uintptr_t address, size_t size) {

libraries/libstratosphere/source/patcher/patcher_api.cpp

@@ -167,6 +167,7 @@ namespace ams::patcher {
 
                     /* Apply patch. */
                     if (patch_offset + rle_size > mapped_size) {
+                        AMS_ABORT_UNLESS(patch_offset <= mapped_size);
                         rle_size = mapped_size - patch_offset;
                     }
                     std::memset(mapped_module + patch_offset, buffer[0], rle_size);
@@ -190,6 +191,7 @@ namespace ams::patcher {
                     /* Apply patch. */
                     u32 read_size = patch_size;
                     if (patch_offset + read_size > mapped_size) {
+                        AMS_ABORT_UNLESS(patch_offset <= mapped_size);
                         read_size = mapped_size - patch_offset;
                     }
                     {

libraries/libstratosphere/source/spl/impl/spl_api_impl.cpp

@@ -893,6 +893,10 @@ namespace ams::spl::impl {
         R_RETURN(PrepareEsDeviceUniqueKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, smc::EsDeviceUniqueKeyType::ArchiveKey, generation));
     }
 
+    Result PrepareEsUnknown2Key(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation) {
+        R_RETURN(PrepareEsDeviceUniqueKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, smc::EsDeviceUniqueKeyType::Unknown2, generation));
+    }
+
     /* FS */
     Result DecryptAndStoreGcKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source, u32 option) {
         R_RETURN(DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, option));

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

@@ -16,11 +16,11 @@
 #pragma once
 
 #define ATMOSPHERE_RELEASE_VERSION_MAJOR    1
-#define ATMOSPHERE_RELEASE_VERSION_MINOR    6
-#define ATMOSPHERE_RELEASE_VERSION_MICRO    2
+#define ATMOSPHERE_RELEASE_VERSION_MINOR    7
+#define ATMOSPHERE_RELEASE_VERSION_MICRO    0
 
 #define ATMOSPHERE_RELEASE_VERSION ATMOSPHERE_RELEASE_VERSION_MAJOR, ATMOSPHERE_RELEASE_VERSION_MINOR, ATMOSPHERE_RELEASE_VERSION_MICRO
 
-#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MAJOR 17
+#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MAJOR 18
 #define ATMOSPHERE_SUPPORTED_HOS_VERSION_MINOR 0
 #define ATMOSPHERE_SUPPORTED_HOS_VERSION_MICRO 0

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

@@ -79,8 +79,10 @@
 #define ATMOSPHERE_TARGET_FIRMWARE_16_0_3 ATMOSPHERE_TARGET_FIRMWARE(16,  0,  3)
 #define ATMOSPHERE_TARGET_FIRMWARE_16_1_0 ATMOSPHERE_TARGET_FIRMWARE(16,  1,  0)
 #define ATMOSPHERE_TARGET_FIRMWARE_17_0_0 ATMOSPHERE_TARGET_FIRMWARE(17,  0,  0)
+#define ATMOSPHERE_TARGET_FIRMWARE_17_0_1 ATMOSPHERE_TARGET_FIRMWARE(17,  0,  1)
+#define ATMOSPHERE_TARGET_FIRMWARE_18_0_0 ATMOSPHERE_TARGET_FIRMWARE(18,  0,  0)
 
-#define ATMOSPHERE_TARGET_FIRMWARE_CURRENT ATMOSPHERE_TARGET_FIRMWARE_17_0_0
+#define ATMOSPHERE_TARGET_FIRMWARE_CURRENT ATMOSPHERE_TARGET_FIRMWARE_18_0_0
 
 #define ATMOSPHERE_TARGET_FIRMWARE_MIN ATMOSPHERE_TARGET_FIRMWARE(0, 0, 0)
 #define ATMOSPHERE_TARGET_FIRMWARE_MAX ATMOSPHERE_TARGET_FIRMWARE_CURRENT
@@ -152,6 +154,8 @@ namespace ams {
         TargetFirmware_16_0_3  = ATMOSPHERE_TARGET_FIRMWARE_16_0_3,
         TargetFirmware_16_1_0  = ATMOSPHERE_TARGET_FIRMWARE_16_1_0,
         TargetFirmware_17_0_0  = ATMOSPHERE_TARGET_FIRMWARE_17_0_0,
+        TargetFirmware_17_0_1  = ATMOSPHERE_TARGET_FIRMWARE_17_0_1,
+        TargetFirmware_18_0_0  = ATMOSPHERE_TARGET_FIRMWARE_18_0_0,
 
         TargetFirmware_Current = ATMOSPHERE_TARGET_FIRMWARE_CURRENT,
 

libraries/libvapours/include/vapours/svc/svc_definition_macro.hpp

@@ -99,7 +99,7 @@
     HANDLER(0x52, Result,  UnmapTransferMemory,            INPUT(::ams::svc::Handle, trmem_handle), INPUT(::ams::svc::Address, address), INPUT(::ams::svc::Size, size))                                                                                                                                                \
     HANDLER(0x53, Result,  CreateInterruptEvent,           OUTPUT(::ams::svc::Handle, out_read_handle), INPUT(int32_t, interrupt_id), INPUT(::ams::svc::InterruptType, interrupt_type))                                                                                                                                \
     HANDLER(0x54, Result,  QueryPhysicalAddress,           OUTPUT(::ams::svc::NAMESPACE::PhysicalMemoryInfo, out_info), INPUT(::ams::svc::Address, address))                                                                                                                                                           \
-    HANDLER(0x55, Result,  QueryIoMapping,                 OUTPUT(::ams::svc::Address, out_address), OUTPUT(::ams::svc::Size, out_size), INPUT(::ams::svc::PhysicalAddress, physical_address), INPUT(::ams::svc::Size, size))                                                                                          \
+    HANDLER(0x55, Result,  QueryMemoryMapping,             OUTPUT(::ams::svc::Address, out_address), OUTPUT(::ams::svc::Size, out_size), INPUT(::ams::svc::PhysicalAddress, physical_address), INPUT(::ams::svc::Size, size))                                                                                          \
     HANDLER(0x56, Result,  CreateDeviceAddressSpace,       OUTPUT(::ams::svc::Handle, out_handle), INPUT(uint64_t, das_address), INPUT(uint64_t, das_size))                                                                                                                                                            \
     HANDLER(0x57, Result,  AttachDeviceAddressSpace,       INPUT(::ams::svc::DeviceName, device_name), INPUT(::ams::svc::Handle, das_handle))                                                                                                                                                                          \
     HANDLER(0x58, Result,  DetachDeviceAddressSpace,       INPUT(::ams::svc::DeviceName, device_name), INPUT(::ams::svc::Handle, das_handle))                                                                                                                                                                          \
@@ -142,8 +142,8 @@
     HANDLER(0x7E, Result,  SetResourceLimitLimitValue,     INPUT(::ams::svc::Handle, resource_limit_handle), INPUT(::ams::svc::LimitableResource, which), INPUT(int64_t, limit_value))                                                                                                                                 \
     HANDLER(0x7F, void,    CallSecureMonitor,              OUTPUT(::ams::svc::NAMESPACE::SecureMonitorArguments, args))                                                                                                                                                                                                \
                                                                                                                                                                                                                                                                                                                        \
-    HANDLER(0x90, Result,  MapInsecureMemory,              INPUT(::ams::svc::Address, address), INPUT(::ams::svc::Size, size))                                                                                                                                                                                         \
-    HANDLER(0x91, Result,  UnmapInsecureMemory,            INPUT(::ams::svc::Address, address), INPUT(::ams::svc::Size, size))                                                                                                                                                                                         \
+    HANDLER(0x90, Result,  MapInsecurePhysicalMemory,      INPUT(::ams::svc::Address, address), INPUT(::ams::svc::Size, size))                                                                                                                                                                                         \
+    HANDLER(0x91, Result,  UnmapInsecurePhysicalMemory,    INPUT(::ams::svc::Address, address), INPUT(::ams::svc::Size, size))                                                                                                                                                                                         \
                                                                                                                                                                                                                                                                                                                        \
     HANDLER(0x2E, Result,  LegacyGetFutureThreadInfo,      OUTPUT(::ams::svc::NAMESPACE::LastThreadContext, out_context), OUTPUT(::ams::svc::Address, out_tls_address), OUTPUT(uint32_t, out_flags), INPUT(int64_t, ns))                                                                                               \
     HANDLER(0x55, Result,  LegacyQueryIoMapping,           OUTPUT(::ams::svc::Address, out_address), INPUT(::ams::svc::PhysicalAddress, physical_address), INPUT(::ams::svc::Size, size))                                                                                                                              \

libraries/libvapours/include/vapours/svc/svc_types_common.hpp

@@ -190,6 +190,7 @@ namespace ams::svc {
         InfoType_ThreadTickCount                = 25,
         InfoType_IsSvcPermitted                 = 26,
         InfoType_IoRegionHint                   = 27,
+        InfoType_AliasRegionExtraSize           = 28,
 
         InfoType_MesosphereMeta                 = 65000,
         InfoType_MesosphereCurrentProcess       = 65001,
@@ -436,15 +437,19 @@ namespace ams::svc {
         /* 11.x+ DisableDeviceAddressSpaceMerge. */
         CreateProcessFlag_DisableDeviceAddressSpaceMerge = (1 << 12),
 
+        /* 18.x EnableAliasRegionExtraSize. */
+        CreateProcessFlag_EnableAliasRegionExtraSize = (1 << 13),
+
         /* Mask of all flags. */
-        CreateProcessFlag_All = CreateProcessFlag_Is64Bit                  |
-                                CreateProcessFlag_AddressSpaceMask         |
-                                CreateProcessFlag_EnableDebug              |
-                                CreateProcessFlag_EnableAslr               |
-                                CreateProcessFlag_IsApplication            |
-                                CreateProcessFlag_PoolPartitionMask        |
-                                CreateProcessFlag_OptimizeMemoryAllocation |
-                                CreateProcessFlag_DisableDeviceAddressSpaceMerge,
+        CreateProcessFlag_All = CreateProcessFlag_Is64Bit                        |
+                                CreateProcessFlag_AddressSpaceMask               |
+                                CreateProcessFlag_EnableDebug                    |
+                                CreateProcessFlag_EnableAslr                     |
+                                CreateProcessFlag_IsApplication                  |
+                                CreateProcessFlag_PoolPartitionMask              |
+                                CreateProcessFlag_OptimizeMemoryAllocation       |
+                                CreateProcessFlag_DisableDeviceAddressSpaceMerge |
+                                CreateProcessFlag_EnableAliasRegionExtraSize,
     };
 
     /* Debug types. */

libraries/libvapours/include/vapours/svc/svc_version.hpp

@@ -57,8 +57,8 @@ namespace ams::svc {
 
     /* This is the highest SVC version supported by Atmosphere, to be updated on new kernel releases. */
     /* NOTE: Official kernel versions have SVC major = SDK major + 4, SVC minor = SDK minor. */
-    constexpr inline u32 SupportedKernelMajorVersion = ConvertToSvcMajorVersion(17);
-    constexpr inline u32 SupportedKernelMinorVersion = ConvertToSvcMinorVersion( 5);
+    constexpr inline u32 SupportedKernelMajorVersion = ConvertToSvcMajorVersion(18);
+    constexpr inline u32 SupportedKernelMinorVersion = ConvertToSvcMinorVersion( 3);
 
     constexpr inline u32 SupportedKernelVersion = EncodeKernelVersion(SupportedKernelMajorVersion, SupportedKernelMinorVersion);
 

libraries/libvapours/source/dd/dd_io_mapping.os.horizon.cpp

@@ -68,7 +68,7 @@ namespace ams::dd {
 
             if (hos::GetVersion() >= hos::Version_10_0_0) {
                 svc::Size region_size = 0;
-                R_TRY_CATCH(svc::QueryIoMapping(std::addressof(virt_addr), std::addressof(region_size), aligned_addr, aligned_size)) {
+                R_TRY_CATCH(svc::QueryMemoryMapping(std::addressof(virt_addr), std::addressof(region_size), aligned_addr, aligned_size)) {
                     /* Official software handles this by returning 0. */
                     R_CATCH(svc::ResultNotFound) { return 0; }
                 } R_END_TRY_CATCH_WITH_ABORT_UNLESS;

mesosphere/kernel/source/arch/arm64/init/kern_init_core.cpp

@@ -345,7 +345,7 @@ namespace ams::kern::init {
         MESOSPHERE_INIT_ABORT_UNLESS(slab_region_size <= resource_region_size);
 
         /* Setup the slab region. */
-        const KPhysicalAddress code_start_phys_addr = init_pt.GetPhysicalAddressOfRandomizedRange(code_start_virt_addr, code_region_size);
+        const KPhysicalAddress code_start_phys_addr = g_phase2_initial_process_binary_meta.layout.kern_address;
         const KPhysicalAddress code_end_phys_addr   = code_start_phys_addr + code_region_size;
         const KPhysicalAddress slab_start_phys_addr = code_end_phys_addr;
         const KPhysicalAddress slab_end_phys_addr   = slab_start_phys_addr + slab_region_size;

mesosphere/kernel_ldr/source/kern_init_loader.cpp

@@ -195,7 +195,7 @@ namespace ams::kern::init::loader {
         /* Setup the INI1 header in memory for the kernel. */
         {
             /* Get the kernel layout. */
-            KSystemControl::Init::GetInitialProcessBinaryLayout(std::addressof(g_initial_process_binary_meta.layout));
+            KSystemControl::Init::GetInitialProcessBinaryLayout(std::addressof(g_initial_process_binary_meta.layout), base_address);
 
             /* If there's no desired base address, use the ini in place. */
             if (g_initial_process_binary_meta.layout.address == 0) {

stratosphere/ams_mitm/source/dns_mitm/dnsmitm_host_redirection.cpp

@@ -107,9 +107,9 @@ namespace ams::mitm::socket::resolver {
                 HostName,
             };
 
-            ams::socket::InAddrT current_address;
+            ams::socket::InAddrT current_address{};
             char current_hostname[0x200];
-            u32 work;
+            u32 work{};
 
             State state = State::BeginLine;
             for (const char *cur = file_data; *cur != '\x00'; ++cur) {

stratosphere/dmnt.gen2/source/dmnt2_breakpoint_manager.cpp

@@ -45,7 +45,7 @@ namespace ams::dmnt {
         }
 
         if (R_FAILED(result)) {
-            AMS_DMNT2_GDB_LOG_DEBUG("BreakPointManager::SetBreakPoint %p 0x%lx !!! Fail 0x%08x !!!\n", bp, bp->m_address, result.GetValue());
+            AMS_DMNT2_GDB_LOG_DEBUG("BreakPointManager::SetBreakPoint %p 0x%lx !!! Fail 0x%08x !!!\n", bp, address, result.GetValue());
         }
 
         R_RETURN(result);

stratosphere/dmnt.gen2/source/dmnt2_gdb_server_impl.cpp

@@ -1538,13 +1538,18 @@ namespace ams::dmnt {
     }
 
     void GdbServerImpl::Q() {
-        if (false) {
-            /* TODO: QStartNoAckMode? */
+        if (ParsePrefix(m_receive_packet, "QStartNoAckMode")) {
+            this->QStartNoAckMode();
         } else {
             AMS_DMNT2_GDB_LOG_DEBUG("Not Implemented Q: %s\n", m_receive_packet);
         }
     }
 
+    void GdbServerImpl::QStartNoAckMode() {
+        m_packet_io.SetNoAck();
+        AppendReplyOk(m_reply_cur, m_reply_end);
+    }
+
     void GdbServerImpl::T() {
         if (const char *dot = std::strchr(m_receive_packet, '.'); dot != nullptr) {
             const u64 thread_id = DecodeHex(dot + 1);
@@ -1919,6 +1924,7 @@ namespace ams::dmnt {
         R_SUCCEED();
     }
 
+
     void GdbServerImpl::q() {
         if (ParsePrefix(m_receive_packet, "qAttached:")) {
             this->qAttached();
@@ -2145,6 +2151,7 @@ namespace ams::dmnt {
         AppendReplyFormat(m_reply_cur, m_reply_end, ";swbreak+");
         AppendReplyFormat(m_reply_cur, m_reply_end, ";hwbreak+");
         AppendReplyFormat(m_reply_cur, m_reply_end, ";vContSupported+");
+        AppendReplyFormat(m_reply_cur, m_reply_end, ";QStartNoAckMode+");
     }
 
     void GdbServerImpl::qXfer() {

stratosphere/dmnt.gen2/source/dmnt2_gdb_server_impl.hpp

@@ -77,6 +77,8 @@ namespace ams::dmnt {
 
             void Q();
 
+            void QStartNoAckMode();
+
             void T();
 
             void Z();
@@ -115,4 +117,4 @@ namespace ams::dmnt {
             Result ParseVCont(char * const token, u64 *thread_ids, u8 *continue_modes, s32 num_threads, DebugProcess::ContinueMode &default_continue_mode);
     };
 
-}
+}

stratosphere/dmnt/source/cheat/impl/dmnt_cheat_vm.cpp

@@ -46,8 +46,11 @@ namespace ams::dmnt::cheat::impl {
     void CheatVirtualMachine::OpenDebugLogFile() {
         #ifdef DMNT_CHEAT_VM_DEBUG_LOG
         CloseDebugLogFile();
-        R_ABORT_UNLESS(fs::OpenFile(std::addressof(m_debug_log_file), "sdmc:/atmosphere/cheat_vm_logs/debug_log.txt"));
+        fs::EnsureDirectory("sdmc:/atmosphere/cheat_vm_logs");
+        fs::CreateFile("sdmc:/atmosphere/cheat_vm_logs/debug_log.txt", 0);
+        R_ABORT_UNLESS(fs::OpenFile(std::addressof(m_debug_log_file), "sdmc:/atmosphere/cheat_vm_logs/debug_log.txt", fs::OpenMode_Write | fs::OpenMode_AllowAppend));
         m_debug_log_file_offset = 0;
+        m_has_debug_log_file = true;
         #endif
     }
 
@@ -80,7 +83,8 @@ namespace ams::dmnt::cheat::impl {
             fmt_len += 1;
         }
 
-        fs::WriteFile(m_debug_log_file, m_debug_log_offset, m_debug_log_format_buf, fmt_len, fs::WriteOption::Flush);
+        fs::WriteFile(m_debug_log_file, m_debug_log_file_offset, m_debug_log_format_buf, fmt_len, fs::WriteOption::Flush);
+        m_debug_log_file_offset += fmt_len;
         #else
         AMS_UNUSED(format);
         #endif

stratosphere/loader/source/ldr_capabilities.cpp

@@ -418,15 +418,7 @@ namespace ams::ldr {
         for (size_t i = 0; i < count; ++i) {
             const auto cap = kac[i];
             switch (GetCapabilityId(cap)) {
-                case CapabilityId::MapRegion:
-                    {
-                        /* MapRegion was added in 8.0.0+, and is only allowed under kernels which have the relevant mappings. */
-                        /* However, we allow it under all firmwares on mesosphere, to facilitate KTrace usage by hbl. */
-                        if (!svc::IsKTraceEnabled()) {
-                            kac[i] = EmptyCapability;
-                        }
-                    }
-                    break;
+                /* NOTE: Currently, there is no pre-processing necessary. */
                 default:
                     break;
             }

stratosphere/loader/source/ldr_embedded_usb_patches.inc

@@ -59,6 +59,11 @@ constexpr inline const EmbeddedPatchEntry Usb30ForceEnablePatches_17_0_0[] = {
     { 0x71EC, "\x20\x00\x80\x52\xC0\x03\x5F\xD6", 8 },
 };
 
+constexpr inline const EmbeddedPatchEntry Usb30ForceEnablePatches_18_0_0[] = {
+    { 0x6DCC, "\x20\x00\x80\x52\xC0\x03\x5F\xD6", 8 },
+    { 0x6E48, "\x20\x00\x80\x52\xC0\x03\x5F\xD6", 8 },
+};
+
 constexpr inline const EmbeddedPatch Usb30ForceEnablePatches[] = {
     { ParseModuleId("C0D3F4E87E8B0FE9BBE9F1968A20767F3DC08E03"), util::size(Usb30ForceEnablePatches_9_0_0),  Usb30ForceEnablePatches_9_0_0 },
     { ParseModuleId("B9C700CA8335F8BAA0D2041D8D09F772890BA988"), util::size(Usb30ForceEnablePatches_10_0_0), Usb30ForceEnablePatches_10_0_0 },
@@ -70,4 +75,5 @@ constexpr inline const EmbeddedPatch Usb30ForceEnablePatches[] = {
     { ParseModuleId("30B15A83E94D91750E7470795414AD1AE9C6A8DB"), util::size(Usb30ForceEnablePatches_15_0_0), Usb30ForceEnablePatches_15_0_0 }, /* 15.0.0 */
     { ParseModuleId("225865A442B4B66E8BD14B3E9450B901BDF29A40"), util::size(Usb30ForceEnablePatches_16_0_0), Usb30ForceEnablePatches_16_0_0 }, /* 16.0.0 */
     { ParseModuleId("70D4C2ABCD049F16B301186924367F813DA70248"), util::size(Usb30ForceEnablePatches_17_0_0), Usb30ForceEnablePatches_17_0_0 }, /* 17.0.0 */
+    { ParseModuleId("4F21AE15E814FA46515C0401BB23D4F7ADCBF3F4"), util::size(Usb30ForceEnablePatches_18_0_0), Usb30ForceEnablePatches_18_0_0 }, /* 18.0.0 */
 };

stratosphere/pm/source/impl/pm_spec.cpp

@@ -243,29 +243,35 @@ namespace ams::pm::impl {
             const u64 boost_size = normal_boost + mitm_boost;
 
             /* Don't allow all application memory to be taken away. */
-            R_UNLESS(boost_size <= g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application], pm::ResultInvalidSize());
+            R_UNLESS(boost_size < g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application], pm::ResultInvalidSize());
 
             const u64 new_app_size = g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application] - boost_size;
             {
                 std::scoped_lock lk(g_resource_limit_lock);
 
+                const auto cur_boost_size = GetCurrentSystemMemoryBoostSize();
+
                 if (hos::GetVersion() >= hos::Version_5_0_0) {
                     /* Starting in 5.0.0, PM does not allow for only one of the sets to fail. */
-                    if (boost_size < GetCurrentSystemMemoryBoostSize()) {
+                    if (boost_size < cur_boost_size) {
                         R_TRY(svc::SetUnsafeLimit(boost_size));
                         R_ABORT_UNLESS(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
-                    } else {
+                    }  else if (boost_size > cur_boost_size) {
                         R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
                         R_ABORT_UNLESS(svc::SetUnsafeLimit(boost_size));
+                    } else {
+                        /* If the boost size is equal, there's nothing to do. */
                     }
                 } else {
                     const u64 new_sys_size = g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_System] + boost_size;
-                    if (boost_size < GetCurrentSystemMemoryBoostSize()) {
+                    if (boost_size < cur_boost_size) {
                         R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
                         R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
+                    } else if (boost_size > cur_boost_size) {
+                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
+                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
                     } else {
-                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
-                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
+                        /* If the boost size is equal, there's nothing to do. */
                     }
                 }
 

stratosphere/spl/source/spl_es_service.hpp

@@ -55,6 +55,10 @@ namespace ams::spl {
             Result LoadPreparedAesKey(s32 keyslot, AccessKey access_key) {
                 R_RETURN(m_manager.LoadPreparedAesKey(keyslot, this, access_key));
             }
+
+            Result PrepareEsUnknown2Key(sf::Out<AccessKey> out_access_key, const sf::InPointerBuffer &base, const sf::InPointerBuffer &mod, const sf::InPointerBuffer &label_digest, u32 generation) {
+                R_RETURN(m_manager.PrepareEsUnknown2Key(out_access_key.GetPointer(), base.GetPointer(), base.GetSize(), mod.GetPointer(), mod.GetSize(), label_digest.GetPointer(), label_digest.GetSize(), generation));
+            }
     };
     static_assert(spl::impl::IsIEsInterface<EsService>);
 

stratosphere/spl/source/spl_secure_monitor_manager.cpp

@@ -121,6 +121,10 @@ namespace ams::spl {
         R_RETURN(impl::PrepareEsArchiveKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, generation));
     }
 
+    Result SecureMonitorManager::PrepareEsUnknown2Key(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation) {
+        R_RETURN(impl::PrepareEsUnknown2Key(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, generation));
+    }
+
     Result SecureMonitorManager::PrepareCommonEsTitleKey(AccessKey *out_access_key, const KeySource &key_source, u32 generation) {
         R_RETURN(impl::PrepareCommonEsTitleKey(out_access_key, key_source, generation));
     }

stratosphere/spl/source/spl_secure_monitor_manager.hpp

@@ -52,6 +52,7 @@ namespace ams::spl {
             Result LoadEsDeviceKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source, u32 option);
             Result PrepareEsTitleKey(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation);
             Result PrepareEsArchiveKey(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation);
+            Result PrepareEsUnknown2Key(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation);
             Result PrepareCommonEsTitleKey(AccessKey *out_access_key, const KeySource &key_source, u32 generation);
             Result LoadPreparedAesKey(s32 keyslot, const void *owner, const AccessKey &access_key);
             Result AllocateAesKeySlot(s32 *out_keyslot, const void *owner);