git subrepo push emummc

subrepo:
  subdir:   "emummc"
  merged:   "6a814ebb"
upstream:
  origin:   "https://github.com/m4xw/emuMMC"
  branch:   "exo2"
  commit:   "6a814ebb"
git-subrepo:
  version:  "0.4.1"
  origin:   "???"
  commit:   "???"

docs/changelog.md

@@ -1,4 +1,19 @@
 # Changelog
+## 0.14.3
++ Support was added for 10.2.0.
++ General system stability improvements to enhance the user's experience.
+## 0.14.2
++ A bug was fixed that could cause a deadlock when installing mitm services.
+  + Fixing this required a breaking change to the client behavior when installing a mitm service, and so custom sysmodules which use mitm will need to be re-compiled to function properly.
++ A bug was fixed that caused atmosphere sysmodules to respond incorrectly when receiving invalid messages.
++ A bug was fixed that caused fatal auto-reboot timing to work improperly.
++ Support was added to fusee for loading binaries for `mesosphere`, atmosphère's reimplementation of the Nintendo Switch kernel.
+  + 0.14.2 does not include mesosphere, but those who are especially interested can build and test mesosphere themselves.
+  + In the future, to enable a sufficient testing period Atmosphère releases will distribute two zips for some time.
+    + One zip will use mesosphere, and the other will not.
+    + This will allow users who are interested to opt-in to mesosphere usage before it has been tested to be stable.
+  + When mesosphere is stable and well-tested, it will be enabled by default and Atmosphère's version will transition to 1.0.0.
++ General system stability improvements to enhance the user's experience.
 ## 0.14.1
 + An issue was fixed in 0.14.0 that would cause a black screen on boot when the INI1's size was not aligned to 8 bytes.
 + General system stability improvements to enhance the user's experience.

emummc/.gitrepo

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

emummc/source/FS/FS_offsets.c

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

emummc/source/FS/FS_versions.h

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

emummc/source/FS/offsets/1020.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2019 m4xw <m4x@m4xw.net>
+ * Copyright (c) 2019 Atmosphere-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __FS_1020_H__
+#define __FS_1020_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_1020_SDMMC_ACCESSOR_GC   0x14E0F0
+#define FS_OFFSET_1020_SDMMC_ACCESSOR_SD   0x14C200
+#define FS_OFFSET_1020_SDMMC_ACCESSOR_NAND 0x147080
+
+// Hooks
+#define FS_OFFSET_1020_SDMMC_WRAPPER_READ  0x1427E0
+#define FS_OFFSET_1020_SDMMC_WRAPPER_WRITE 0x1428C0
+#define FS_OFFSET_1020_RTLD                0x634
+#define FS_OFFSET_1020_RTLD_DESTINATION    0x9C
+
+#define FS_OFFSET_1020_CLKRST_SET_MIN_V_CLK_RATE 0x141A00
+
+// Misc funcs
+#define FS_OFFSET_1020_LOCK_MUTEX          0x28910
+#define FS_OFFSET_1020_UNLOCK_MUTEX        0x28960
+
+#define FS_OFFSET_1020_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x142740
+
+// Misc Data
+#define FS_OFFSET_1020_SD_MUTEX            0xE273E8
+#define FS_OFFSET_1020_NAND_MUTEX          0xE22DA0
+#define FS_OFFSET_1020_ACTIVE_PARTITION    0xE22DE0
+#define FS_OFFSET_1020_SDMMC_DAS_HANDLE    0xE0AB90
+
+// NOPs
+#define FS_OFFSET_1020_SD_DAS_INIT         0x15214C
+
+// Nintendo Paths
+#define FS_OFFSET_1020_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x0006BBA4, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x00078520, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x0007ED0C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0009115C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_1020_H__

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2019 m4xw <m4x@m4xw.net>
+ * Copyright (c) 2019 Atmosphere-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __FS_1020_EXFAT_H__
+#define __FS_1020_EXFAT_H__
+
+// Accessor vtable getters
+#define FS_OFFSET_1020_EXFAT_SDMMC_ACCESSOR_GC   0x14E0F0
+#define FS_OFFSET_1020_EXFAT_SDMMC_ACCESSOR_SD   0x14C200
+#define FS_OFFSET_1020_EXFAT_SDMMC_ACCESSOR_NAND 0x147080
+
+// Hooks
+#define FS_OFFSET_1020_EXFAT_SDMMC_WRAPPER_READ  0x1427E0
+#define FS_OFFSET_1020_EXFAT_SDMMC_WRAPPER_WRITE 0x1428C0
+#define FS_OFFSET_1020_EXFAT_RTLD                0x634
+#define FS_OFFSET_1020_EXFAT_RTLD_DESTINATION    0x9C
+
+#define FS_OFFSET_1020_EXFAT_CLKRST_SET_MIN_V_CLK_RATE 0x141A00
+
+// Misc funcs
+#define FS_OFFSET_1020_EXFAT_LOCK_MUTEX          0x28910
+#define FS_OFFSET_1020_EXFAT_UNLOCK_MUTEX        0x28960
+
+#define FS_OFFSET_1020_EXFAT_SDMMC_WRAPPER_CONTROLLER_CLOSE 0x142740
+
+// Misc Data
+#define FS_OFFSET_1020_EXFAT_SD_MUTEX            0xE353E8
+#define FS_OFFSET_1020_EXFAT_NAND_MUTEX          0xE30DA0
+#define FS_OFFSET_1020_EXFAT_ACTIVE_PARTITION    0xE30DE0
+#define FS_OFFSET_1020_EXFAT_SDMMC_DAS_HANDLE    0xE18B90
+
+// NOPs
+#define FS_OFFSET_1020_EXFAT_SD_DAS_INIT         0x15214C
+
+// Nintendo Paths
+#define FS_OFFSET_1020_EXFAT_NINTENDO_PATHS \
+{ \
+	{.opcode_reg = 3, .adrp_offset = 0x0006BBA4, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x00078520, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 3, .adrp_offset = 0x0007ED0C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 4, .adrp_offset = 0x0009115C, .add_rel_offset = 0x00000004}, \
+	{.opcode_reg = 0, .adrp_offset = 0, .add_rel_offset = 0}, \
+}
+
+#endif // __FS_1020_EXFAT_H__

