[fs] Share parent resources with bundled programs

src/audio_core/adsp/apps/opus/opus_decoder.cpp

@@ -67,58 +67,48 @@ public:
             LOG_WARNING(Audio_DSP, "using ffmpeg native opus decoder");
             codec = avcodec_find_decoder(AV_CODEC_ID_OPUS);
         }
-        // handles null codec
-        avcodec_free_context(&avc);
-        if ((avc = avcodec_alloc_context3(codec))) {
-            if (is_libopus) {
-                const std::array<u8, 2> mapping_arr{0, 1};
-                mappings = mappings ? mappings : mapping_arr.data();
+        if (codec) {
+            if ((avc = avc ? avc : avcodec_alloc_context3(codec))) {
+                if (is_libopus) {
+                    const std::array<u8, 2> mapping_arr{0, 1};
+                    mappings = mappings ? mappings : mapping_arr.data();
 
-                // freed by avcodec_context_free()
-                u8 *edata = reinterpret_cast<u8*>(av_mallocz(OPUS_HEAD_SIZE + 2 * OPUS_MAX_CHANNELS + AV_INPUT_BUFFER_PADDING_SIZE));
-                ASSERT(edata);
-                edata[9] = u8(channel_count); //channels
-                edata[10] = u8(0); //opus->pre_skip
-                edata[16] = u8(0); //gain_db
-                edata[18] = u8(0); //channel_map
-                edata[OPUS_HEAD_SIZE + 0] = u8(total_stream_count);
-                edata[OPUS_HEAD_SIZE + 1] = u8(stereo_stream_count);
-                if (channel_count >= 1) edata[OPUS_HEAD_SIZE + 2] = mappings[0];
-                if (channel_count >= 2) edata[OPUS_HEAD_SIZE + 3] = mappings[1];
-                avc->extradata = edata;
-                avc->extradata_size = OPUS_HEAD_SIZE + 2 * channel_count;
-            }
+                    // freed by avcodec_context_free()
+                    u8 *edata = reinterpret_cast<u8*>(av_mallocz(OPUS_HEAD_SIZE + 2 * OPUS_MAX_CHANNELS + AV_INPUT_BUFFER_PADDING_SIZE));
+                    ASSERT(edata);
+                    edata[9] = u8(channel_count); //channels
+                    edata[10] = u8(0); //opus->pre_skip
+                    edata[16] = u8(0); //gain_db
+                    edata[18] = u8(0); //channel_map
+                    edata[OPUS_HEAD_SIZE + 0] = u8(total_stream_count);
+                    edata[OPUS_HEAD_SIZE + 1] = u8(stereo_stream_count);
+                    if (channel_count >= 1) edata[OPUS_HEAD_SIZE + 2] = mappings[0];
+                    if (channel_count >= 2) edata[OPUS_HEAD_SIZE + 3] = mappings[1];
+                    avc->extradata = edata;
+                    avc->extradata_size = OPUS_HEAD_SIZE + 2 * channel_count;
+                }
 
-            // FFmpeg hardcodes sample rate
-            avc->sample_rate = sample_rate;
-            avc->request_sample_fmt = AV_SAMPLE_FMT_S16;
-            av_channel_layout_default(&avc->ch_layout, channel_count);
-            if (avcodec_open2(avc, codec, nullptr) >= 0) {
-                pkt = av_packet_alloc();
-                frame = av_frame_alloc();
-                if (swr_alloc_set_opts2(
-                    &swr,
-                    &avc->ch_layout, AV_SAMPLE_FMT_S16, 48000,
-                    &avc->ch_layout, (enum AVSampleFormat)frame->format, 48000,
-                    0, nullptr) >= 0) {
-                    if (swr_init(swr) >= 0) {
-                        return ResultSuccess;
-                    }
+
+                // FFmpeg hardcodes sample rate
+                avc->sample_rate = sample_rate;
+                avc->request_sample_fmt = AV_SAMPLE_FMT_S16;
+                av_channel_layout_default(&avc->ch_layout, channel_count);
+                if (avcodec_open2(avc, codec, nullptr) >= 0) {
+                    avpkt = av_packet_alloc();
+                    frame = av_frame_alloc();
+                    return ResultSuccess;
+                } else {
+                    avcodec_free_context(&avc);
                 }
             }
-            swr_free(&swr);
-            av_frame_free(&frame);
-            av_packet_free(&pkt);
-            avcodec_free_context(&avc);
         }
         return Service::Audio::ResultLibOpusInternalError;
     }
 
     Result Shutdown() {
-        swr_free(&swr);
-        av_frame_free(&frame);
-        av_packet_free(&pkt);
         avcodec_free_context(&avc);
+        av_frame_free(&frame);
+        av_packet_free(&avpkt);
         return ResultSuccess;
     }
 
@@ -137,34 +127,45 @@ public:
             while (rem_output_bytes > 0) {
                 int r = avcodec_receive_frame(avc, frame);
                 if (r == AVERROR(EAGAIN)) {
-                    av_frame_unref(frame);
-                    av_packet_unref(pkt);
-                    if ((r = av_new_packet(pkt, int(input_data_size))) < 0)
-                        break;
-                    std::memcpy(pkt->data, reinterpret_cast<const u8*>(input_data), input_data_size);
-                    if ((r = avcodec_send_packet(avc, pkt)) < 0)
-                        break;
+                    av_packet_unref(avpkt);
+                    av_new_packet(avpkt, int(input_data_size));
+                    std::memcpy(avpkt->data, reinterpret_cast<const u8*>(input_data), input_data_size);
+                    r = avcodec_send_packet(avc, avpkt);
+                    ASSERT(r >= 0);
                 } else if (r == AVERROR_EOF) {
-                    av_frame_unref(frame);
                     break;
                 } else if (r >= 0) {
-                    auto const input_bsize = av_samples_get_buffer_size(frame->linesize, frame->ch_layout.nb_channels, frame->nb_samples, AV_SAMPLE_FMT_S16, 1);
+                    auto const bsize = av_samples_get_buffer_size(nullptr, frame->ch_layout.nb_channels, frame->nb_samples, AV_SAMPLE_FMT_S16, 1);
                     if (frame->format == AV_SAMPLE_FMT_S16) {
-                        // input_bsize == output_bsize
-                        ASSERT(size_t(int(output_data_size) - rem_output_bytes + input_bsize) <= size_t(output_data_size));
-                        std::memcpy(reinterpret_cast<s16*>(output_data + (int(output_data_size) - rem_output_bytes)), frame->data[0], size_t(input_bsize));
+                        std::memcpy(reinterpret_cast<s16*>(output_data) + (int(output_data_size) - rem_output_bytes), frame->data[0], size_t(bsize));
                     } else {
-                        int out_samples = int(av_rescale_rnd(swr_get_delay(swr, frame->sample_rate) + frame->nb_samples, frame->sample_rate, frame->sample_rate, AV_ROUND_UP));
-                        uint8_t *output = nullptr;
-                        av_samples_alloc(&output, frame->linesize, frame->ch_layout.nb_channels, out_samples, AV_SAMPLE_FMT_S16, 0);
-                        out_samples = swr_convert(swr, &output, out_samples, (const uint8_t **)frame->data, frame->nb_samples);
-                        auto const output_bsize = av_samples_get_buffer_size(frame->linesize, frame->ch_layout.nb_channels, out_samples, AV_SAMPLE_FMT_S16, 1);
-                        std::memcpy(reinterpret_cast<s16*>(output_data + (int(output_data_size) - rem_output_bytes)), output, size_t(output_bsize));
-                        av_freep(&output);
+                        SwrContext *swr = nullptr;
+                        if (swr_alloc_set_opts2(
+                            &swr,
+                            &avc->ch_layout,
+                            AV_SAMPLE_FMT_S16,
+                            48000,
+                            &avc->ch_layout,
+                            (enum AVSampleFormat)frame->format,
+                            48000,
+                            0,
+                            nullptr
+                        ) >= 0) {
+                            if (swr_init(swr) >= 0) {
+                                AVFrame *s16_frame = av_frame_alloc();
+                                s16_frame->format = AV_SAMPLE_FMT_S16;
+                                s16_frame->sample_rate = frame->sample_rate;
+                                av_channel_layout_copy(&s16_frame->ch_layout, &frame->ch_layout);
+                                s16_frame->nb_samples = frame->nb_samples;
+                                av_frame_get_buffer(s16_frame, 0);
+                                swr_convert(swr, s16_frame->data, s16_frame->nb_samples, (const uint8_t **)frame->data, frame->nb_samples);
+                                std::memcpy(reinterpret_cast<s16*>(output_data) + (int(output_data_size) - rem_output_bytes), s16_frame->data[0], size_t(bsize));
+                                swr_free(&swr);
+                            }
+                        }
                     }
                     out_sample_count += frame->nb_samples;
-                    rem_output_bytes -= input_bsize;
-                    av_frame_unref(frame);
+                    rem_output_bytes -= bsize;
                 } else {
                     LOG_ERROR(Audio_DSP, "{}", r);
                     break;
@@ -177,9 +178,8 @@ public:
     }
 
     AVCodecContext* avc = nullptr;
-    AVPacket* pkt = nullptr;
+    AVPacket* avpkt = nullptr;
     AVFrame* frame = nullptr;
-    SwrContext* swr = nullptr;
 };
 } // namespace
 

src/core/file_sys/patch_manager.cpp

@@ -156,12 +156,16 @@ std::string GetUpdateVersionStringFromSlot(const ContentProvider* provider, u64
     NACP nacp{nacp_file};
     return nacp.GetVersionString();
 }
+
+std::optional<u64> GetParentApplicationId(const ContentProvider* provider, u64 title_id) {
+    return provider == nullptr ? std::nullopt : provider->GetParentApplicationId(title_id);
+}
 } // Anonymous namespace
 
 PatchManager::PatchManager(u64 title_id_,
                            const Service::FileSystem::FileSystemController& fs_controller_,
                            const ContentProvider& content_provider_)
