Merge pull request #1415 from DarkLordZach/ips

file_sys: Add support for loading IPS patches

src/core/CMakeLists.txt

@@ -34,6 +34,8 @@ add_library(core STATIC
     file_sys/errors.h
     file_sys/fsmitm_romfsbuild.cpp
     file_sys/fsmitm_romfsbuild.h
+    file_sys/ips_layer.cpp
+    file_sys/ips_layer.h
     file_sys/mode.h
     file_sys/nca_metadata.cpp
     file_sys/nca_metadata.h

src/core/file_sys/ips_layer.cpp

@@ -0,0 +1,88 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "common/swap.h"
+#include "core/file_sys/ips_layer.h"
+#include "core/file_sys/vfs_vector.h"
+
+namespace FileSys {
+
+enum class IPSFileType {
+    IPS,
+    IPS32,
+    Error,
+};
+
+static IPSFileType IdentifyMagic(const std::vector<u8>& magic) {
+    if (magic.size() != 5)
+        return IPSFileType::Error;
+    if (magic == std::vector<u8>{'P', 'A', 'T', 'C', 'H'})
+        return IPSFileType::IPS;
+    if (magic == std::vector<u8>{'I', 'P', 'S', '3', '2'})
+        return IPSFileType::IPS32;
+    return IPSFileType::Error;
+}
+
+VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
+    if (in == nullptr || ips == nullptr)
+        return nullptr;
+
+    const auto type = IdentifyMagic(ips->ReadBytes(0x5));
+    if (type == IPSFileType::Error)
+        return nullptr;
+
+    auto in_data = in->ReadAllBytes();
+
+    std::vector<u8> temp(type == IPSFileType::IPS ? 3 : 4);
+    u64 offset = 5; // After header
+    while (ips->Read(temp.data(), temp.size(), offset) == temp.size()) {
+        offset += temp.size();
+        if (type == IPSFileType::IPS32 && temp == std::vector<u8>{'E', 'E', 'O', 'F'} ||
+            type == IPSFileType::IPS && temp == std::vector<u8>{'E', 'O', 'F'}) {
+            break;
+        }
+
+        u32 real_offset{};
+        if (type == IPSFileType::IPS32)
+            real_offset = (temp[0] << 24) | (temp[1] << 16) | (temp[2] << 8) | temp[3];
+        else
+            real_offset = (temp[0] << 16) | (temp[1] << 8) | temp[2];
+
+        u16 data_size{};
+        if (ips->ReadObject(&data_size, offset) != sizeof(u16))
+            return nullptr;
+        data_size = Common::swap16(data_size);
+        offset += sizeof(u16);
+
+        if (data_size == 0) { // RLE
+            u16 rle_size{};
+            if (ips->ReadObject(&rle_size, offset) != sizeof(u16))
+                return nullptr;
+            rle_size = Common::swap16(data_size);
+            offset += sizeof(u16);
+
+            const auto data = ips->ReadByte(offset++);
+            if (data == boost::none)
+                return nullptr;
+
+            if (real_offset + rle_size > in_data.size())
+                rle_size = in_data.size() - real_offset;
+            std::memset(in_data.data() + real_offset, data.get(), rle_size);
+        } else { // Standard Patch
+            auto read = data_size;
+            if (real_offset + read > in_data.size())
+                read = in_data.size() - real_offset;
+            if (ips->Read(in_data.data() + real_offset, read, offset) != data_size)
+                return nullptr;
+            offset += data_size;
+        }
+    }
+
+    if (temp != std::vector<u8>{'E', 'E', 'O', 'F'} && temp != std::vector<u8>{'E', 'O', 'F'})
+        return nullptr;
+    return std::make_shared<VectorVfsFile>(in_data, in->GetName(), in->GetContainingDirectory());
+}
+
+} // namespace FileSys

src/core/file_sys/ips_layer.h

@@ -0,0 +1,15 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+
+#include "core/file_sys/vfs.h"
+
+namespace FileSys {
+
+VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips);
+
+} // namespace FileSys

src/core/file_sys/patch_manager.cpp

@@ -5,14 +5,18 @@
 #include <algorithm>
 #include <array>
 #include <cstddef>
+#include <cstring>
 
+#include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
+#include "core/file_sys/ips_layer.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_layered.h"
+#include "core/file_sys/vfs_vector.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
 