fusee/fusee-secondary/src/emummc_cfg.h

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

fusee/fusee-secondary/src/ips.c

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

fusee/fusee-secondary/src/nxboot.c

@@ -236,6 +236,7 @@ static uint32_t nxboot_get_specific_target_firmware(uint32_t target_firmware){
     #define CHECK_NCA(NCA_ID, VERSION) do { if (is_nca_present(NCA_ID)) { return ATMOSPHERE_TARGET_FIRMWARE_##VERSION; } } while(0)
 
     if (target_firmware >= ATMOSPHERE_TARGET_FIRMWARE_10_0_0) {
+        CHECK_NCA("26325de4db3909e0ef2379787c7e671d", 10_2_0);
         CHECK_NCA("5077973537f6735b564dd7475b779f87", 10_1_1); /* Exclusive to China. */
         CHECK_NCA("fd1faed0ca750700d254c0915b93d506", 10_1_0);
         CHECK_NCA("34728c771299443420820d8ae490ea41", 10_0_4);

libraries/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/Atmosphere-NX/Atmosphere-libs
 	branch = master
-	commit = 2d522dc6a12b2eb5eb3f103a8c5b5126ca301b1a
-	parent = 35fffade4ea4fdbba9cf2443c321e724c9e70c3d
+	commit = 48dbf4808f4f2042de8c45e9ec471a8f60d5d621
+	parent = 47d0d5c6abc1c9957cd05c63b02ee5e712179b80
 	method = merge
 	cmdver = 0.4.1

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

@@ -19,17 +19,17 @@
 
 namespace ams::fs {
 
-    struct CodeInfo {
+    struct CodeVerificationData {
         u8 signature[crypto::Rsa2048PssSha256Verifier::SignatureSize];
-        u8 hash[crypto::Rsa2048PssSha256Verifier::HashSize];
-        bool is_signed;
+        u8 target_hash[crypto::Rsa2048PssSha256Verifier::HashSize];
+        bool has_data;
         u8 reserved[3];
     };
-    static_assert(sizeof(CodeInfo) == crypto::Rsa2048PssSha256Verifier::SignatureSize + crypto::Rsa2048PssSha256Verifier::HashSize + 4);
+    static_assert(sizeof(CodeVerificationData) == crypto::Rsa2048PssSha256Verifier::SignatureSize + crypto::Rsa2048PssSha256Verifier::HashSize + 4);
 
-    Result MountCode(CodeInfo *out, const char *name, const char *path, ncm::ProgramId program_id);
+    Result MountCode(CodeVerificationData *out, const char *name, const char *path, ncm::ProgramId program_id);
 
-    Result MountCodeForAtmosphereWithRedirection(CodeInfo *out, const char *name, const char *path, ncm::ProgramId program_id, bool is_hbl, bool is_specific);
-    Result MountCodeForAtmosphere(CodeInfo *out, const char *name, const char *path, ncm::ProgramId program_id);
+    Result MountCodeForAtmosphereWithRedirection(CodeVerificationData *out, const char *name, const char *path, ncm::ProgramId program_id, bool is_hbl, bool is_specific);
+    Result MountCodeForAtmosphere(CodeVerificationData *out, const char *name, const char *path, ncm::ProgramId program_id);
 
 }

libraries/libstratosphere/include/stratosphere/ro/impl/ro_ro_interface.hpp

@@ -27,7 +27,7 @@ namespace ams::ro::impl {
         AMS_SF_METHOD_INFO(C, H,  2, Result, RegisterModuleInfo,          (const sf::ClientProcessId &client_pid, u64 nrr_address, u64 nrr_size))                                                                                   \
         AMS_SF_METHOD_INFO(C, H,  3, Result, UnregisterModuleInfo,        (const sf::ClientProcessId &client_pid, u64 nrr_address))                                                                                                 \
         AMS_SF_METHOD_INFO(C, H,  4, Result, RegisterProcessHandle,       (const sf::ClientProcessId &client_pid, sf::CopyHandle process_h))                                                                                        \
-        AMS_SF_METHOD_INFO(C, H, 10, Result, RegisterModuleInfoEx,        (const sf::ClientProcessId &client_pid, u64 nrr_address, u64 nrr_size, sf::CopyHandle process_h),                                     hos::Version_7_0_0)
+        AMS_SF_METHOD_INFO(C, H, 10, Result, RegisterProcessModuleInfo,   (const sf::ClientProcessId &client_pid, u64 nrr_address, u64 nrr_size, sf::CopyHandle process_h),                                     hos::Version_7_0_0)
 
     AMS_SF_DEFINE_INTERFACE(IRoInterface, AMS_RO_I_RO_INTERFACE_INTERFACE_INFO)
 

libraries/libstratosphere/include/stratosphere/ro/ro_types.hpp

@@ -20,10 +20,11 @@
 
 namespace ams::ro {
 
-    enum class ModuleType : u8 {
-        ForSelf   = 0,
-        ForOthers = 1,
-        Count
+    enum NrrKind : u8 {
+        NrrKind_User      = 0,
+        NrrKind_JitPlugin = 1,
+
+        NrrKind_Count,
     };
 
     struct ModuleId {
@@ -54,7 +55,7 @@ namespace ams::ro {
             u8  signature[0x100];
             ncm::ProgramId program_id;
             u32 size;
-            u8  type; /* 7.0.0+ */
+            u8  nrr_kind; /* 7.0.0+ */
             u8  reserved_33D[3];
             u32 hashes_offset;
             u32 num_hashes;
@@ -68,10 +69,10 @@ namespace ams::ro {
                 return (static_cast<u64>(this->program_id) & this->certification.program_id_mask) == this->certification.program_id_pattern;
             }
 
-            ModuleType GetType() const {
-                const ModuleType type = static_cast<ModuleType>(this->type);
-                AMS_ABORT_UNLESS(type < ModuleType::Count);
-                return type;
+            NrrKind GetNrrKind() const {
+                const NrrKind kind = static_cast<NrrKind>(this->nrr_kind);
+                AMS_ABORT_UNLESS(kind < NrrKind_Count);
+                return kind;
             }
 
             ncm::ProgramId GetProgramId() const {

libraries/libstratosphere/source/fs/fs_code.cpp

@@ -20,15 +20,15 @@ namespace ams::fs {
 
     namespace {
 
-        Result OpenCodeFileSystemImpl(CodeInfo *out_code_info, std::unique_ptr<fsa::IFileSystem> *out, const char *path, ncm::ProgramId program_id) {
+        Result OpenCodeFileSystemImpl(CodeVerificationData *out_verification_data, std::unique_ptr<fsa::IFileSystem> *out, const char *path, ncm::ProgramId program_id) {
             /* Print a path suitable for the remote service. */
             fssrv::sf::Path sf_path;
             R_TRY(FspPathPrintf(std::addressof(sf_path), "%s", path));
 
             /* Open the filesystem using libnx bindings. */
-            static_assert(sizeof(CodeInfo) == sizeof(::FsCodeInfo));
+            static_assert(sizeof(CodeVerificationData) == sizeof(::FsCodeInfo));
             ::FsFileSystem fs;
-            R_TRY(fsldrOpenCodeFileSystem(reinterpret_cast<::FsCodeInfo *>(out_code_info), program_id.value, sf_path.str, std::addressof(fs)));
+            R_TRY(fsldrOpenCodeFileSystem(reinterpret_cast<::FsCodeInfo *>(out_verification_data), program_id.value, sf_path.str, std::addressof(fs)));
 
             /* Allocate a new filesystem wrapper. */
             auto fsa = std::make_unique<RemoteFileSystem>(fs);
@@ -62,12 +62,12 @@ namespace ams::fs {
             return OpenPackageFileSystemImpl(out, sf_path.str);
         }
 
-        Result OpenSdCardCodeOrCodeFileSystemImpl(CodeInfo *out_code_info, std::unique_ptr<fsa::IFileSystem> *out, const char *path, ncm::ProgramId program_id) {
+        Result OpenSdCardCodeOrCodeFileSystemImpl(CodeVerificationData *out_verification_data, std::unique_ptr<fsa::IFileSystem> *out, const char *path, ncm::ProgramId program_id) {
             /* If we can open an sd card code fs, use it. */
             R_SUCCEED_IF(R_SUCCEEDED(OpenSdCardCodeFileSystemImpl(out, program_id)));
 
             /* Otherwise, fall back to a normal code fs. */
-            return OpenCodeFileSystemImpl(out_code_info, out, path, program_id);
+            return OpenCodeFileSystemImpl(out_verification_data, out, path, program_id);
         }
 
         Result OpenHblCodeFileSystemImpl(std::unique_ptr<fsa::IFileSystem> *out) {
@@ -227,7 +227,7 @@ namespace ams::fs {
             public:
                 AtmosphereCodeFileSystem() : initialized(false) { /* ... */ }
 
-                Result Initialize(CodeInfo *out_code_info, const char *path, ncm::ProgramId program_id, bool is_hbl, bool is_specific) {
+                Result Initialize(CodeVerificationData *out_verification_data, const char *path, ncm::ProgramId program_id, bool is_hbl, bool is_specific) {
                     AMS_ABORT_UNLESS(!this->initialized);
 
                     /* If we're hbl, we need to open a hbl fs. */
@@ -239,7 +239,7 @@ namespace ams::fs {
 
                     /* Open the code filesystem. */
                     std::unique_ptr<fsa::IFileSystem> fsa;
-                    R_TRY(OpenSdCardCodeOrCodeFileSystemImpl(out_code_info, std::addressof(fsa), path, program_id));
+                    R_TRY(OpenSdCardCodeOrCodeFileSystemImpl(out_verification_data, std::addressof(fsa), path, program_id));
                     this->code_fs.emplace(std::move(fsa), program_id, is_specific);
 
                     this->program_id = program_id;
@@ -275,7 +275,7 @@ namespace ams::fs {
 
     }
 
-    Result MountCode(CodeInfo *out, const char *name, const char *path, ncm::ProgramId program_id) {
+    Result MountCode(CodeVerificationData *out, const char *name, const char *path, ncm::ProgramId program_id) {
         /* Clear the output. */
         std::memset(out, 0, sizeof(*out));
 
@@ -293,7 +293,7 @@ namespace ams::fs {
         return fsa::Register(name, std::move(fsa));
     }
 
-    Result MountCodeForAtmosphereWithRedirection(CodeInfo *out, const char *name, const char *path, ncm::ProgramId program_id, bool is_hbl, bool is_specific) {
+    Result MountCodeForAtmosphereWithRedirection(CodeVerificationData *out, const char *name, const char *path, ncm::ProgramId program_id, bool is_hbl, bool is_specific) {
         /* Clear the output. */
         std::memset(out, 0, sizeof(*out));
 
@@ -314,7 +314,7 @@ namespace ams::fs {
         return fsa::Register(name, std::move(ams_code_fs));
     }
 
-    Result MountCodeForAtmosphere(CodeInfo *out, const char *name, const char *path, ncm::ProgramId program_id) {
+    Result MountCodeForAtmosphere(CodeVerificationData *out, const char *name, const char *path, ncm::ProgramId program_id) {
         /* Clear the output. */
         std::memset(out, 0, sizeof(*out));
 

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

@@ -17,10 +17,10 @@
 
 #define ATMOSPHERE_RELEASE_VERSION_MAJOR    0
 #define ATMOSPHERE_RELEASE_VERSION_MINOR    14
-#define ATMOSPHERE_RELEASE_VERSION_MICRO    2
+#define ATMOSPHERE_RELEASE_VERSION_MICRO    3
 
 #define ATMOSPHERE_RELEASE_VERSION ATMOSPHERE_RELEASE_VERSION_MAJOR, ATMOSPHERE_RELEASE_VERSION_MINOR, ATMOSPHERE_RELEASE_VERSION_MICRO
 
 #define ATMOSPHERE_SUPPORTED_HOS_VERSION_MAJOR 10
-#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MINOR 1
-#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MICRO 1
+#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MINOR 2
+#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MICRO 0

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

@@ -55,8 +55,9 @@
 #define ATMOSPHERE_TARGET_FIRMWARE_10_0_4 ATMOSPHERE_TARGET_FIRMWARE(10,  0,  4)
 #define ATMOSPHERE_TARGET_FIRMWARE_10_1_0 ATMOSPHERE_TARGET_FIRMWARE(10,  1,  0)
 #define ATMOSPHERE_TARGET_FIRMWARE_10_1_1 ATMOSPHERE_TARGET_FIRMWARE(10,  1,  1)
+#define ATMOSPHERE_TARGET_FIRMWARE_10_2_0 ATMOSPHERE_TARGET_FIRMWARE(10,  2,  0)
 
-#define ATMOSPHERE_TARGET_FIRMWARE_CURRENT ATMOSPHERE_TARGET_FIRMWARE_10_1_1
+#define ATMOSPHERE_TARGET_FIRMWARE_CURRENT ATMOSPHERE_TARGET_FIRMWARE_10_2_0
 
 #define ATMOSPHERE_TARGET_FIRMWARE_MIN ATMOSPHERE_TARGET_FIRMWARE(0, 0, 0)
 #define ATMOSPHERE_TARGET_FIRMWARE_MAX ATMOSPHERE_TARGET_FIRMWARE_CURRENT
@@ -104,6 +105,7 @@ namespace ams {
         TargetFirmware_10_0_4  = ATMOSPHERE_TARGET_FIRMWARE_10_0_4,
         TargetFirmware_10_1_0  = ATMOSPHERE_TARGET_FIRMWARE_10_1_0,
         TargetFirmware_10_1_1  = ATMOSPHERE_TARGET_FIRMWARE_10_1_1,
+        TargetFirmware_10_2_0  = ATMOSPHERE_TARGET_FIRMWARE_10_2_0,
 
         TargetFirmware_Current = ATMOSPHERE_TARGET_FIRMWARE_CURRENT,
 

libraries/libvapours/include/vapours/results/ro_results.hpp

@@ -30,7 +30,7 @@ namespace ams::ro {
         R_DEFINE_ERROR_RESULT(TooManyNro,               7);
         R_DEFINE_ERROR_RESULT(TooManyNrr,               8);
         R_DEFINE_ERROR_RESULT(NotAuthorized,            9);
-        R_DEFINE_ERROR_RESULT(InvalidNrrType,           10);
+        R_DEFINE_ERROR_RESULT(InvalidNrrKind,           10);
 
         R_DEFINE_ERROR_RESULT(InternalError,            1023);
 

stratosphere/loader/source/ldr_content_management.cpp

@@ -58,15 +58,15 @@ namespace ams::ldr {
         }
 
         /* Mount the atmosphere code file system. */
-        R_TRY(fs::MountCodeForAtmosphereWithRedirection(std::addressof(this->ams_code_info), AtmosphereCodeMountName, content_path, loc.program_id, this->override_status.IsHbl(), this->override_status.IsProgramSpecific()));
+        R_TRY(fs::MountCodeForAtmosphereWithRedirection(std::addressof(this->ams_code_verification_data), AtmosphereCodeMountName, content_path, loc.program_id, this->override_status.IsHbl(), this->override_status.IsProgramSpecific()));
         this->mounted_ams = true;
 
         /* Mount the sd or base code file system. */
-        R_TRY(fs::MountCodeForAtmosphere(std::addressof(this->sd_or_base_code_info), SdOrCodeMountName, content_path, loc.program_id));
+        R_TRY(fs::MountCodeForAtmosphere(std::addressof(this->sd_or_base_code_verification_data), SdOrCodeMountName, content_path, loc.program_id));
         this->mounted_sd_or_code = true;
 
         /* Mount the base code file system. */
-        if (R_SUCCEEDED(fs::MountCode(std::addressof(this->base_code_info), CodeMountName, content_path, loc.program_id))) {
+        if (R_SUCCEEDED(fs::MountCode(std::addressof(this->base_code_verification_data), CodeMountName, content_path, loc.program_id))) {
             this->mounted_code = true;
         }
 

stratosphere/loader/source/ldr_content_management.hpp

@@ -25,9 +25,9 @@ namespace ams::ldr {
         private:
             std::scoped_lock<os::Mutex> lk;
             cfg::OverrideStatus override_status;
-            fs::CodeInfo ams_code_info;
-            fs::CodeInfo sd_or_base_code_info;
-            fs::CodeInfo base_code_info;
+            fs::CodeVerificationData ams_code_verification_data;
+            fs::CodeVerificationData sd_or_base_code_verification_data;
+            fs::CodeVerificationData base_code_verification_data;
             Result result;
             bool has_status;
             bool mounted_ams;
@@ -47,16 +47,16 @@ namespace ams::ldr {
                 return this->override_status;
             }
 
-            const fs::CodeInfo &GetAtmosphereCodeInfo() const {
-                return this->ams_code_info;
+            const fs::CodeVerificationData &GetAtmosphereCodeVerificationData() const {
+                return this->ams_code_verification_data;
             }
 
-            const fs::CodeInfo &GetSdOrBaseCodeInfo() const {
-                return this->sd_or_base_code_info;
+            const fs::CodeVerificationData &GetSdOrBaseCodeVerificationData() const {
+                return this->sd_or_base_code_verification_data;
             }
 
-            const fs::CodeInfo &GetCodeInfo() const {
-                return this->base_code_info;
+            const fs::CodeVerificationData &GetCodeVerificationData() const {
+                return this->base_code_verification_data;
             }
         private:
             Result Initialize(const ncm::ProgramLocation &loc);

stratosphere/loader/source/ldr_meta.cpp

@@ -107,7 +107,7 @@ namespace ams::ldr {
         Result ValidateAcidSignature(Meta *meta) {
             /* Loader did not check signatures prior to 10.0.0. */
             if (hos::GetVersion() < hos::Version_10_0_0) {
-                meta->is_signed = false;
+                meta->check_verification_data = false;
                 return ResultSuccess();
             }
 
@@ -123,7 +123,7 @@ namespace ams::ldr {
             const bool is_signature_valid = crypto::VerifyRsa2048PssSha256(sig, sig_size, mod, mod_size, exp, exp_size, msg, msg_size);
             R_UNLESS(is_signature_valid || !IsEnabledProgramVerification(), ResultInvalidAcidSignature());
 
-            meta->is_signed = is_signature_valid;
+            meta->check_verification_data = is_signature_valid;
             return ResultSuccess();
         }
 
@@ -220,8 +220,8 @@ namespace ams::ldr {
                 ON_SCOPE_EXIT { fs::CloseFile(file); };
                 R_TRY(LoadMetaFromFile(file, &g_original_meta_cache));
                 R_TRY(ValidateAcidSignature(&g_original_meta_cache.meta));
-                meta->modulus   = g_original_meta_cache.meta.modulus;
-                meta->is_signed = g_original_meta_cache.meta.is_signed;
+                meta->modulus                 = g_original_meta_cache.meta.modulus;
+                meta->check_verification_data = g_original_meta_cache.meta.check_verification_data;
             }
         }
 

stratosphere/loader/source/ldr_meta.hpp

@@ -32,7 +32,7 @@ namespace ams::ldr {
         void *aci_kac;
 
         void *modulus;
-        bool is_signed;
+        bool check_verification_data;
     };
 
     /* Meta API. */

stratosphere/loader/source/ldr_process_creation.cpp

@@ -210,7 +210,7 @@ namespace ams::ldr {
             return ResultSuccess();
         }
 
-        Result ValidateMeta(const Meta *meta, const ncm::ProgramLocation &loc, const fs::CodeInfo &code_info) {
+        Result ValidateMeta(const Meta *meta, const ncm::ProgramLocation &loc, const fs::CodeVerificationData &code_verification_data) {
             /* Validate version. */
             R_TRY(ValidateProgramVersion(loc.program_id, meta->npdm->version));
 
@@ -222,15 +222,15 @@ namespace ams::ldr {
             R_TRY(caps::ValidateCapabilities(meta->acid_kac, meta->acid->kac_size, meta->aci_kac, meta->aci->kac_size));
 
             /* If we have data to validate, validate it. */
-            if (code_info.is_signed && meta->is_signed) {
-                const u8 *sig         = code_info.signature;
-                const size_t sig_size = sizeof(code_info.signature);
+            if (code_verification_data.has_data && meta->check_verification_data) {
+                const u8 *sig         = code_verification_data.signature;
+                const size_t sig_size = sizeof(code_verification_data.signature);
                 const u8 *mod         = static_cast<u8 *>(meta->modulus);
                 const size_t mod_size = crypto::Rsa2048PssSha256Verifier::ModulusSize;
                 const u8 *exp         = fssystem::GetAcidSignatureKeyPublicExponent();
                 const size_t exp_size = fssystem::AcidSignatureKeyPublicExponentSize;
-                const u8 *hsh         = code_info.hash;
-                const size_t hsh_size = sizeof(code_info.hash);
+                const u8 *hsh         = code_verification_data.target_hash;
+                const size_t hsh_size = sizeof(code_verification_data.target_hash);
                 const bool is_signature_valid = crypto::VerifyRsa2048PssSha256WithHash(sig, sig_size, mod, mod_size, exp, exp_size, hsh, hsh_size);
 
                 R_UNLESS(is_signature_valid, ResultInvalidNcaSignature());
@@ -596,7 +596,7 @@ namespace ams::ldr {
             R_TRY(LoadMetaFromCache(&meta, loc, override_status));
 
             /* Validate meta. */
-            R_TRY(ValidateMeta(&meta, loc, mount.GetCodeInfo()));
+            R_TRY(ValidateMeta(&meta, loc, mount.GetCodeVerificationData()));
 
             /* Load, validate NSOs. */
             R_TRY(LoadNsoHeaders(nso_headers, has_nso));

stratosphere/ro/source/impl/ro_nrr_utils.cpp

@@ -157,7 +157,7 @@ namespace ams::ro::impl {
             return ResultSuccess();
         }
 
-        Result ValidateNrr(const NrrHeader *header, u64 size, ncm::ProgramId program_id, ModuleType expected_type, bool enforce_type) {
+        Result ValidateNrr(const NrrHeader *header, u64 size, ncm::ProgramId program_id, NrrKind nrr_kind, bool enforce_nrr_kind) {
             /* Check magic. */
             R_UNLESS(header->IsMagicValid(), ResultInvalidNrr());
 
@@ -182,9 +182,9 @@ namespace ams::ro::impl {
                 /* Check program id. */
                 R_UNLESS(header->GetProgramId() == program_id, ResultInvalidNrr());
 
-                /* Check type. */
-                if (hos::GetVersion() >= hos::Version_7_0_0 && enforce_type) {
-                    R_UNLESS(header->GetType() == expected_type, ResultInvalidNrrType());
+                /* Check nrr kind. */
+                if (hos::GetVersion() >= hos::Version_7_0_0 && enforce_nrr_kind) {
+                    R_UNLESS(header->GetNrrKind() == nrr_kind, ResultInvalidNrrKind());
                 }
             }
 
@@ -194,7 +194,7 @@ namespace ams::ro::impl {
     }
 
     /* Utilities for working with NRRs. */
-    Result MapAndValidateNrr(NrrHeader **out_header, u64 *out_mapped_code_address, void *out_hash, size_t out_hash_size, Handle process_handle, ncm::ProgramId program_id, u64 nrr_heap_address, u64 nrr_heap_size, ModuleType expected_type, bool enforce_type) {
+    Result MapAndValidateNrr(NrrHeader **out_header, u64 *out_mapped_code_address, void *out_hash, size_t out_hash_size, Handle process_handle, ncm::ProgramId program_id, u64 nrr_heap_address, u64 nrr_heap_size, NrrKind nrr_kind, bool enforce_nrr_kind) {
         map::MappedCodeMemory nrr_mcm(ResultInternalError{});
 
         /* First, map the NRR. */
@@ -209,7 +209,7 @@ namespace ams::ro::impl {
         R_TRY(nrr_map.GetResult());
 
         NrrHeader *nrr_header = reinterpret_cast<NrrHeader *>(map_address);
-        R_TRY(ValidateNrr(nrr_header, nrr_heap_size, program_id, expected_type, enforce_type));
+        R_TRY(ValidateNrr(nrr_header, nrr_heap_size, program_id, nrr_kind, enforce_nrr_kind));
 
         /* Invalidation here actually prevents them from unmapping at scope exit. */
         nrr_map.Invalidate();

stratosphere/ro/source/impl/ro_nrr_utils.hpp

@@ -20,7 +20,7 @@
 namespace ams::ro::impl {
 
     /* Utilities for working with NRRs. */
-    Result MapAndValidateNrr(NrrHeader **out_header, u64 *out_mapped_code_address, void *out_hash, size_t out_hash_size, Handle process_handle, ncm::ProgramId program_id, u64 nrr_heap_address, u64 nrr_heap_size, ModuleType expected_type, bool enforce_type);
+    Result MapAndValidateNrr(NrrHeader **out_header, u64 *out_mapped_code_address, void *out_hash, size_t out_hash_size, Handle process_handle, ncm::ProgramId program_id, u64 nrr_heap_address, u64 nrr_heap_size, NrrKind nrr_kind, bool enforce_nrr_kind);
     Result UnmapNrr(Handle process_handle, const NrrHeader *header, u64 nrr_heap_address, u64 nrr_heap_size, u64 mapped_code_address);
 
     bool ValidateNrrHashTableEntry(const void *signed_area, size_t signed_area_size, size_t hashes_offset, size_t num_hashes, const void *nrr_hash, const u8 *hash_table, const void *desired_hash);

stratosphere/ro/source/impl/ro_service_impl.cpp

@@ -413,7 +413,7 @@ namespace ams::ro::impl {
     }
 
     /* Service implementations. */
-    Result RegisterModuleInfo(size_t context_id, Handle process_h, u64 nrr_address, u64 nrr_size, ModuleType expected_type, bool enforce_type) {
+    Result RegisterModuleInfo(size_t context_id, Handle process_h, u64 nrr_address, u64 nrr_size, NrrKind nrr_kind, bool enforce_nrr_kind) {
         /* Get context. */
         ProcessContext *context = GetContextById(context_id);
         AMS_ABORT_UNLESS(context != nullptr);
@@ -435,7 +435,7 @@ namespace ams::ro::impl {
         /* Map. */
         NrrHeader *header = nullptr;
         u64 mapped_code_address = 0;
-        R_TRY(MapAndValidateNrr(&header, &mapped_code_address, std::addressof(signed_area_hash), sizeof(signed_area_hash), context->process_handle, program_id, nrr_address, nrr_size, expected_type, enforce_type));
+        R_TRY(MapAndValidateNrr(&header, &mapped_code_address, std::addressof(signed_area_hash), sizeof(signed_area_hash), context->process_handle, program_id, nrr_address, nrr_size, nrr_kind, enforce_nrr_kind));
 
         /* Set NRR info. */
         context->SetNrrInfoInUse(nrr_info, true);

stratosphere/ro/source/impl/ro_service_impl.hpp

@@ -35,7 +35,7 @@ namespace ams::ro::impl {
     void   UnregisterProcess(size_t context_id);
 
     /* Service implementations. */
-    Result RegisterModuleInfo(size_t context_id, Handle process_h, u64 nrr_address, u64 nrr_size, ModuleType expected_type, bool enforce_type);
+    Result RegisterModuleInfo(size_t context_id, Handle process_h, u64 nrr_address, u64 nrr_size, NrrKind nrr_kind, bool enforce_nrr_kind);
     Result UnregisterModuleInfo(size_t context_id, u64 nrr_address);
     Result MapManualLoadModuleMemory(u64 *out_address, size_t context_id, u64 nro_address, u64 nro_size, u64 bss_address, u64 bss_size);
     Result UnmapManualLoadModuleMemory(size_t context_id, u64 nro_address);

stratosphere/ro/source/ro_main.cpp

@@ -95,11 +95,11 @@ namespace {
     constexpr size_t          DebugMonitorMaxSessions = 2;
 
     /* NOTE: Official code passes 32 for ldr:ro max sessions. We will pass 2, because that's the actual limit. */
-    constexpr sm::ServiceName ForSelfServiceName = sm::ServiceName::Encode("ldr:ro");
-    constexpr size_t          ForSelfMaxSessions = 2;
+    constexpr sm::ServiceName UserServiceName = sm::ServiceName::Encode("ldr:ro");
+    constexpr size_t          UserMaxSessions = 2;
 
-    constexpr sm::ServiceName ForOthersServiceName = sm::ServiceName::Encode("ro:1");
-    constexpr size_t          ForOthersMaxSessions = 2;
+    constexpr sm::ServiceName JitPluginServiceName = sm::ServiceName::Encode("ro:1");
+    constexpr size_t          JitPluginMaxSessions = 2;
 
 }
 
@@ -120,9 +120,9 @@ int main(int argc, char **argv)
     /* Create services. */
     R_ABORT_UNLESS((g_server_manager.RegisterServer<ro::impl::IDebugMonitorInterface, ro::DebugMonitorService>(DebugMonitorServiceName, DebugMonitorMaxSessions)));
 
-    R_ABORT_UNLESS((g_server_manager.RegisterServer<ro::impl::IRoInterface, ro::RoServiceForSelf>(ForSelfServiceName, ForSelfMaxSessions)));
+    R_ABORT_UNLESS((g_server_manager.RegisterServer<ro::impl::IRoInterface, ro::RoUserService>(UserServiceName, UserMaxSessions)));
     if (hos::GetVersion() >= hos::Version_7_0_0) {
-        R_ABORT_UNLESS((g_server_manager.RegisterServer<ro::impl::IRoInterface, ro::RoServiceForOthers>(ForOthersServiceName, ForOthersMaxSessions)));
+        R_ABORT_UNLESS((g_server_manager.RegisterServer<ro::impl::IRoInterface, ro::RoJitPluginService>(JitPluginServiceName, JitPluginMaxSessions)));
     }
 
     /* Loop forever, servicing our services. */

stratosphere/ro/source/ro_ro_service.cpp

@@ -27,7 +27,7 @@ namespace ams::ro {
         impl::SetDevelopmentFunctionEnabled(is_development_function_enabled);
     }
 
-    RoService::RoService(ModuleType t) : context_id(impl::InvalidContextId), type(t) {
+    RoService::RoService(NrrKind k) : context_id(impl::InvalidContextId), nrr_kind(k) {
         /* ... */
     }
 
@@ -47,7 +47,7 @@ namespace ams::ro {
 
     Result RoService::RegisterModuleInfo(const sf::ClientProcessId &client_pid, u64 nrr_address, u64 nrr_size) {
         R_TRY(impl::ValidateProcess(this->context_id, client_pid.GetValue()));
-        return impl::RegisterModuleInfo(this->context_id, svc::InvalidHandle, nrr_address, nrr_size, ModuleType::ForSelf, true);
+        return impl::RegisterModuleInfo(this->context_id, svc::InvalidHandle, nrr_address, nrr_size, NrrKind_User, true);
     }
 
     Result RoService::UnregisterModuleInfo(const sf::ClientProcessId &client_pid, u64 nrr_address) {
@@ -59,9 +59,9 @@ namespace ams::ro {
         return impl::RegisterProcess(std::addressof(this->context_id), process_h.GetValue(), client_pid.GetValue());
     }
 
-    Result RoService::RegisterModuleInfoEx(const sf::ClientProcessId &client_pid, u64 nrr_address, u64 nrr_size, sf::CopyHandle process_h) {
+    Result RoService::RegisterProcessModuleInfo(const sf::ClientProcessId &client_pid, u64 nrr_address, u64 nrr_size, sf::CopyHandle process_h) {
         R_TRY(impl::ValidateProcess(this->context_id, client_pid.GetValue()));
-        return impl::RegisterModuleInfo(this->context_id, process_h.GetValue(), nrr_address, nrr_size, this->type, this->type == ModuleType::ForOthers);
+        return impl::RegisterModuleInfo(this->context_id, process_h.GetValue(), nrr_address, nrr_size, this->nrr_kind, this->nrr_kind == NrrKind_JitPlugin);
     }
 
 }

stratosphere/ro/source/ro_ro_service.hpp

@@ -26,9 +26,9 @@ namespace ams::ro {
     class RoService {
         private:
             size_t context_id;
-            ModuleType type;
+            NrrKind nrr_kind;
         protected:
-            explicit RoService(ModuleType t);
+            explicit RoService(NrrKind k);
         public:
             virtual ~RoService();
         public:
@@ -38,19 +38,18 @@ namespace ams::ro {
             Result RegisterModuleInfo(const sf::ClientProcessId &client_pid, u64 nrr_address, u64 nrr_size);
             Result UnregisterModuleInfo(const sf::ClientProcessId &client_pid, u64 nrr_address);
             Result RegisterProcessHandle(const sf::ClientProcessId &client_pid, sf::CopyHandle process_h);
-            Result RegisterModuleInfoEx(const sf::ClientProcessId &client_pid, u64 nrr_address, u64 nrr_size, sf::CopyHandle process_h);
+            Result RegisterProcessModuleInfo(const sf::ClientProcessId &client_pid, u64 nrr_address, u64 nrr_size, sf::CopyHandle process_h);
     };
     static_assert(ro::impl::IsIRoInterface<RoService>);
 
-    class RoServiceForSelf final : public RoService {
+    class RoUserService final : public RoService {
         public:
-            RoServiceForSelf() : RoService(ro::ModuleType::ForSelf) { /* ... */ }
+            RoUserService() : RoService(NrrKind_User) { /* ... */ }
     };
 
-    /* TODO: This is really JitPlugin... */
-    class RoServiceForOthers final : public RoService {
+    class RoJitPluginService final : public RoService {
         public:
-            RoServiceForOthers() : RoService(ro::ModuleType::ForOthers) { /* ... */ }
+            RoJitPluginService() : RoService(NrrKind_JitPlugin) { /* ... */ }
     };
 
 }