-    : title_id{title_id_}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
+    : title_id{title_id_}, parent_title_id{GetParentApplicationId(&content_provider_, title_id_)}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
 
 PatchManager::~PatchManager() = default;
 
@@ -169,13 +173,35 @@ u64 PatchManager::GetTitleID() const {
     return title_id;
 }
 
+VirtualDir PatchManager::GetModificationLoadRoot(bool sdmc) const {
+    const auto get_root = [&](u64 id) {
+        return sdmc ? fs_controller.GetSDMCModificationLoadRoot(id) : fs_controller.GetModificationLoadRoot(id);
+    };
+    auto root = get_root(title_id);
+    if (!parent_title_id) {
+        return root;
+    }
+    std::vector<VirtualDir> roots{std::move(root), get_root(*parent_title_id)};
+    std::erase(roots, nullptr);
+    return LayeredVfsDirectory::MakeLayeredDirectory(std::move(roots));
+}
+
+std::vector<std::string> PatchManager::GetDisabledAddons() const {
+    auto disabled = Settings::values.disabled_addons[title_id];
+    if (parent_title_id) {
+        const auto& shared = Settings::values.disabled_addons[*parent_title_id];
+        disabled.insert(disabled.end(), shared.begin(), shared.end());
+    }
+    return disabled;
+}
+
 VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);
 
     if (exefs == nullptr)
         return exefs;
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
 
     bool update_disabled = true;
     std::optional<u32> enabled_version;