@@ -21,6 +25,14 @@ namespace FileSys {
 constexpr u64 SINGLE_BYTE_MODULUS = 0x100;
 constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
 
+struct NSOBuildHeader {
+    u32_le magic;
+    INSERT_PADDING_BYTES(0x3C);
+    std::array<u8, 0x20> build_id;
+    INSERT_PADDING_BYTES(0xA0);
+};
+static_assert(sizeof(NSOBuildHeader) == 0x100, "NSOBuildHeader has incorrect size.");
+
 std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
     std::array<u8, sizeof(u32)> bytes{};
     bytes[0] = version % SINGLE_BYTE_MODULUS;
@@ -34,16 +46,6 @@ std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
     return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
 }
 
-constexpr std::array<const char*, 3> PATCH_TYPE_NAMES{
-    "Update",
-    "LayeredFS",
-    "DLC",
-};
-
-std::string FormatPatchTypeName(PatchType type) {
-    return PATCH_TYPE_NAMES.at(static_cast<std::size_t>(type));
-}
-
 PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
 
 PatchManager::~PatchManager() = default;
@@ -71,6 +73,79 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     return exefs;
 }
 
+static std::vector<VirtualFile> CollectIPSPatches(const std::vector<VirtualDir>& patch_dirs,
+                                                  const std::string& build_id) {
+    std::vector<VirtualFile> ips;
+    ips.reserve(patch_dirs.size());
+    for (const auto& subdir : patch_dirs) {
+        auto exefs_dir = subdir->GetSubdirectory("exefs");
+        if (exefs_dir != nullptr) {
+            for (const auto& file : exefs_dir->GetFiles()) {
+                if (file->GetExtension() != "ips")
+                    continue;
+                auto name = file->GetName();
+                const auto p1 = name.substr(0, name.find('.'));
+                const auto this_build_id = p1.substr(0, p1.find_last_not_of('0') + 1);
+
+                if (build_id == this_build_id)
+                    ips.push_back(file);
+            }
+        }
+    }
+
+    return ips;
+}
+
+std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
+    if (nso.size() < 0x100)
+        return nso;
+
+    NSOBuildHeader header;
+    std::memcpy(&header, nso.data(), sizeof(NSOBuildHeader));
+
+    if (header.magic != Common::MakeMagic('N', 'S', 'O', '0'))
+        return nso;
+
+    const auto build_id_raw = Common::HexArrayToString(header.build_id);
+    const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
+
+    LOG_INFO(Loader, "Patching NSO for build_id={}", build_id);
+
+    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    auto patch_dirs = load_dir->GetSubdirectories();
+    std::sort(patch_dirs.begin(), patch_dirs.end(),
+              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
+    const auto ips = CollectIPSPatches(patch_dirs, build_id);
+
+    auto out = nso;
+    for (const auto& ips_file : ips) {
+        LOG_INFO(Loader, "    - Appling IPS patch from mod \"{}\"",
+                 ips_file->GetContainingDirectory()->GetParentDirectory()->GetName());
+        const auto patched = PatchIPS(std::make_shared<VectorVfsFile>(out), ips_file);
+        if (patched != nullptr)
+            out = patched->ReadAllBytes();
+    }
+
+    if (out.size() < 0x100)
+        return nso;
+    std::memcpy(out.data(), &header, sizeof(NSOBuildHeader));
+    return out;
+}
+
+bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
+    const auto build_id_raw = Common::HexArrayToString(build_id_);
+    const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
+
+    LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);
+
+    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    auto patch_dirs = load_dir->GetSubdirectories();
+    std::sort(patch_dirs.begin(), patch_dirs.end(),
+              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
+
+    return !CollectIPSPatches(patch_dirs, build_id).empty();
+}
+
 static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
     const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
     if (type != ContentRecordType::Program || load_dir == nullptr || load_dir->GetSize() <= 0) {
@@ -138,8 +213,19 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset,
     return romfs;
 }
 
