[desktop] fix save data location, orphaned profiles finder (#2678)

Previously, if the user had their NAND in a nonstandard location,
profiles.dat would be read from the standard Eden path and thus return
effectively garbage data. What this would result in is:

- The Qt profile manager would be completely nonfunctional
- "Open Save Data Location" would put you into the completely wrong
  place
- Games would read from incorrect locations for their saves

To solve this, I made it so that profiles.dat is re-read *after*
QtConfig initializes. It's not the perfect solution, but it works.

Additionally, this adds an orphaned profiles finder:
- walks through the save folders in nand/user/save/000.../
- for each subdirectory, checks to see if profiles.dat contains a
  corresponding UUID
- If not, the profile is "orphaned". It may contain legit save data, so
  let the user decide how to handle it (famous last words)
- Empty profiles are just removed. If they really matter, they're
  instantly recreated anyways.

The orphaned profiles check runs right *after* the decryption keys
check, but before the game list ever gets populated

Signed-off-by: crueter <crueter@eden-emu.dev>

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/2678
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
Reviewed-by: MaranBr <maranbr@eden-emu.dev>

src/core/file_sys/savedata_factory.cpp

@@ -4,7 +4,6 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <memory>
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
@@ -129,10 +128,6 @@ std::string SaveDataFactory::GetFullPath(ProgramId program_id, VirtualDir dir,
 
     std::string out = GetSaveDataSpaceIdPath(space);
 
-    LOG_INFO(Common_Filesystem, "Save ID: {:016X}", save_id);
-    LOG_INFO(Common_Filesystem, "User ID[1]: {:016X}", user_id[1]);
-    LOG_INFO(Common_Filesystem, "User ID[0]: {:016X}", user_id[0]);
-
     switch (type) {
     case SaveDataType::System:
         return fmt::format("{}save/{:016X}/{:016X}{:016X}", out, save_id, user_id[1], user_id[0]);

src/core/hle/service/acc/profile_manager.cpp

@@ -4,13 +4,17 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <algorithm>
 #include <cstring>
+#include <filesystem>
+#include <iostream>
 #include <random>
 
 #include <fmt/ranges.h>
 
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
+#include "common/fs/fs_types.h"
 #include "common/fs/path_util.h"
 #include <ranges>
 #include "common/settings.h"
@@ -90,6 +94,11 @@ bool ProfileManager::RemoveProfileAtIndex(std::size_t index) {
     return true;
 }
 
+void ProfileManager::RemoveAllProfiles()
+{
+    profiles = {};
+}
+
 /// Helper function to register a user to the system
 Result ProfileManager::AddUser(const ProfileInfo& user) {
     if (!AddToProfiles(user)) {
@@ -259,8 +268,9 @@ void ProfileManager::CloseUser(UUID uuid) {
 /// Gets all valid user ids on the system
 UserIDArray ProfileManager::GetAllUsers() const {
     UserIDArray output{};
-    std::ranges::transform(profiles, output.begin(),
-                           [](const ProfileInfo& p) { return p.user_uuid; });
+    std::ranges::transform(profiles, output.begin(), [](const ProfileInfo& p) {
+        return p.user_uuid;
+    });
     return output;
 }
 
@@ -387,18 +397,19 @@ bool ProfileManager::SetProfileBaseAndData(Common::UUID uuid, const ProfileBase&
 void ProfileManager::ParseUserSaveFile() {
     const auto save_path(FS::GetEdenPath(FS::EdenPath::NANDDir) / ACC_SAVE_AVATORS_BASE_PATH /
                          "profiles.dat");
+
     const FS::IOFile save(save_path, FS::FileAccessMode::Read, FS::FileType::BinaryFile);
 
     if (!save.IsOpen()) {
         LOG_WARNING(Service_ACC, "Failed to load profile data from save data... Generating new "
-                                 "user 'eden' with random UUID.");
+                                 "user 'Eden' with random UUID.");
         return;
     }
 
     ProfileDataRaw data;
     if (!save.ReadObject(data)) {
         LOG_WARNING(Service_ACC, "profiles.dat is smaller than expected... Generating new user "
-                                 "'eden' with random UUID.");
+                                 "'Eden' with random UUID.");
         return;
     }
 
@@ -471,6 +482,79 @@ void ProfileManager::WriteUserSaveFile() {
     is_save_needed = false;
 }
 
+void ProfileManager::ResetUserSaveFile()
+{
+    RemoveAllProfiles();
+    ParseUserSaveFile();
+}
+
+std::vector<std::string> ProfileManager::FindOrphanedProfiles()
+{
+    std::vector<std::string> good_uuids;
+
+    for (const ProfileInfo& p : profiles) {
+        std::string uuid_string = [p]() -> std::string {
+            auto uuid = p.user_uuid;
+
+            // "ignore" invalid uuids
+            if (uuid.IsInvalid()) {
+                return "0";
+            }
+
+            auto user_id = uuid.AsU128();
+
+            return fmt::format("{:016X}{:016X}", user_id[1], user_id[0]);
+        }();
+
+        good_uuids.emplace_back(uuid_string);
+    }
+
+    // TODO: fetch save_id programmatically
+    const auto path = Common::FS::GetEdenPath(Common::FS::EdenPath::NANDDir)
+                      / "user/save/0000000000000000";
+
+    std::vector<std::string> orphaned_profiles;
+
+    Common::FS::IterateDirEntries(
+        path,
+        [&good_uuids, &orphaned_profiles](const std::filesystem::directory_entry& entry) -> bool {
+            const std::string uuid = entry.path().stem().string();
+
+            // first off, we should always clear empty profiles
+            // 99% of the time these are useless. If not, they are recreated anyways...
+            namespace fs = std::filesystem;
+
+            const auto is_empty = [&entry]() -> bool {
+                try {
+                    for (const auto& file : fs::recursive_directory_iterator(entry.path())) {
+                        if (file.is_regular_file()) {
+                            return true;
+                        }
+                    }
+                } catch (const fs::filesystem_error& e) {
+                    // if we get an error--no worries, just pretend it's not empty
+                    return false;
+                }
+                return false;
+            }();
+
+            if (!is_empty) {
+                fs::remove_all(entry);
+                return true;
+            }
+
+            // if profiles.dat contains the UUID--all good
+            // if not--it's an orphaned profile and should be resolved by the user
+            if (std::find(good_uuids.begin(), good_uuids.end(), uuid) == good_uuids.end()) {
+                orphaned_profiles.emplace_back(uuid);
+            }
+            return true;
+        },
+        Common::FS::DirEntryFilter::Directory);
+
+    return orphaned_profiles;
+}
+
 void ProfileManager::SetUserPosition(u64 position, Common::UUID uuid) {
     auto idxOpt = GetUserIndex(uuid);
     if (!idxOpt)

src/core/hle/service/acc/profile_manager.h

@@ -103,10 +103,15 @@ public:
 
     void WriteUserSaveFile();
 
+    void ResetUserSaveFile();
+
+    std::vector<std::string> FindOrphanedProfiles();
+
 private:
     void ParseUserSaveFile();
     std::optional<std::size_t> AddToProfiles(const ProfileInfo& profile);
     bool RemoveProfileAtIndex(std::size_t index);
+    void RemoveAllProfiles();
 
     bool is_save_needed{};
     std::array<ProfileInfo, MAX_USERS> profiles{};