@@ -303,8 +329,8 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     }
 
     // LayeredExeFS
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
-    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
+    const auto load_dir = GetModificationLoadRoot();
+    const auto sdmc_load_dir = GetModificationLoadRoot(true);
 
     std::vector<VirtualDir> patch_dirs = {sdmc_load_dir};
     if (load_dir != nullptr) {
@@ -346,7 +372,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 }
 
 std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs, const std::string& build_id) const {
-    const auto& disabled = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
     const auto nso_build_id = fmt::format("{:0<64}", build_id);
 
     std::vector<VirtualFile> out;
@@ -405,7 +431,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
 
     LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);
 
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto load_dir = GetModificationLoadRoot();
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return nso;
@@ -448,7 +474,7 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)
 
     LOG_INFO(Loader, "Querying NSO patch existence for build_id={}, name={}", build_id, name);
 
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto load_dir = GetModificationLoadRoot();
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return false;
@@ -462,13 +488,13 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)
 }
 
 std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildID& build_id_) const {
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto load_dir = GetModificationLoadRoot();
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return {};
     }
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(), [](auto const& l, auto const& r) { return l->GetName() < r->GetName(); });
 
@@ -502,17 +528,16 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildI
     return out;
 }
 
-static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type,
-                           const Service::FileSystem::FileSystemController& fs_controller) {
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
-    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
+void PatchManager::ApplyLayeredFS(VirtualFile& romfs, ContentRecordType type) const {
+    const auto load_dir = GetModificationLoadRoot();
+    const auto sdmc_load_dir = GetModificationLoadRoot(true);
     if ((type != ContentRecordType::Program && type != ContentRecordType::Data &&
          type != ContentRecordType::HtmlDocument) ||
         (load_dir == nullptr && sdmc_load_dir == nullptr)) {
         return;
     }
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
     std::vector<VirtualDir> patch_dirs = load_dir->GetSubdirectories();
     if (std::find(disabled.cbegin(), disabled.cend(), "SDMC") == disabled.cend()) {
         patch_dirs.push_back(sdmc_load_dir);
@@ -591,7 +616,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto& disabled = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
 
     bool update_disabled = true;
     std::optional<u32> enabled_version;
@@ -698,7 +723,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
 
     // LayeredFS
     if (apply_layeredfs) {
-        ApplyLayeredFS(romfs, title_id, type, fs_controller);
+        ApplyLayeredFS(romfs, type);
     }
 
     return romfs;
@@ -1072,15 +1097,22 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
 std::optional<u32> PatchManager::GetGameVersion() const {
     const auto update_tid = GetUpdateTitleID(title_id);
     if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
-        return content_provider.GetEntryVersion(update_tid);
+        const auto version = content_provider.GetEntryVersion(update_tid);
+        return version || !parent_title_id ? version : content_provider.GetEntryVersion(GetUpdateTitleID(*parent_title_id));
     }
 
-    return content_provider.GetEntryVersion(title_id);
+    const auto version = content_provider.GetEntryVersion(title_id);
+    return version || !parent_title_id ? version : content_provider.GetEntryVersion(*parent_title_id);
 }
 
 PatchManager::Metadata PatchManager::GetControlMetadata() const {
     const auto base_control_nca = content_provider.GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr) {
+        if (parent_title_id) {
+            const auto control_id = content_provider.HasEntry(*parent_title_id, ContentRecordType::Control) ? *parent_title_id : GetUpdateTitleID(*parent_title_id);
+            const PatchManager parent{control_id, fs_controller, content_provider};
+            return parent.GetControlMetadata();
+        }
         return {};
     }
 

src/core/file_sys/patch_manager.h

@@ -109,10 +109,14 @@ public:
     [[nodiscard]] static PatchManager::Metadata GetMetadataFromBaseOrUpdate(Core::System& system, u64 application_id) noexcept;
 
 private:
+    [[nodiscard]] VirtualDir GetModificationLoadRoot(bool sdmc = false) const;
+    [[nodiscard]] std::vector<std::string> GetDisabledAddons() const;
+    void ApplyLayeredFS(VirtualFile& romfs, ContentRecordType type) const;
     [[nodiscard]] std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
                                                           const std::string& build_id) const;
 
     u64 title_id;
+    std::optional<u64> parent_title_id;
     const Service::FileSystem::FileSystemController& fs_controller;
     const ContentProvider& content_provider;
 };