-std::map<PatchType, std::string> PatchManager::GetPatchVersionNames() const {
-    std::map<PatchType, std::string> out;
+static void AppendCommaIfNotEmpty(std::string& to, const std::string& with) {
+    if (to.empty())
+        to += with;
+    else
+        to += ", " + with;
+}
+
+static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
+    return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
+}
+
+std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames() const {
+    std::map<std::string, std::string, std::less<>> out;
     const auto installed = Service::FileSystem::GetUnionContents();
 
     // Game Updates
@@ -148,23 +234,36 @@ std::map<PatchType, std::string> PatchManager::GetPatchVersionNames() const {
     auto [nacp, discard_icon_file] = update.GetControlMetadata();
 
     if (nacp != nullptr) {
-        out[PatchType::Update] = nacp->GetVersionString();
+        out.insert_or_assign("Update", nacp->GetVersionString());
     } else {
         if (installed->HasEntry(update_tid, ContentRecordType::Program)) {
             const auto meta_ver = installed->GetEntryVersion(update_tid);
             if (meta_ver == boost::none || meta_ver.get() == 0) {
-                out[PatchType::Update] = "";
+                out.insert_or_assign("Update", "");
             } else {
-                out[PatchType::Update] =
-                    FormatTitleVersion(meta_ver.get(), TitleVersionFormat::ThreeElements);
+                out.insert_or_assign(
+                    "Update",
+                    FormatTitleVersion(meta_ver.get(), TitleVersionFormat::ThreeElements));
             }
         }
     }
 
-    // LayeredFS
-    const auto lfs_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    if (lfs_dir != nullptr && lfs_dir->GetSize() > 0)
-        out.insert_or_assign(PatchType::LayeredFS, "");
+    // General Mods (LayeredFS and IPS)
+    const auto mod_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    if (mod_dir != nullptr && mod_dir->GetSize() > 0) {
+        for (const auto& mod : mod_dir->GetSubdirectories()) {
+            std::string types;
+            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("exefs")))
+                AppendCommaIfNotEmpty(types, "IPS");
+            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("romfs")))
+                AppendCommaIfNotEmpty(types, "LayeredFS");
+
+            if (types.empty())
+                continue;
+
+            out.insert_or_assign(mod->GetName(), types);
+        }
+    }
 
     // DLC
     const auto dlc_entries = installed->ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
@@ -186,7 +285,7 @@ std::map<PatchType, std::string> PatchManager::GetPatchVersionNames() const {
 
         list += fmt::format("{}", dlc_match.back().title_id & 0x7FF);
 
-        out.insert_or_assign(PatchType::DLC, std::move(list));
+        out.insert_or_assign("DLC", std::move(list));
     }
 
     return out;

src/core/file_sys/patch_manager.h

@@ -24,14 +24,6 @@ enum class TitleVersionFormat : u8 {
 std::string FormatTitleVersion(u32 version,
                                TitleVersionFormat format = TitleVersionFormat::ThreeElements);
 
-enum class PatchType {
-    Update,
-    LayeredFS,
-    DLC,
-};
-
-std::string FormatPatchTypeName(PatchType type);
-
 // A centralized class to manage patches to games.
 class PatchManager {
 public:
@@ -42,6 +34,14 @@ public:
     // - Game Updates
     VirtualDir PatchExeFS(VirtualDir exefs) const;
 
+    // Currently tracked NSO patches:
+    // - IPS
+    std::vector<u8> PatchNSO(const std::vector<u8>& nso) const;
+
+    // Checks to see if PatchNSO() will have any effect given the NSO's build ID.
+    // Used to prevent expensive copies in NSO loader.
+    bool HasNSOPatch(const std::array<u8, 0x20>& build_id) const;
+
     // Currently tracked RomFS patches:
     // - Game Updates
     // - LayeredFS
@@ -49,8 +49,8 @@ public:
                            ContentRecordType type = ContentRecordType::Program) const;
 
     // Returns a vector of pairs between patch names and patch versions.
-    // i.e. Update v80 will return {Update, 80}
-    std::map<PatchType, std::string> GetPatchVersionNames() const;
+    // i.e. Update 3.2.2 will return {"Update", "3.2.2"}
+    std::map<std::string, std::string, std::less<>> GetPatchVersionNames() const;
 
     // Given title_id of the program, attempts to get the control data of the update and parse it,
     // falling back to the base control data.

src/core/loader/deconstructed_rom_directory.cpp

@@ -130,6 +130,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(Kernel::Process& process)
     }
 
     process.LoadFromMetadata(metadata);