src/core/file_sys/registered_cache.cpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
+#include <limits>
 #include <random>
 #include <regex>
 #include <openssl/evp.h>
@@ -348,6 +349,22 @@ std::vector<ContentProviderEntry> ContentProvider::ListEntries() const {
     return ListEntriesFilter(std::nullopt, std::nullopt, std::nullopt);
 }
 
+std::optional<u64> ContentProvider::GetParentApplicationId(u64 program_id) const {
+    const auto application_id = GetBaseTitleID(program_id);
+    const auto program_index = program_id - application_id;
+    if (program_index == 0 || program_index > std::numeric_limits<u8>::max()) {
+        return std::nullopt;
+    }
+    if (!ListEntriesFilter(TitleType::Application, ContentRecordType::Meta, program_id).empty()) {
+        return std::nullopt;
+    }
+    if ((!ListEntriesFilter(TitleType::Application, ContentRecordType::Meta, application_id).empty() && HasEntry(program_id, ContentRecordType::Program))
+     || (!ListEntriesFilter(TitleType::Update, ContentRecordType::Meta, GetUpdateTitleID(application_id)).empty() && HasEntry(GetUpdateTitleID(program_id), ContentRecordType::Program))) {
+        return application_id;
+    }
+    return std::nullopt;
+}
+
 PlaceholderCache::PlaceholderCache(VirtualDir dir_) : dir(std::move(dir_)) {}
 
 bool PlaceholderCache::Create(const NcaID& id, u64 size) const {

src/core/file_sys/registered_cache.h

@@ -100,6 +100,8 @@ public:
         std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
         std::optional<u64> title_id = {}) const = 0;
 
+    [[nodiscard]] std::optional<u64> GetParentApplicationId(u64 program_id) const;
+
 protected:
     // A single instance of KeyManager to be used by GetEntry()
     Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();

src/core/file_sys/savedata_factory.cpp

@@ -9,6 +9,7 @@
 #include "common/logging.h"
 #include "common/uuid.h"
 #include "core/core.h"
+#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs/vfs.h"
 
@@ -61,17 +62,24 @@ SaveDataFactory::SaveDataFactory(Core::System& system_, ProgramId program_id_,
 
 SaveDataFactory::~SaveDataFactory() = default;
 
+std::string SaveDataFactory::GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const {
+    if (type == SaveDataType::Account || type == SaveDataType::Device) {
+        const auto requested_id = title_id != 0 ? title_id : program_id;
+        const auto parent_id = system.GetContentProvider().GetParentApplicationId(requested_id);
+        title_id = parent_id.value_or(requested_id);
+    }
+    return GetFullPath(program_id, dir, space, type, title_id, user_id, save_id);
+}
+
 VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
-    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
-                                            meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
 
     return dir->CreateDirectoryRelative(save_directory);
 }
 
 VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
 
-    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
-                                            meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
@@ -154,8 +162,7 @@ std::string SaveDataFactory::GetUserGameSaveDataRoot(u128 user_id, bool future)
 
 SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
                                                u128 user_id) const {
-    const auto path =
-        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->GetFile(GetSaveDataSizeFileName());
@@ -173,8 +180,7 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
 
 void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
                                         SaveDataSize new_value) const {
-    const auto path =
-        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->CreateFile(GetSaveDataSizeFileName());

src/core/file_sys/savedata_factory.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -47,6 +50,7 @@ public:
     void SetAutoCreate(bool state);
 
 private:
+    std::string GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const;
     Core::System& system;
     ProgramId program_id;
     VirtualDir dir;