+    const FileSys::PatchManager pm(metadata.GetTitleID());
 
     // Load NSO modules
     const VAddr base_address = process.VMManager().GetCodeRegionBaseAddress();
@@ -139,7 +140,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(Kernel::Process& process)
         const FileSys::VirtualFile module_file = dir->GetFile(module);
         if (module_file != nullptr) {
             const VAddr load_addr = next_load_addr;
-            next_load_addr = AppLoader_NSO::LoadModule(module_file, load_addr);
+            next_load_addr = AppLoader_NSO::LoadModule(module_file, load_addr, pm);
             LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
             // Register module with GDBStub
             GDBStub::RegisterModule(module, load_addr, next_load_addr - 1, false);

src/core/loader/nso.cpp

@@ -10,6 +10,7 @@
 #include "common/logging/log.h"
 #include "common/swap.h"
 #include "core/core.h"
+#include "core/file_sys/patch_manager.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
@@ -36,8 +37,7 @@ struct NsoHeader {
     INSERT_PADDING_WORDS(1);
     u8 flags;
     std::array<NsoSegmentHeader, 3> segments; // Text, RoData, Data (in that order)
-    u32_le bss_size;
-    INSERT_PADDING_BYTES(0x1c);
+    std::array<u8, 0x20> build_id;
     std::array<u32_le, 3> segments_compressed_size;
 
     bool IsSegmentCompressed(size_t segment_num) const {
@@ -93,7 +93,8 @@ static constexpr u32 PageAlignSize(u32 size) {
     return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
 }
 
-VAddr AppLoader_NSO::LoadModule(FileSys::VirtualFile file, VAddr load_base) {
+VAddr AppLoader_NSO::LoadModule(FileSys::VirtualFile file, VAddr load_base,
+                                boost::optional<FileSys::PatchManager> pm) {
     if (file == nullptr)
         return {};
 
@@ -142,6 +143,17 @@ VAddr AppLoader_NSO::LoadModule(FileSys::VirtualFile file, VAddr load_base) {
     const u32 image_size{PageAlignSize(static_cast<u32>(program_image.size()) + bss_size)};
     program_image.resize(image_size);
 
+    // Apply patches if necessary
+    if (pm != boost::none && pm->HasNSOPatch(nso_header.build_id)) {
+        std::vector<u8> pi_header(program_image.size() + 0x100);
+        std::memcpy(pi_header.data(), &nso_header, sizeof(NsoHeader));
+        std::memcpy(pi_header.data() + 0x100, program_image.data(), program_image.size());
+
+        pi_header = pm->PatchNSO(pi_header);
+
+        std::memcpy(program_image.data(), pi_header.data() + 0x100, program_image.size());
+    }
+
     // Load codeset for current process
     codeset->name = file->GetName();
     codeset->memory = std::make_shared<std::vector<u8>>(std::move(program_image));

src/core/loader/nso.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include "common/common_types.h"
+#include "core/file_sys/patch_manager.h"
 #include "core/loader/linker.h"
 #include "core/loader/loader.h"
 
@@ -26,7 +27,8 @@ public:
         return IdentifyType(file);
     }
 
-    static VAddr LoadModule(FileSys::VirtualFile file, VAddr load_base);
+    static VAddr LoadModule(FileSys::VirtualFile file, VAddr load_base,
+                            boost::optional<FileSys::PatchManager> pm = boost::none);
 
     ResultStatus Load(Kernel::Process& process) override;
 };

src/yuzu/game_list_worker.cpp

@@ -60,14 +60,13 @@ QString FormatGameName(const std::string& physical_name) {
 QString FormatPatchNameVersions(const FileSys::PatchManager& patch_manager, bool updatable = true) {
     QString out;
     for (const auto& kv : patch_manager.GetPatchVersionNames()) {
-        if (!updatable && kv.first == FileSys::PatchType::Update)
+        if (!updatable && kv.first == "Update")
             continue;
 
         if (kv.second.empty()) {
-            out.append(fmt::format("{}\n", FileSys::FormatPatchTypeName(kv.first)).c_str());
+            out.append(fmt::format("{}\n", kv.first).c_str());
         } else {
-            out.append(fmt::format("{} ({})\n", FileSys::FormatPatchTypeName(kv.first), kv.second)
-                           .c_str());
+            out.append(fmt::format("{} ({})\n", kv.first, kv.second).c_str());
         }
     }