RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2024-11-22 02:32:36 +01:00
Code Issues Releases Wiki Activity

Move unspecific Emulator code out of System.cpp

Browse Source
This commit is contained in:
Megamouse 2021-04-21 22:12:21 +02:00 committed by Ivan
parent 4c2a11b6d0
commit 1caf81811a
38 changed files with 729 additions and 652 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
rpcs3/Crypto/unpkg.cpp
View File

@ -5,6 +5,7 @@
#include "util/logs.hpp"
#include "Utilities/StrUtil.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Emu/VFS.h"
#include "unpkg.h"
#include "Loader/PSF.h"
@ -590,7 +591,7 @@ package_error package_reader::check_target_app_version() const
return package_error::no_error;
}
const fs::file installed_sfo_file(Emu.GetHddDir() + "game/" + std::string(title_id) + "/PARAM.SFO");
const fs::file installed_sfo_file(rpcs3::utils::get_hdd0_dir() + "game/" + std::string(title_id) + "/PARAM.SFO");
if (!installed_sfo_file)
{
if (!target_app_ver.empty())
@ -674,7 +675,7 @@ bool package_reader::extract_data(atomic_t<double>& sync)
}
// Get full path and create the directory
std::string dir = Emulator::GetHddDir();
std::string dir = rpcs3::utils::get_hdd0_dir();
// Based on https://www.psdevwiki.com/ps3/PKG_files#ContentType
switch (m_metadata.content_type)

3
rpcs3/Crypto/unself.cpp
View File

@ -4,6 +4,7 @@
#include "unself.h"
#include "Emu/VFS.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include <algorithm>
#include <zlib.h>
@ -1320,7 +1321,7 @@ bool SELFDecrypter::GetKeyFromRap(u8* content_id, u8* npdrm_key)
// Try to find a matching RAP file under exdata folder.
const std::string ci_str = reinterpret_cast<const char*>(content_id);
const std::string rap_path = Emulator::GetRapFilePath(ci_str);
const std::string rap_path = rpcs3::utils::get_rap_file_path(ci_str);
// Open the RAP file and read the key.
const fs::file rap_file(rap_path);

3
rpcs3/Emu/CMakeLists.txt
View File

@ -1,9 +1,12 @@
add_library(rpcs3_emu
cache_utils.cpp
IdManager.cpp
localized_string.cpp
System.cpp
system_config.cpp
system_config_types.cpp
system_progress.cpp
system_utils.cpp
VFS.cpp
GDB.cpp
title.cpp

3
rpcs3/Emu/Cell/Modules/cellGame.cpp
View File

@ -1,6 +1,7 @@
#include "stdafx.h"
#include "Emu/localized_string.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Emu/VFS.h"
#include "Emu/IdManager.h"
#include "Emu/Cell/ErrorCodes.h"
@ -978,7 +979,7 @@ error_code cellGameDeleteGameData(vm::cptr<char> dirName)
}
// Actually remove game data
if (!vfs::host::remove_all(dir, Emu.GetHddDir(), &g_mp_sys_dev_hdd0, true))
if (!vfs::host::remove_all(dir, rpcs3::utils::get_hdd0_dir(), &g_mp_sys_dev_hdd0, true))
{
return {CELL_GAME_ERROR_ACCESS_ERROR, dir};
}

3
rpcs3/Emu/Cell/Modules/cellSysCache.cpp
View File

@ -1,5 +1,6 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Emu/VFS.h"
#include "Emu/IdManager.h"
#include "Emu/Cell/PPUModule.h"
@ -32,7 +33,7 @@ extern lv2_fs_mount_point g_mp_sys_dev_hdd1;
struct syscache_info
{
const std::string cache_root = Emu.GetHdd1Dir() + "/caches/";
const std::string cache_root = rpcs3::utils::get_hdd1_dir() + "/caches/";
stx::init_mutex init;

11
rpcs3/Emu/Cell/Modules/cellUserInfo.cpp
View File

@ -1,5 +1,6 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Emu/VFS.h"
#include "Emu/IdManager.h"
#include "Emu/Cell/PPUModule.h"
@ -22,7 +23,7 @@ std::string get_username(const u32 user_id)
{
std::string username;
if (const fs::file file{Emulator::GetHddDir() + fmt::format("home/%08d/localusername", user_id)})
if (const fs::file file{rpcs3::utils::get_hdd0_dir() + fmt::format("home/%08d/localusername", user_id)})
{
username = file.to_string();
username.resize(CELL_USERINFO_USERNAME_SIZE); // TODO: investigate
@ -119,7 +120,7 @@ error_code cellUserInfoSelectUser_ListType(vm::ptr<CellUserInfoTypeSet> listType
}
std::vector<u32> user_ids;
const std::string home_dir = Emulator::GetHddDir() + "home";
const std::string home_dir = rpcs3::utils::get_hdd0_dir() + "home";
for (const auto& user_folder : fs::dir(home_dir))
{
@ -129,7 +130,7 @@ error_code cellUserInfoSelectUser_ListType(vm::ptr<CellUserInfoTypeSet> listType
}
// Is the folder name exactly 8 all-numerical characters long?
const u32 user_id = Emulator::CheckUsr(user_folder.name);
const u32 user_id = rpcs3::utils::check_user(user_folder.name);
if (user_id == 0)
{
@ -330,7 +331,7 @@ error_code cellUserInfoGetList(vm::ptr<u32> listNum, vm::ptr<CellUserInfoUserLis
}
}
const std::string home_dir = Emulator::GetHddDir() + "home";
const std::string home_dir = rpcs3::utils::get_hdd0_dir() + "home";
std::vector<u32> user_ids;
for (const auto& user_folder : fs::dir(home_dir))
@ -341,7 +342,7 @@ error_code cellUserInfoGetList(vm::ptr<u32> listNum, vm::ptr<CellUserInfoUserLis
}
// Is the folder name exactly 8 all-numerical characters long?
const u32 user_id = Emulator::CheckUsr(user_folder.name);
const u32 user_id = rpcs3::utils::check_user(user_folder.name);
if (user_id == 0)
{

7
rpcs3/Emu/Cell/Modules/sceNp.cpp
View File

@ -1,5 +1,6 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Emu/VFS.h"
#include "Emu/Cell/PPUModule.h"
@ -506,7 +507,7 @@ error_code npDrmIsAvailable(vm::cptr<u8> k_licensee_addr, vm::cptr<char> drm_pat
if (VerifyEDATHeaderWithKLicense(enc_file, enc_drm_path_local, reinterpret_cast<u8*>(&k_licensee), &contentID))
{
const std::string rap_file = Emulator::GetRapFilePath(contentID);
const std::string rap_file = rpcs3::utils::get_rap_file_path(contentID);
npdrmkeys.devKlic = k_licensee;
if (fs::is_file(rap_file))
@ -552,7 +553,7 @@ error_code sceNpDrmVerifyUpgradeLicense(vm::cptr<char> content_id)
}
const std::string content_str(content_id.get_ptr(), std::find(content_id.get_ptr(), content_id.get_ptr() + 0x2f, '\0'));
const std::string rap_file = Emulator::GetRapFilePath(content_str);
const std::string rap_file = rpcs3::utils::get_rap_file_path(content_str);
sceNp.warning(u8"sceNpDrmVerifyUpgradeLicense(): content_id=“%s”", content_id);
@ -576,7 +577,7 @@ error_code sceNpDrmVerifyUpgradeLicense2(vm::cptr<char> content_id)
}
const std::string content_str(content_id.get_ptr(), std::find(content_id.get_ptr(), content_id.get_ptr() + 0x2f, '\0'));
const std::string rap_file = Emulator::GetRapFilePath(content_str);
const std::string rap_file = rpcs3::utils::get_rap_file_path(content_str);
sceNp.warning(u8"sceNpDrmVerifyUpgradeLicense2(): content_id=“%s”", content_id);

6
rpcs3/Emu/Cell/PPUThread.cpp
View File

@ -10,6 +10,8 @@
#include "Emu/Memory/vm_locking.h"
#include "Emu/RSX/RSXThread.h"
#include "Emu/VFS.h"
#include "Emu/system_progress.hpp"
#include "Emu/system_utils.hpp"
#include "PPUThread.h"
#include "PPUInterpreter.h"
#include "PPUAnalyser.h"
@ -67,8 +69,6 @@ const bool s_use_ssse3 = utils::has_ssse3();
extern atomic_t<u64> g_watchdog_hold_ctr;
#include "Emu/system_progress.hpp"
// Should be of the same type
using spu_rdata_t = decltype(ppu_thread::rdata);
@ -2999,7 +2999,7 @@ bool ppu_initialize(const ppu_module& info, bool check_only)
// Create worker threads for compilation (TODO: how many threads)
{
u32 thread_count = Emulator::GetMaxThreads();
u32 thread_count = rpcs3::utils::get_max_threads();
if (workload.size() < thread_count)
{

11
rpcs3/Emu/Cell/SPURecompiler.cpp
View File

@ -3,6 +3,9 @@
#include "Emu/System.h"
#include "Emu/system_config.h"
#include "Emu/system_progress.hpp"
#include "Emu/system_utils.hpp"
#include "Emu/cache_utils.hpp"
#include "Emu/IdManager.h"
#include "Emu/Cell/timers.hpp"
#include "Crypto/sha1.h"
@ -23,8 +26,6 @@
#include "util/v128sse.hpp"
#include "util/sysinfo.hpp"
#include "Emu/system_progress.hpp"
const spu_decoder<spu_itype> s_spu_itype;
const spu_decoder<spu_iname> s_spu_iname;
const spu_decoder<spu_iflag> s_spu_iflag;
@ -368,7 +369,7 @@ void spu_cache::initialize()
}
}
const std::string ppu_cache = Emu.PPUCache();
const std::string ppu_cache = rpcs3::cache::get_ppu_cache();
if (ppu_cache.empty())
{
@ -425,7 +426,7 @@ void spu_cache::initialize()
g_progr_ptotal += ::size32(func_list);
progr.emplace("Building SPU cache...");
worker_count = Emulator::GetMaxThreads();
worker_count = rpcs3::utils::get_max_threads();
}
named_thread_group workers("SPU Worker ", worker_count, [&]() -> uint
@ -585,7 +586,7 @@ bool spu_program::operator<(const spu_program& rhs) const noexcept
spu_runtime::spu_runtime()
{
// Clear LLVM output
m_cache_path = Emu.PPUCache();
m_cache_path = rpcs3::cache::get_ppu_cache();
if (m_cache_path.empty())
{

8
rpcs3/Emu/Io/PadHandler.cpp
View File

@ -1,6 +1,6 @@
#include "stdafx.h"
#include "PadHandler.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Input/pad_thread.h"
#include "Input/product_info.h"
@ -292,16 +292,16 @@ std::string PadHandlerBase::get_config_dir(pad_handler type, const std::string&
{
if (!title_id.empty())
{
return Emulator::GetCustomInputConfigDir(title_id) + fmt::format("%s", type) + "/";
return rpcs3::utils::get_custom_input_config_dir(title_id) + fmt::format("%s", type) + "/";
}
return fs::get_config_dir() + "/InputConfigs/" + fmt::format("%s", type) + "/";
}
std::string PadHandlerBase::get_config_filename(int i, const std::string& title_id)
{
if (!title_id.empty() && fs::is_file(Emulator::GetCustomInputConfigPath(title_id)))
if (!title_id.empty() && fs::is_file(rpcs3::utils::get_custom_input_config_path(title_id)))
{
const std::string path = Emulator::GetCustomInputConfigDir(title_id) + g_cfg_input.player[i]->handler.to_string() + "/" + g_cfg_input.player[i]->profile.to_string() + ".yml";
const std::string path = rpcs3::utils::get_custom_input_config_dir(title_id) + g_cfg_input.player[i]->handler.to_string() + "/" + g_cfg_input.player[i]->profile.to_string() + ".yml";
if (fs::is_file(path))
{
return path;

6
rpcs3/Emu/Io/pad_config.cpp
View File

@ -1,6 +1,6 @@
#include "stdafx.h"
#include "pad_config.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
cfg_input::cfg_input()
: cfg_name(fs::get_config_dir() + "/config_input.yml")
@ -9,7 +9,7 @@ cfg_input::cfg_input()
bool cfg_input::load(const std::string& title_id)
{
cfg_name = Emulator::GetCustomInputConfigPath(title_id);
cfg_name = rpcs3::utils::get_custom_input_config_path(title_id);
if (!fs::is_file(cfg_name))
{
@ -38,7 +38,7 @@ void cfg_input::save(const std::string& title_id)
}
else
{
cfg_name = Emulator::GetCustomInputConfigPath(title_id);
cfg_name = rpcs3::utils::get_custom_input_config_path(title_id);
}
fs::file(cfg_name, fs::rewrite).write(to_string());
}

2
rpcs3/Emu/RSX/Common/texture_cache_utils.h
View File

@ -1,11 +1,11 @@
#pragma once
#include "../rsx_cache.h"
#include "texture_cache_types.h"
#include "texture_cache_predictor.h"
#include "TextureUtils.h"
#include "Emu/Memory/vm.h"
#include "util/vm.hpp"
#include <list>
#include <unordered_set>

4
rpcs3/Emu/RSX/Overlays/overlay_user_list_dialog.cpp
View File

@ -1,7 +1,7 @@
#include "stdafx.h"
#include "overlay_user_list_dialog.h"
#include "Emu/System.h"
#include "Emu/system_config.h"
#include "Emu/system_utils.hpp"
#include "Utilities/StrUtil.h"
#include "Utilities/Thread.h"
@ -152,7 +152,7 @@ namespace rsx
std::vector<u8> icon;
std::vector<std::unique_ptr<overlay_element>> entries;
const std::string home_dir = Emulator::GetHddDir() + "home/";
const std::string home_dir = rpcs3::utils::get_hdd0_dir() + "home/";
s32 selected_index = 0;
for (const auto& id : user_ids)

4
rpcs3/Emu/RSX/rsx_cache.h
View File

@ -4,6 +4,7 @@
#include "Utilities/Thread.h"
#include "Common/ProgramStateCache.h"
#include "Emu/System.h"
#include "Emu/cache_utils.hpp"
#include "Common/texture_cache_checker.h"
#include "Overlays/Shaders/shader_loading_dialog.h"
@ -11,7 +12,6 @@
#include <chrono>
#include <unordered_map>
#include "util/vm.hpp"
#include "util/sysinfo.hpp"
#include "util/fnv_hash.hpp"
@ -199,7 +199,7 @@ namespace rsx
{
if (!g_cfg.video.disable_on_disk_shader_cache)
{
root_path = Emu.PPUCache() + "shaders_cache";
root_path = rpcs3::cache::get_ppu_cache() + "shaders_cache";
}
}

570
rpcs3/Emu/System.cpp
View File

@ -3,6 +3,8 @@
#include "Utilities/bin_patch.h"
#include "Emu/Memory/vm.h"
#include "Emu/System.h"
#include "Emu/system_progress.hpp"
#include "Emu/system_utils.hpp"
#include "Emu/perf_meter.hpp"
#include "Emu/Cell/ErrorCodes.h"
@ -15,12 +17,10 @@
#include "Emu/Cell/lv2/sys_sync.h"
#include "Emu/Cell/lv2/sys_prx.h"
#include "Emu/Cell/lv2/sys_overlay.h"
#include "Emu/Cell/Modules/cellMsgDialog.h"
#include "Emu/title.h"
#include "Emu/IdManager.h"
#include "Emu/RSX/Capture/rsx_replay.h"
#include "Emu/RSX/Overlays/overlay_message_dialog.h"
#include "Loader/PSF.h"
#include "Loader/ELF.h"
@ -28,17 +28,13 @@
#include "Utilities/StrUtil.h"
#include "../Crypto/unself.h"
#include "../Crypto/unpkg.h"
#include "util/sysinfo.hpp"
#include "util/yaml.hpp"
#include "util/logs.hpp"
#include "util/cereal.hpp"
#include <thread>
#include <fstream>
#include <memory>
#include <regex>
#include <charconv>
#include "Utilities/JIT.h"
@ -75,21 +71,9 @@ atomic_t<s64> g_tty_size{0};
std::array<std::deque<std::string>, 16> g_tty_input;
std::mutex g_tty_mutex;
// Progress display server synchronization variables
atomic_t<const char*> g_progr{nullptr};
atomic_t<u32> g_progr_ftotal{0};
atomic_t<u32> g_progr_fdone{0};
atomic_t<u32> g_progr_ptotal{0};
atomic_t<u32> g_progr_pdone{0};
// Report error and call std::abort(), defined in main.cpp
[[noreturn]] void report_fatal_error(std::string_view);
namespace
{
struct progress_dialog_server;
}
namespace atomic_wait
{
extern void parse_hashtable(bool(*cb)(u64 id, u32 refs, u64 ptr, u32 stats));
@ -191,8 +175,8 @@ void Emulator::Init(bool add_only)
}
// Create directories (can be disabled if necessary)
const std::string emu_dir = GetEmuDir();
const std::string dev_hdd0 = GetHddDir();
const std::string emu_dir = rpcs3::utils::get_emu_dir();
const std::string dev_hdd0 = rpcs3::utils::get_hdd0_dir();
const std::string dev_hdd1 = g_cfg.vfs.get(g_cfg.vfs.dev_hdd1, emu_dir);
const std::string dev_usb = g_cfg.vfs.get(g_cfg.vfs.dev_usb000, emu_dir);
const std::string dev_flsh = g_cfg.vfs.get_dev_flash();
@ -322,225 +306,17 @@ void Emulator::Init(bool add_only)
// Limit cache size
if (g_cfg.vfs.limit_cache_size)
LimitCacheSize();
rpcs3::cache::limit_cache_size();
// Initialize patch engine
g_fxo->init<patch_engine>()->append_global_patches();
}
namespace rsx::overlays
{
class progress_dialog : public message_dialog
{
public:
using message_dialog::message_dialog;
};
}
namespace
{
struct progress_dialog_server
{
void operator()()
{
while (thread_ctrl::state() != thread_state::aborting)
{
// Wait for the start condition
auto text0 = +g_progr;
while (!text0)
{
if (thread_ctrl::state() == thread_state::aborting)
{
break;
}
std::this_thread::sleep_for(5ms);
text0 = +g_progr;
}
if (thread_ctrl::state() == thread_state::aborting)
{
break;
}
// Initialize message dialog
bool skip_this_one = false; // Workaround: do not open a progress dialog if there is already a cell message dialog open.
std::shared_ptr<MsgDialogBase> dlg;
std::shared_ptr<rsx::overlays::progress_dialog> native_dlg;
if (const auto renderer = rsx::get_current_renderer();
renderer && renderer->is_inited)
{
auto manager = g_fxo->try_get<rsx::overlays::display_manager>();
skip_this_one = g_fxo->get<progress_dialog_workaround>().skip_the_progress_dialog || (manager && manager->get<rsx::overlays::message_dialog>());
if (manager && !skip_this_one)
{
MsgDialogType type{};
type.se_normal = true;
type.bg_invisible = true;
type.disable_cancel = true;
type.progress_bar_count = 1;
native_dlg = manager->create<rsx::overlays::progress_dialog>(true);
native_dlg->show(false, text0, type, nullptr);
native_dlg->progress_bar_set_message(0, "Please wait");
}
}
if (!skip_this_one && !native_dlg)
{
dlg = Emu.GetCallbacks().get_msg_dialog();
dlg->type.se_normal = true;
dlg->type.bg_invisible = true;
dlg->type.progress_bar_count = 1;
dlg->on_close = [](s32 /*status*/)
{
Emu.CallAfter([]()
{
// Abort everything
Emu.Stop();
});
};
Emu.CallAfter([dlg, text0]()
{
dlg->Create(text0, text0);
});
}
u32 ftotal = 0;
u32 fdone = 0;
u32 ptotal = 0;
u32 pdone = 0;
auto text1 = text0;
// Update progress
while (thread_ctrl::state() != thread_state::aborting)
{
const auto text_new = g_progr.load();
const u32 ftotal_new = g_progr_ftotal;
const u32 fdone_new = g_progr_fdone;
const u32 ptotal_new = g_progr_ptotal;
const u32 pdone_new = g_progr_pdone;
if (ftotal != ftotal_new || fdone != fdone_new || ptotal != ptotal_new || pdone != pdone_new || text_new != text1)
{
ftotal = ftotal_new;
fdone = fdone_new;
ptotal = ptotal_new;
pdone = pdone_new;
text1 = text_new;
if (!text_new)
{
// Close dialog
break;
}
if (skip_this_one)
{
// Do nothing
std::this_thread::sleep_for(10ms);
continue;
}
// Compute new progress in percents
// Assume not all programs were found if files were not compiled (as it may contain more)
const u64 total = std::max<u64>(ptotal, 1) * std::max<u64>(ftotal, 1);
const u64 done = pdone * std::max<u64>(fdone, 1);
const double value = std::fmin(done * 100. / total, 100.);
std::string progr = "Progress:";
if (ftotal)
fmt::append(progr, " file %u of %u%s", fdone, ftotal, ptotal ? "," : "");
if (ptotal)
fmt::append(progr, " module %u of %u", pdone, ptotal);
// Changes detected, send update
if (native_dlg)
{
native_dlg->set_text(text_new);
native_dlg->progress_bar_set_message(0, progr);
native_dlg->progress_bar_set_value(0, std::floor(value));
}
else if (dlg)
{
Emu.CallAfter([=]()
{
dlg->SetMsg(text_new);
dlg->ProgressBarSetMsg(0, progr);
dlg->ProgressBarSetValue(0, std::floor(value));
});
}
}
std::this_thread::sleep_for(10ms);
}
if (thread_ctrl::state() == thread_state::aborting)
{
break;
}
if (skip_this_one)
{
// Do nothing
}
else if (native_dlg)
{
native_dlg->close(false, false);
}
else if (dlg)
{
Emu.CallAfter([=]()
{
dlg->Close(true);
});
}
// Cleanup
g_progr_fdone -= fdone;
g_progr_pdone -= pdone;
g_progr_ftotal -= ftotal;
g_progr_ptotal -= ptotal;
g_progr_ptotal.notify_all();
}
}
~progress_dialog_server()
{
g_progr_ftotal.release(0);
g_progr_fdone.release(0);
g_progr_ptotal.release(0);
g_progr_pdone.release(0);
g_progr.release(nullptr);
}
static auto constexpr thread_name = "Progress Dialog Server"sv;
};
}
u32 Emulator::CheckUsr(const std::string& user)
{
u32 id = 0;
if (user.size() == 8)
{
std::from_chars(&user.front(), &user.back() + 1, id);
}
return id;
}
void Emulator::SetUsr(const std::string& user)
{
sys_log.notice("Setting user ID '%s'", user);
const u32 id = CheckUsr(user);
const u32 id = rpcs3::utils::check_user(user);
if (id == 0)
{
@ -594,19 +370,6 @@ std::string Emulator::GetBackgroundPicturePath() const
return path;
}
std::string Emulator::PPUCache()
{
auto& _main = g_fxo->get<ppu_module>();
if (!g_fxo->is_init<ppu_module>() || _main.cache.empty())
{
ppu_log.warning("PPU Cache location not initialized.");
return {};
}
return _main.cache;
}
bool Emulator::BootRsxCapture(const std::string& path)
{
fs::file in_file(path);
@ -655,93 +418,6 @@ bool Emulator::BootRsxCapture(const std::string& path)
return true;
}
void Emulator::LimitCacheSize()
{
const std::string cache_location = GetHdd1Dir() + "/caches";
if (!fs::is_dir(cache_location))
{
sys_log.warning("Cache does not exist (%s)", cache_location);
return;
}
const u64 size = fs::get_dir_size(cache_location);
if (size == umax)
{
sys_log.error("Could not calculate cache directory '%s' size (%s)", cache_location, fs::g_tls_error);
return;
}
const u64 max_size = static_cast<u64>(g_cfg.vfs.cache_max_size) * 1024 * 1024;
if (max_size == 0) // Everything must go, so no need to do checks
{
fs::remove_all(cache_location, false);
sys_log.success("Cleared disk cache");
return;
}
if (size <= max_size)
{
sys_log.trace("Cache size below limit: %llu/%llu", size, max_size);
return;
}
sys_log.success("Cleaning disk cache...");
std::vector<fs::dir_entry> file_list{};
fs::dir cache_dir(cache_location);
if (!cache_dir)
{
sys_log.error("Could not open cache directory '%s' (%s)", cache_location, fs::g_tls_error);
return;
}
// retrieve items to delete
for (const auto &item : cache_dir)
{
if (item.name != "." && item.name != "..")
file_list.push_back(item);
}
cache_dir.close();
// sort oldest first
std::sort(file_list.begin(), file_list.end(), [](auto left, auto right)
{
return left.mtime < right.mtime;
});
// keep removing until cache is empty or enough bytes have been cleared
// cache is cleared down to 80% of limit to increase interval between clears
const u64 to_remove = static_cast<u64>(size - max_size * 0.8);
u64 removed = 0;
for (const auto &item : file_list)
{
const std::string &name = cache_location + "/" + item.name;
const bool is_dir = fs::is_dir(name);
const u64 item_size = is_dir ? fs::get_dir_size(name) : item.size;
if (is_dir && item_size == umax)
{
sys_log.error("Failed to calculate '%s' item '%s' size (%s)", cache_location, item.name, fs::g_tls_error);
break;
}
if (is_dir ? !fs::remove_all(name, true) : !fs::remove_file(name))
{
sys_log.error("Could not remove cache directory '%s' item '%s' (%s)", cache_location, item.name, fs::g_tls_error);
break;
}
removed += item_size;
if (removed >= to_remove)
break;
}
sys_log.success("Cleaned disk cache, removed %.2f MB", size / 1024.0 / 1024.0);
}
game_boot_result Emulator::BootGame(const std::string& path, const std::string& title_id, bool direct, bool add_only, bool force_global_config)
{
if (!fs::exists(path))
@ -806,179 +482,6 @@ game_boot_result Emulator::BootGame(const std::string& path, const std::string&
return result;
}
bool Emulator::InstallPkg(const std::string& path)
{
sys_log.success("Installing package: %s", path);
atomic_t<double> progress(0.);
int int_progress = 0;
// Run PKG unpacking asynchronously
named_thread worker("PKG Installer", [&]
{
package_reader reader(path);
return reader.extract_data(progress);
});
{
// Wait for the completion
while (std::this_thread::sleep_for(5ms), worker <= thread_state::aborting)
{
// TODO: update unified progress dialog
double pval = progress;
pval < 0 ? pval += 1. : pval;
pval *= 100.;
if (static_cast<int>(pval) > int_progress)
{
int_progress = static_cast<int>(pval);
sys_log.success("... %u%%", int_progress);
}
}
}
return worker();
}
std::string Emulator::GetEmuDir()
{
const std::string& emu_dir_ = g_cfg.vfs.emulator_dir;
return emu_dir_.empty() ? fs::get_config_dir() : emu_dir_;
}
std::string Emulator::GetHddDir()
{
return g_cfg.vfs.get(g_cfg.vfs.dev_hdd0, GetEmuDir());
}
std::string Emulator::GetHdd1Dir()
{
return g_cfg.vfs.get(g_cfg.vfs.dev_hdd1, GetEmuDir());
}
std::string Emulator::GetCacheDir()
{
return fs::get_cache_dir() + "cache/";
}
#ifdef _WIN32
std::string Emulator::GetExeDir()
{
wchar_t buffer[32767];
GetModuleFileNameW(nullptr, buffer, sizeof(buffer)/2);
const std::string path_to_exe = wchar_to_utf8(buffer);
const usz last = path_to_exe.find_last_of('\\');
return last == std::string::npos ? std::string("") : path_to_exe.substr(0, last+1);
}
#endif
std::string Emulator::GetSfoDirFromGamePath(const std::string& game_path, const std::string& title_id)
{
if (fs::is_file(game_path + "/PS3_DISC.SFB"))
{
// This is a disc game.
if (!title_id.empty())
{
for (auto&& entry : fs::dir{game_path})
{
if (entry.name == "." || entry.name == "..")
{
continue;
}
const std::string sfo_path = game_path + "/" + entry.name + "/PARAM.SFO";
if (entry.is_directory && fs::is_file(sfo_path))
{
const auto psf = psf::load_object(fs::file(sfo_path));
const auto serial = psf::get_string(psf, "TITLE_ID");
if (serial == title_id)
{
return game_path + "/" + entry.name;
}
}
}
}
return game_path + "/PS3_GAME";
}
const auto psf = psf::load_object(fs::file(game_path + "/PARAM.SFO"));
const auto category = psf::get_string(psf, "CATEGORY");
const auto content_id = std::string(psf::get_string(psf, "CONTENT_ID"));
if (category == "HG" && !content_id.empty())
{
// This is a trial game. Check if the user has a RAP file to unlock it.
if (fs::is_file(game_path + "/C00/PARAM.SFO") && fs::is_file(GetRapFilePath(content_id)))
{
// Load full game data.
sys_log.notice("Found RAP file %s.rap for trial game %s", content_id, title_id);
return game_path + "/C00";
}
}
return game_path;
}
std::string Emulator::GetRapFilePath(const std::string& rap)
{
const std::string home_dir = GetHddDir() + "/home";
for (auto&& entry : fs::dir(home_dir))
{
if (entry.is_directory && CheckUsr(entry.name))
{
std::string rap_path = fmt::format("%s/%s/exdata/%s.rap", home_dir, entry.name, rap);
if (fs::is_file(rap_path))
{
return rap_path;
}
}
}
return {};
}
std::string Emulator::GetCustomConfigDir()
{
#ifdef _WIN32
return fs::get_config_dir() + "config/custom_configs/";
#else
return fs::get_config_dir() + "custom_configs/";
#endif
}
std::string Emulator::GetCustomConfigPath(const std::string& title_id, bool get_deprecated_path)
{
std::string path;
if (get_deprecated_path)
path = fs::get_config_dir() + "data/" + title_id + "/config.yml";
else
path = GetCustomConfigDir() + "config_" + title_id + ".yml";
return path;
}
std::string Emulator::GetCustomInputConfigDir(const std::string& title_id)
{
// Notice: the extra folder for each title id may be removed at a later stage
// Warning: make sure to change any function that removes this directory as well
#ifdef _WIN32
return fs::get_config_dir() + "config/custom_input_configs/" + title_id + "/";
#else
return fs::get_config_dir() + "custom_input_configs/" + title_id + "/";
#endif
}
std::string Emulator::GetCustomInputConfigPath(const std::string& title_id)
{
return GetCustomInputConfigDir(title_id) + "/config_input_" + title_id + ".yml";
}
void Emulator::SetForceBoot(bool force_boot)
{
m_force_boot = force_boot;
@ -1038,7 +541,7 @@ game_boot_result Emulator::Load(const std::string& title_id, bool add_only, bool
if (fs::is_dir(m_path))
{
// Special case (directory scan)
m_sfo_dir = GetSfoDirFromGamePath(m_path, m_title_id);
m_sfo_dir = rpcs3::utils::get_sfo_dir_from_game_path(m_path, m_title_id);
}
else if (!disc.empty())
{
@ -1049,16 +552,16 @@ game_boot_result Emulator::Load(const std::string& title_id, bool add_only, bool
}
else if (m_cat == "GD")
{
m_sfo_dir = GetHddDir() + "game/" + m_title_id;
m_sfo_dir = rpcs3::utils::get_hdd0_dir() + "game/" + m_title_id;
}
else
{
m_sfo_dir = GetSfoDirFromGamePath(disc, m_title_id);
m_sfo_dir = rpcs3::utils::get_sfo_dir_from_game_path(disc, m_title_id);
}
}
else
{
m_sfo_dir = GetSfoDirFromGamePath(elf_dir + "/../", m_title_id);
m_sfo_dir = rpcs3::utils::get_sfo_dir_from_game_path(elf_dir + "/../", m_title_id);
}
_psf = psf::load_object(fs::file(m_sfo_dir + "/PARAM.SFO"));
@ -1085,8 +588,8 @@ game_boot_result Emulator::Load(const std::string& title_id, bool add_only, bool
if (!add_only && !force_global_config && m_config_override_path.empty())
{
const std::string config_path_new = GetCustomConfigPath(m_title_id);
const std::string config_path_old = GetCustomConfigPath(m_title_id, true);
const std::string config_path_new = rpcs3::utils::get_custom_config_path(m_title_id);
const std::string config_path_old = rpcs3::utils::get_custom_config_path(m_title_id, true);
// Load custom config-1
if (fs::file cfg_file{ config_path_old })
@ -1159,7 +662,7 @@ game_boot_result Emulator::Load(const std::string& title_id, bool add_only, bool
g_fxo->get<patch_engine>().append_title_patches(m_title_id);
// Mount all devices
const std::string emu_dir = GetEmuDir();
const std::string emu_dir = rpcs3::utils::get_emu_dir();
std::string bdvd_dir = g_cfg.vfs.dev_bdvd;
// Mount default relative path to non-existent directory
@ -1503,7 +1006,7 @@ game_boot_result Emulator::Load(const std::string& title_id, bool add_only, bool
for (auto&& entry : fs::dir{ins_dir})
{
const std::string pkg = ins_dir + entry.name;
if (!entry.is_directory && entry.name.ends_with(".PKG") && !InstallPkg(pkg))
if (!entry.is_directory && entry.name.ends_with(".PKG") && !rpcs3::utils::install_pkg(pkg))
{
sys_log.error("Failed to install %s", pkg);
return game_boot_result::install_failed;
@ -1521,7 +1024,7 @@ game_boot_result Emulator::Load(const std::string& title_id, bool add_only, bool
{
const std::string pkg_file = pkg_dir + entry.name + "/INSTALL.PKG";
if (fs::is_file(pkg_file) && !InstallPkg(pkg_file))
if (fs::is_file(pkg_file) && !rpcs3::utils::install_pkg(pkg_file))
{
sys_log.error("Failed to install %s", pkg_file);
return game_boot_result::install_failed;
@ -1540,7 +1043,7 @@ game_boot_result Emulator::Load(const std::string& title_id, bool add_only, bool
{
const std::string pkg_file = extra_dir + entry.name + "/DATA000.PKG";
if (fs::is_file(pkg_file) && !InstallPkg(pkg_file))
if (fs::is_file(pkg_file) && !rpcs3::utils::install_pkg(pkg_file))
{
sys_log.error("Failed to install %s", pkg_file);
return game_boot_result::install_failed;
@ -1838,7 +1341,7 @@ void Emulator::Run(bool start_playtime)
m_pause_amend_time = 0;
m_state = system_state::running;
ConfigureLogs();
rpcs3::utils::configure_logs();
// Run main thread
idm::check<named_thread<ppu_thread>>(ppu_thread::id_base, [](named_thread<ppu_thread>& cpu)
@ -2137,14 +1640,6 @@ std::string Emulator::GetFormattedTitle(double fps) const
return rpcs3::get_formatted_title(title_data);
}
u32 Emulator::GetMaxThreads()
{
const u32 max_threads = static_cast<u32>(g_cfg.core.llvm_threads);
const u32 hw_threads = utils::get_thread_count();
const u32 thread_count = max_threads > 0 ? std::min(max_threads, hw_threads) : hw_threads;
return thread_count;
}
s32 error_code::error_report(const fmt_type_info* sup, u64 arg, const fmt_type_info* sup2, u64 arg2)
{
static thread_local std::unordered_map<std::string, usz> g_tls_error_stats;
@ -2199,40 +1694,11 @@ s32 error_code::error_report(const fmt_type_info* sup, u64 arg, const fmt_type_i
return static_cast<s32>(arg);
}
void Emulator::ConfigureLogs()
{
static bool was_silenced = false;
const bool silenced = g_cfg.misc.silence_all_logs.get();
if (silenced)
{
if (!was_silenced)
{
sys_log.notice("Disabling logging...");
}
logs::silence();
}
else
{
logs::reset();
logs::set_channel_levels(g_cfg.log.get_map());
if (was_silenced)
{
sys_log.notice("Logging enabled");
}
}
was_silenced = silenced;
}
void Emulator::ConfigurePPUCache() const
{
auto& _main = g_fxo->get<ppu_module>();
_main.cache = GetCacheDir();
_main.cache = rpcs3::utils::get_cache_dir();
if (!m_title_id.empty() && m_cat != "1P")
{

27
rpcs3/Emu/System.h
View File

@ -205,8 +205,6 @@ public:
return m_usrid;
}
static u32 CheckUsr(const std::string& user);
void SetUsr(const std::string& user);
std::string GetBackgroundPicturePath() const;
@ -216,27 +214,8 @@ public:
return m_pause_amend_time;
}
static std::string PPUCache();
game_boot_result BootGame(const std::string& path, const std::string& title_id = "", bool direct = false, bool add_only = false, bool force_global_config = false);
bool BootRsxCapture(const std::string& path);
static bool InstallPkg(const std::string& path);
#ifdef _WIN32
static std::string GetExeDir();
#endif
static std::string GetEmuDir();
static std::string GetHddDir();
static std::string GetHdd1Dir();
static std::string GetCacheDir();
static std::string GetSfoDirFromGamePath(const std::string& game_path, const std::string& title_id = "");
static std::string GetRapFilePath(const std::string& rap);
static std::string GetCustomConfigDir();
static std::string GetCustomConfigPath(const std::string& title_id, bool get_deprecated_path = false);
static std::string GetCustomInputConfigDir(const std::string& title_id);
static std::string GetCustomInputConfigPath(const std::string& title_id);
void SetForceBoot(bool force_boot);
@ -264,15 +243,9 @@ public:
std::string GetFormattedTitle(double fps) const;
static u32 GetMaxThreads();
static void ConfigureLogs();
void ConfigurePPUCache() const;
std::set<std::string> GetGameDirs() const;
private:
static void LimitCacheSize();
};
extern Emulator Emu;

112
rpcs3/Emu/cache_utils.cpp Normal file
View File

@ -0,0 +1,112 @@
#include "stdafx.h"
#include "cache_utils.hpp"
#include "system_utils.hpp"
#include "system_config.h"
#include "IdManager.h"
#include "Emu/Cell/PPUAnalyser.h"
#include "Emu/Cell/PPUThread.h"
LOG_CHANNEL(sys_log, "SYS");
namespace rpcs3::cache
{
std::string get_ppu_cache()
{
auto& _main = g_fxo->get<ppu_module>();
if (!g_fxo->is_init<ppu_module>() || _main.cache.empty())
{
ppu_log.warning("PPU Cache location not initialized.");
return {};
}
return _main.cache;
}
void limit_cache_size()
{
const std::string cache_location = rpcs3::utils::get_hdd1_dir() + "/caches";
if (!fs::is_dir(cache_location))
{
sys_log.warning("Cache does not exist (%s)", cache_location);
return;
}
const u64 size = fs::get_dir_size(cache_location);
if (size == umax)
{
sys_log.error("Could not calculate cache directory '%s' size (%s)", cache_location, fs::g_tls_error);
return;
}
const u64 max_size = static_cast<u64>(g_cfg.vfs.cache_max_size) * 1024 * 1024;
if (max_size == 0) // Everything must go, so no need to do checks
{
fs::remove_all(cache_location, false);
sys_log.success("Cleared disk cache");
return;
}
if (size <= max_size)
{
sys_log.trace("Cache size below limit: %llu/%llu", size, max_size);
return;
}
sys_log.success("Cleaning disk cache...");
std::vector<fs::dir_entry> file_list{};
fs::dir cache_dir(cache_location);
if (!cache_dir)
{
sys_log.error("Could not open cache directory '%s' (%s)", cache_location, fs::g_tls_error);
return;
}
// retrieve items to delete
for (const auto &item : cache_dir)
{
if (item.name != "." && item.name != "..")
file_list.push_back(item);
}
cache_dir.close();
// sort oldest first
std::sort(file_list.begin(), file_list.end(), [](auto left, auto right)
{
return left.mtime < right.mtime;
});
// keep removing until cache is empty or enough bytes have been cleared
// cache is cleared down to 80% of limit to increase interval between clears
const u64 to_remove = static_cast<u64>(size - max_size * 0.8);
u64 removed = 0;
for (const auto &item : file_list)
{
const std::string &name = cache_location + "/" + item.name;
const bool is_dir = fs::is_dir(name);
const u64 item_size = is_dir ? fs::get_dir_size(name) : item.size;
if (is_dir && item_size == umax)
{
sys_log.error("Failed to calculate '%s' item '%s' size (%s)", cache_location, item.name, fs::g_tls_error);
break;
}
if (is_dir ? !fs::remove_all(name, true) : !fs::remove_file(name))
{
sys_log.error("Could not remove cache directory '%s' item '%s' (%s)", cache_location, item.name, fs::g_tls_error);
break;
}
removed += item_size;
if (removed >= to_remove)
break;
}
sys_log.success("Cleaned disk cache, removed %.2f MB", size / 1024.0 / 1024.0);
}
}

7
rpcs3/Emu/cache_utils.hpp Normal file
View File

@ -0,0 +1,7 @@
#pragma once
namespace rpcs3::cache
{
std::string get_ppu_cache();
void limit_cache_size();
}

196
rpcs3/Emu/system_progress.cpp Normal file
View File

@ -0,0 +1,196 @@
#include "stdafx.h"
#include "system_progress.hpp"
#include "Emu/Cell/Modules/cellMsgDialog.h"
#include "Emu/RSX/RSXThread.h"
#include "Emu/RSX/Overlays/overlay_message_dialog.h"
#include "Emu/System.h"
// Progress display server synchronization variables
atomic_t<const char*> g_progr{nullptr};
atomic_t<u32> g_progr_ftotal{0};
atomic_t<u32> g_progr_fdone{0};
atomic_t<u32> g_progr_ptotal{0};
atomic_t<u32> g_progr_pdone{0};
namespace rsx::overlays
{
class progress_dialog : public message_dialog
{
public:
using message_dialog::message_dialog;
};
} // namespace rsx::overlays
void progress_dialog_server::operator()()
{
while (thread_ctrl::state() != thread_state::aborting)
{
// Wait for the start condition
auto text0 = +g_progr;
while (!text0)
{
if (thread_ctrl::state() == thread_state::aborting)
{
break;
}
std::this_thread::sleep_for(5ms);
text0 = +g_progr;
}
if (thread_ctrl::state() == thread_state::aborting)
{
break;
}
// Initialize message dialog
bool skip_this_one = false; // Workaround: do not open a progress dialog if there is already a cell message dialog open.
std::shared_ptr<MsgDialogBase> dlg;
std::shared_ptr<rsx::overlays::progress_dialog> native_dlg;
if (const auto renderer = rsx::get_current_renderer();
renderer && renderer->is_inited)
{
auto manager = g_fxo->try_get<rsx::overlays::display_manager>();
skip_this_one = g_fxo->get<progress_dialog_workaround>().skip_the_progress_dialog || (manager && manager->get<rsx::overlays::message_dialog>());
if (manager && !skip_this_one)
{
MsgDialogType type{};
type.se_normal = true;
type.bg_invisible = true;
type.disable_cancel = true;
type.progress_bar_count = 1;
native_dlg = manager->create<rsx::overlays::progress_dialog>(true);
native_dlg->show(false, text0, type, nullptr);
native_dlg->progress_bar_set_message(0, "Please wait");
}
}
if (!skip_this_one && !native_dlg)
{
dlg = Emu.GetCallbacks().get_msg_dialog();
dlg->type.se_normal = true;
dlg->type.bg_invisible = true;
dlg->type.progress_bar_count = 1;
dlg->on_close = [](s32 /*status*/) {
Emu.CallAfter([]() {
// Abort everything
Emu.Stop();
});
};
Emu.CallAfter([dlg, text0]() {
dlg->Create(text0, text0);
});
}
u32 ftotal = 0;
u32 fdone = 0;
u32 ptotal = 0;
u32 pdone = 0;
auto text1 = text0;
// Update progress
while (thread_ctrl::state() != thread_state::aborting)
{
const auto text_new = g_progr.load();
const u32 ftotal_new = g_progr_ftotal;
const u32 fdone_new = g_progr_fdone;
const u32 ptotal_new = g_progr_ptotal;
const u32 pdone_new = g_progr_pdone;
if (ftotal != ftotal_new || fdone != fdone_new || ptotal != ptotal_new || pdone != pdone_new || text_new != text1)
{
ftotal = ftotal_new;
fdone = fdone_new;
ptotal = ptotal_new;
pdone = pdone_new;
text1 = text_new;
if (!text_new)
{
// Close dialog
break;
}
if (skip_this_one)
{
// Do nothing
std::this_thread::sleep_for(10ms);
continue;
}
// Compute new progress in percents
// Assume not all programs were found if files were not compiled (as it may contain more)
const u64 total = std::max<u64>(ptotal, 1) * std::max<u64>(ftotal, 1);
const u64 done = pdone * std::max<u64>(fdone, 1);
const double value = std::fmin(done * 100. / total, 100.);
std::string progr = "Progress:";
if (ftotal)
fmt::append(progr, " file %u of %u%s", fdone, ftotal, ptotal ? "," : "");
if (ptotal)
fmt::append(progr, " module %u of %u", pdone, ptotal);
// Changes detected, send update
if (native_dlg)
{
native_dlg->set_text(text_new);
native_dlg->progress_bar_set_message(0, progr);
native_dlg->progress_bar_set_value(0, std::floor(value));
}
else if (dlg)
{
Emu.CallAfter([=]() {
dlg->SetMsg(text_new);
dlg->ProgressBarSetMsg(0, progr);
dlg->ProgressBarSetValue(0, std::floor(value));
});
}
}
std::this_thread::sleep_for(10ms);
}
if (thread_ctrl::state() == thread_state::aborting)
{
break;
}
if (skip_this_one)
{
// Do nothing
}
else if (native_dlg)
{
native_dlg->close(false, false);
}
else if (dlg)
{
Emu.CallAfter([=]() {
dlg->Close(true);
});
}
// Cleanup
g_progr_fdone -= fdone;
g_progr_pdone -= pdone;
g_progr_ftotal -= ftotal;
g_progr_ptotal -= ptotal;
g_progr_ptotal.notify_all();
}
}
progress_dialog_server::~progress_dialog_server()
{
g_progr_ftotal.release(0);
g_progr_fdone.release(0);
g_progr_ptotal.release(0);
g_progr_pdone.release(0);
g_progr.release(nullptr);
}

8
rpcs3/Emu/system_progress.hpp
View File

@ -30,3 +30,11 @@ public:
g_progr.release(m_prev);
}
};
struct progress_dialog_server
{
void operator()();
~progress_dialog_server();
static auto constexpr thread_name = "Progress Dialog Server"sv;
};

240
rpcs3/Emu/system_utils.cpp Normal file
View File

@ -0,0 +1,240 @@
#include "stdafx.h"
#include "system_utils.hpp"
#include "system_config.h"
#include "util/sysinfo.hpp"
#include "Utilities/File.h"
#include "Utilities/StrUtil.h"
#include "Utilities/Thread.h"
#include "Crypto/unpkg.h"
#include <charconv>
#include <thread>
#ifdef _WIN32
#include <windows.h>
#endif
LOG_CHANNEL(sys_log, "SYS");
namespace rpcs3::utils
{
u32 get_max_threads()
{
const u32 max_threads = static_cast<u32>(g_cfg.core.llvm_threads);
const u32 hw_threads = ::utils::get_thread_count();
const u32 thread_count = max_threads > 0 ? std::min(max_threads, hw_threads) : hw_threads;
return thread_count;
}
void configure_logs()
{
static bool was_silenced = false;
const bool silenced = g_cfg.misc.silence_all_logs.get();
if (silenced)
{
if (!was_silenced)
{
sys_log.notice("Disabling logging...");
}
logs::silence();
}
else
{
logs::reset();
logs::set_channel_levels(g_cfg.log.get_map());
if (was_silenced)
{
sys_log.notice("Logging enabled");
}
}
was_silenced = silenced;
}
u32 check_user(const std::string& user)
{
u32 id = 0;
if (user.size() == 8)
{
std::from_chars(&user.front(), &user.back() + 1, id);
}
return id;
}
bool install_pkg(const std::string& path)
{
sys_log.success("Installing package: %s", path);
atomic_t<double> progress(0.);
int int_progress = 0;
// Run PKG unpacking asynchronously
named_thread worker("PKG Installer", [&]
{
package_reader reader(path);
return reader.extract_data(progress);
});
// Wait for the completion
while (std::this_thread::sleep_for(5ms), worker <= thread_state::aborting)
{
// TODO: update unified progress dialog
double pval = progress;
pval < 0 ? pval += 1. : pval;
pval *= 100.;
if (static_cast<int>(pval) > int_progress)
{
int_progress = static_cast<int>(pval);
sys_log.success("... %u%%", int_progress);
}
}
return worker();
}
#ifdef _WIN32
std::string get_exe_dir()
{
wchar_t buffer[32767];
GetModuleFileNameW(nullptr, buffer, sizeof(buffer) / 2);
const std::string path_to_exe = wchar_to_utf8(buffer);
const usz last = path_to_exe.find_last_of('\\');
return last == std::string::npos ? std::string("") : path_to_exe.substr(0, last + 1);
}
#endif
std::string get_emu_dir()
{
const std::string& emu_dir_ = g_cfg.vfs.emulator_dir;
return emu_dir_.empty() ? fs::get_config_dir() : emu_dir_;
}
std::string get_hdd0_dir()
{
return g_cfg.vfs.get(g_cfg.vfs.dev_hdd0, get_emu_dir());
}
std::string get_hdd1_dir()
{
return g_cfg.vfs.get(g_cfg.vfs.dev_hdd1, get_emu_dir());
}
std::string get_cache_dir()
{
return fs::get_cache_dir() + "cache/";
}
std::string get_rap_file_path(const std::string& rap)
{
const std::string home_dir = get_hdd0_dir() + "/home";
for (auto&& entry : fs::dir(home_dir))
{
if (entry.is_directory && check_user(entry.name))
{
std::string rap_path = fmt::format("%s/%s/exdata/%s.rap", home_dir, entry.name, rap);
if (fs::is_file(rap_path))
{
return rap_path;
}
}
}
return {};
}
std::string get_sfo_dir_from_game_path(const std::string& game_path, const std::string& title_id)
{
if (fs::is_file(game_path + "/PS3_DISC.SFB"))
{
// This is a disc game.
if (!title_id.empty())
{
for (auto&& entry : fs::dir{game_path})
{
if (entry.name == "." || entry.name == "..")
{
continue;
}
const std::string sfo_path = game_path + "/" + entry.name + "/PARAM.SFO";
if (entry.is_directory && fs::is_file(sfo_path))
{
const auto psf = psf::load_object(fs::file(sfo_path));
const auto serial = psf::get_string(psf, "TITLE_ID");
if (serial == title_id)
{
return game_path + "/" + entry.name;
}
}
}
}
return game_path + "/PS3_GAME";
}
const auto psf = psf::load_object(fs::file(game_path + "/PARAM.SFO"));
const auto category = psf::get_string(psf, "CATEGORY");
const auto content_id = std::string(psf::get_string(psf, "CONTENT_ID"));
if (category == "HG" && !content_id.empty())
{
// This is a trial game. Check if the user has a RAP file to unlock it.
if (fs::is_file(game_path + "/C00/PARAM.SFO") && fs::is_file(get_rap_file_path(content_id)))
{
// Load full game data.
sys_log.notice("Found RAP file %s.rap for trial game %s", content_id, title_id);
return game_path + "/C00";
}
}
return game_path;
}
std::string get_custom_config_dir()
{
#ifdef _WIN32
return fs::get_config_dir() + "config/custom_configs/";
#else
return fs::get_config_dir() + "custom_configs/";
#endif
}
std::string get_custom_config_path(const std::string& title_id, bool get_deprecated_path)
{
std::string path;
if (get_deprecated_path)
path = fs::get_config_dir() + "data/" + title_id + "/config.yml";
else
path = get_custom_config_dir() + "config_" + title_id + ".yml";
return path;
}
std::string get_custom_input_config_dir(const std::string& title_id)
{
// Notice: the extra folder for each title id may be removed at a later stage
// Warning: make sure to change any function that removes this directory as well
#ifdef _WIN32
return fs::get_config_dir() + "config/custom_input_configs/" + title_id + "/";
#else
return fs::get_config_dir() + "custom_input_configs/" + title_id + "/";
#endif
}
std::string get_custom_input_config_path(const std::string& title_id)
{
return get_custom_input_config_dir(title_id) + "/config_input_" + title_id + ".yml";
}
}

32
rpcs3/Emu/system_utils.hpp Normal file
View File

@ -0,0 +1,32 @@
#pragma once
#include "util/types.hpp"
#include <string>
namespace rpcs3::utils
{
u32 get_max_threads();
void configure_logs();
u32 check_user(const std::string& user);
bool install_pkg(const std::string& path);
#ifdef _WIN32
std::string get_exe_dir();
#endif
std::string get_emu_dir();
std::string get_hdd0_dir();
std::string get_hdd1_dir();
std::string get_cache_dir();
std::string get_rap_file_path(const std::string& rap);
std::string get_sfo_dir_from_game_path(const std::string& game_path, const std::string& title_id = "");
std::string get_custom_config_dir();
std::string get_custom_config_path(const std::string& title_id, bool get_deprecated_path = false);
std::string get_custom_input_config_dir(const std::string& title_id);
std::string get_custom_input_config_path(const std::string& title_id);
}

6
rpcs3/emucore.vcxproj
View File

@ -59,6 +59,7 @@
<ClCompile Include="Emu\Audio\Pulse\PulseBackend.cpp">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Emu\cache_utils.cpp" />
<ClCompile Include="Emu\Cell\Modules\sys_crashdump.cpp" />
<ClCompile Include="Emu\Io\Turntable.cpp" />
<ClCompile Include="Emu\Io\GHLtar.cpp" />
@ -79,6 +80,8 @@
<ClCompile Include="Emu\RSX\RSXDisAsm.cpp" />
<ClCompile Include="Emu\system_config_types.cpp" />
<ClCompile Include="Emu\perf_meter.cpp" />
<ClCompile Include="Emu\system_progress.cpp" />
<ClCompile Include="Emu\system_utils.cpp" />
<ClCompile Include="Emu\title.cpp" />
<ClCompile Include="Emu\system_config.cpp" />
<ClCompile Include="Emu\NP\fb_helpers.cpp" />
@ -431,6 +434,7 @@
<ClInclude Include="Emu\Audio\Pulse\PulseBackend.h">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Emu\cache_utils.hpp" />
<ClInclude Include="Emu\Cell\lv2\sys_crypto_engine.h" />
<ClInclude Include="Emu\Cell\Modules\cellCrossController.h" />
<ClInclude Include="Emu\Cell\Modules\cellRemotePlay.h" />
@ -471,6 +475,8 @@
<ClInclude Include="Emu\RSX\Overlays\Shaders\shader_loading_dialog.h" />
<ClInclude Include="Emu\RSX\Overlays\Shaders\shader_loading_dialog_native.h" />
<ClInclude Include="Emu\RSX\RSXDisAsm.h" />
<ClInclude Include="Emu\system_progress.hpp" />
<ClInclude Include="Emu\system_utils.hpp" />
<ClInclude Include="Emu\title.h" />
<ClInclude Include="Emu\system_config.h" />
<ClInclude Include="Emu\system_config_types.h" />

18
rpcs3/emucore.vcxproj.filters
View File

@ -992,6 +992,15 @@
<ClCompile Include="Emu\RSX\Overlays\overlay_user_list_dialog.cpp">
<Filter>Emu\GPU\RSX\Overlays</Filter>
</ClCompile>
<ClCompile Include="Emu\system_utils.cpp">
<Filter>Emu</Filter>
</ClCompile>
<ClCompile Include="Emu\cache_utils.cpp">
<Filter>Emu</Filter>
</ClCompile>
<ClCompile Include="Emu\system_progress.cpp">
<Filter>Emu</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Crypto\aes.h">
@ -1939,6 +1948,15 @@
<ClInclude Include="Emu\RSX\Overlays\overlay_user_list_dialog.h">
<Filter>Emu\GPU\RSX\Overlays</Filter>
</ClInclude>
<ClInclude Include="Emu\system_utils.hpp">
<Filter>Emu</Filter>
</ClInclude>
<ClInclude Include="Emu\cache_utils.hpp">
<Filter>Emu</Filter>
</ClInclude>
<ClInclude Include="Emu\system_progress.hpp">
<Filter>Emu</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="Emu\RSX\Common\Interpreter\FragmentInterpreter.glsl">

3
rpcs3/main.cpp
View File

@ -51,6 +51,7 @@ DYNAMIC_IMPORT("ntdll.dll", NtSetTimerResolution, NTSTATUS(ULONG DesiredResoluti
#include "Utilities/StrUtil.h"
#include "rpcs3_version.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include <thread>
#include <charconv>
@ -743,7 +744,7 @@ int main(int argc, char** argv)
{
active_user = parser.value(arg_user_id).toStdString();
if (Emulator::CheckUsr(active_user) == 0)
if (rpcs3::utils::check_user(active_user) == 0)
{
report_fatal_error(fmt::format("Failed to set user ID '%s'.\nThe user ID must consist of 8 digits and cannot be 00000000.", active_user));
}

4
rpcs3/rpcs3qt/curl_handle.cpp
View File

@ -1,5 +1,5 @@
#include "curl_handle.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#ifdef _WIN32
#include "Utilities/StrUtil.h"
@ -11,7 +11,7 @@ curl_handle::curl_handle(QObject* parent) : QObject(parent)
#ifdef _WIN32
// This shouldn't be needed on linux
const std::string path_to_cert = Emulator::GetExeDir() + "cacert.pem";
const std::string path_to_cert = rpcs3::utils::get_exe_dir() + "cacert.pem";
const std::string ansi_path = utf8_path_to_ansi_path(path_to_cert);
curl_easy_setopt(m_curl, CURLOPT_CAINFO, ansi_path.data());

9
rpcs3/rpcs3qt/emu_settings.cpp
View File

@ -8,6 +8,7 @@
#include "Emu/System.h"
#include "Emu/system_config.h"
#include "Emu/system_utils.hpp"
#include "Emu/Cell/Modules/cellSysutil.h"
#include "util/yaml.hpp"
@ -98,7 +99,7 @@ void emu_settings::LoadSettings(const std::string& title_id)
m_title_id = title_id;
// Create config path if necessary
fs::create_path(title_id.empty() ? fs::get_config_dir() : Emulator::GetCustomConfigDir());
fs::create_path(title_id.empty() ? fs::get_config_dir() : rpcs3::utils::get_custom_config_dir());
// Load default config
auto [default_config, default_error] = yaml_load(g_cfg_defaults);
@ -139,8 +140,8 @@ void emu_settings::LoadSettings(const std::string& title_id)
// Otherwise we'll always trigger the "obsolete settings dialog" when editing custom configs.
ValidateSettings(true);
const std::string config_path_new = Emulator::GetCustomConfigPath(m_title_id);
const std::string config_path_old = Emulator::GetCustomConfigPath(m_title_id, true);
const std::string config_path_new = rpcs3::utils::get_custom_config_path(m_title_id);
const std::string config_path_old = rpcs3::utils::get_custom_config_path(m_title_id, true);
std::string custom_config_path;
if (fs::is_file(config_path_new))
@ -274,7 +275,7 @@ void emu_settings::SaveSettings() const
}
else
{
config_name = Emulator::GetCustomConfigPath(m_title_id);
config_name = rpcs3::utils::get_custom_config_path(m_title_id);
}
// Save config atomically

21
rpcs3/rpcs3qt/game_list_frame.cpp
View File

@ -16,6 +16,7 @@
#include "Emu/Memory/vm.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Loader/PSF.h"
#include "util/types.hpp"
#include "Utilities/lockless.h"
@ -394,7 +395,7 @@ QString game_list_frame::GetLastPlayedBySerial(const QString& serial) const
std::string game_list_frame::GetCacheDirBySerial(const std::string& serial)
{
return Emulator::GetCacheDir() + serial;
return rpcs3::utils::get_cache_dir() + serial;
}
std::string game_list_frame::GetDataDirBySerial(const std::string& serial)
@ -413,7 +414,7 @@ void game_list_frame::Refresh(const bool from_drive, const bool scroll_after)
m_game_data.clear();
m_notes.clear();
const std::string _hdd = Emulator::GetHddDir();
const std::string _hdd = rpcs3::utils::get_hdd0_dir();
const std::string cat_unknown = sstr(cat::cat_unknown);
const std::string cat_unknown_localized = sstr(localized.category.unknown);
@ -542,7 +543,7 @@ void game_list_frame::Refresh(const bool from_drive, const bool scroll_after)
const Localized thread_localized;
{
const std::string sfo_dir = Emulator::GetSfoDirFromGamePath(dir);
const std::string sfo_dir = rpcs3::utils::get_sfo_dir_from_game_path(dir);
const psf::registry psf = psf::load_object(fs::file(sfo_dir + "/PARAM.SFO"));
@ -654,8 +655,8 @@ void game_list_frame::Refresh(const bool from_drive, const bool scroll_after)
const auto compat = m_game_compat->GetCompatibility(game.serial);
const bool hasCustomConfig = fs::is_file(Emulator::GetCustomConfigPath(game.serial)) || fs::is_file(Emulator::GetCustomConfigPath(game.serial, true));
const bool hasCustomPadConfig = fs::is_file(Emulator::GetCustomInputConfigPath(game.serial));
const bool hasCustomConfig = fs::is_file(rpcs3::utils::get_custom_config_path(game.serial)) || fs::is_file(rpcs3::utils::get_custom_config_path(game.serial, true));
const bool hasCustomPadConfig = fs::is_file(rpcs3::utils::get_custom_input_config_path(game.serial));
const bool has_hover_gif = fs::is_file(game_icon_path + game.serial + "/hover.gif");
const QColor color = getGridCompatibilityColor(compat.color);
@ -970,12 +971,12 @@ void game_list_frame::ShowContextMenu(const QPoint &pos)
QAction* open_config_dir = menu.addAction(tr("&Open Custom Config Folder"));
connect(open_config_dir, &QAction::triggered, [current_game]()
{
const std::string new_config_path = Emulator::GetCustomConfigPath(current_game.serial);
const std::string new_config_path = rpcs3::utils::get_custom_config_path(current_game.serial);
if (fs::is_file(new_config_path))
gui::utils::open_dir(new_config_path);
const std::string old_config_path = Emulator::GetCustomConfigPath(current_game.serial, true);
const std::string old_config_path = rpcs3::utils::get_custom_config_path(current_game.serial, true);
if (fs::is_file(old_config_path))
gui::utils::open_dir(old_config_path);
@ -1346,8 +1347,8 @@ bool game_list_frame::CreatePPUCache(const game_info& game)
bool game_list_frame::RemoveCustomConfiguration(const std::string& title_id, const game_info& game, bool is_interactive)
{
const std::string config_path_new = Emulator::GetCustomConfigPath(title_id);
const std::string config_path_old = Emulator::GetCustomConfigPath(title_id, true);
const std::string config_path_new = rpcs3::utils::get_custom_config_path(title_id);
const std::string config_path_old = rpcs3::utils::get_custom_config_path(title_id, true);
if (!fs::is_file(config_path_new) && !fs::is_file(config_path_old))
return true;
@ -1388,7 +1389,7 @@ bool game_list_frame::RemoveCustomConfiguration(const std::string& title_id, con
bool game_list_frame::RemoveCustomPadConfiguration(const std::string& title_id, const game_info& game, bool is_interactive)
{
const std::string config_dir = Emulator::GetCustomInputConfigDir(title_id);
const std::string config_dir = rpcs3::utils::get_custom_input_config_dir(title_id);
if (!fs::is_dir(config_dir))
return true;

3
rpcs3/rpcs3qt/gui_application.cpp
View File

@ -17,6 +17,7 @@
#include "Emu/Cell/Modules/cellAudio.h"
#include "Emu/RSX/Overlays/overlay_perf_metrics.h"
#include "Emu/system_utils.hpp"
#include "trophy_notification_helper.h"
#include "save_data_dialog.h"
#include "msg_dialog_frame.h"
@ -557,7 +558,7 @@ void gui_application::OnEmuSettingsChange()
}
}
Emulator::ConfigureLogs();
rpcs3::utils::configure_logs();
audio::configure_audio();
rsx::overlays::reset_performance_overlay();
}

7
rpcs3/rpcs3qt/main_window.cpp
View File

@ -43,6 +43,7 @@
#include "Emu/IdManager.h"
#include "Emu/VFS.h"
#include "Emu/system_config.h"
#include "Emu/system_utils.hpp"
#include "Crypto/unpkg.h"
#include "Crypto/unself.h"
@ -518,7 +519,7 @@ bool main_window::InstallRapFile(const QString& path, const std::string& filenam
// Copy file atomically with thread/process-safe error checking for file size
fs::pending_file to(Emulator::GetHddDir() + "/home/" + Emu.GetUsr() + "/exdata/" + filename.substr(0, filename.find_last_of('.')) + ".rap");
fs::pending_file to(rpcs3::utils::get_hdd0_dir() + "/home/" + Emu.GetUsr() + "/exdata/" + filename.substr(0, filename.find_last_of('.')) + ".rap");
const fs::file from(sstr(path));
if (!to.file || !from)
@ -2573,7 +2574,7 @@ void main_window::SetIconSizeActions(int idx) const
void main_window::RemoveDiskCache()
{
const std::string cache_dir = Emulator::GetHdd1Dir() + "/caches";
const std::string cache_dir = rpcs3::utils::get_hdd1_dir() + "/caches";
if (fs::is_dir(cache_dir) && fs::remove_all(cache_dir, false))
{
@ -2587,7 +2588,7 @@ void main_window::RemoveDiskCache()
void main_window::RemoveFirmwareCache()
{
const std::string cache_dir = Emulator::GetCacheDir();
const std::string cache_dir = rpcs3::utils::get_cache_dir();
if (!fs::is_dir(cache_dir))
return;

4
rpcs3/rpcs3qt/persistent_settings.cpp
View File

@ -1,7 +1,7 @@
#include "persistent_settings.h"
#include "util/logs.hpp"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
LOG_CHANNEL(cfg_log, "CFG");
@ -49,7 +49,7 @@ QString persistent_settings::GetCurrentUser(const QString& fallback) const
}
// Set user if valid
if (Emulator::CheckUsr(user.toStdString()) > 0)
if (rpcs3::utils::check_user(user.toStdString()) > 0)
{
return user;
}

4
rpcs3/rpcs3qt/qt_utils.cpp
View File

@ -8,7 +8,7 @@
#include <QScreen>
#include <QUrl>
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Utilities/File.h"
inline std::string sstr(const QString& _in) { return _in.toStdString(); }
@ -260,7 +260,7 @@ namespace gui
continue;
}
const std::string sfo_dir = Emulator::GetSfoDirFromGamePath(pth, title_id);
const std::string sfo_dir = rpcs3::utils::get_sfo_dir_from_game_path(pth, title_id);
icon_path = sfo_dir + "/ICON0.PNG";
found_file = fs::is_file(icon_path);

3
rpcs3/rpcs3qt/save_manager_dialog.cpp
View File

@ -6,6 +6,7 @@
#include "persistent_settings.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Loader/PSF.h"
#include <QtConcurrent>
@ -236,7 +237,7 @@ void save_manager_dialog::UpdateList()
{
if (m_dir.empty())
{
m_dir = Emulator::GetHddDir() + "home/" + Emu.GetUsr() + "/savedata/";
m_dir = rpcs3::utils::get_hdd0_dir() + "home/" + Emu.GetUsr() + "/savedata/";
}
m_save_entries = GetSaveEntries(m_dir);

4
rpcs3/rpcs3qt/screenshot_manager_dialog.cpp
View File

@ -3,7 +3,7 @@
#include "qt_utils.h"
#include "Utilities/File.h"
#include "Emu/VFS.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include <QApplication>
#include <QDir>
@ -29,7 +29,7 @@ screenshot_manager_dialog::screenshot_manager_dialog(QWidget* parent) : QDialog(
m_grid->setGridSize(m_icon_size + QSize(10, 10));
// HACK: dev_hdd0 must be mounted for vfs to work for loading trophies.
vfs::mount("/dev_hdd0", Emulator::GetHddDir());
vfs::mount("/dev_hdd0", rpcs3::utils::get_hdd0_dir());
const std::string screenshot_path_qt = fs::get_config_dir() + "screenshots/";
const std::string screenshot_path_cell = vfs::get("/dev_hdd0/photo/");

3
rpcs3/rpcs3qt/trophy_manager_dialog.cpp
View File

@ -10,6 +10,7 @@
#include "Utilities/File.h"
#include "Emu/VFS.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Emu/Cell/Modules/sceNpTrophy.h"
#include "Loader/TROPUSR.h"
@ -60,7 +61,7 @@ trophy_manager_dialog::trophy_manager_dialog(std::shared_ptr<gui_settings> gui_s
m_show_platinum_trophies = m_gui_settings->GetValue(gui::tr_show_platinum).toBool();
// HACK: dev_hdd0 must be mounted for vfs to work for loading trophies.
vfs::mount("/dev_hdd0", Emulator::GetHddDir());
vfs::mount("/dev_hdd0", rpcs3::utils::get_hdd0_dir());
// Get the currently selected user's trophy path.
m_trophy_dir = "/dev_hdd0/home/" + Emu.GetUsr() + "/trophy/";

7
rpcs3/rpcs3qt/update_manager.cpp
View File

@ -6,6 +6,7 @@
#include "Utilities/StrUtil.h"
#include "Utilities/File.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "util/logs.hpp"
#include <QApplication>
@ -284,7 +285,7 @@ bool update_manager::handle_rpcs3(const QByteArray& data)
#ifdef _WIN32
// Get executable path
const std::string orig_path = Emulator::GetExeDir() + "rpcs3.exe";
const std::string orig_path = rpcs3::utils::get_exe_dir() + "rpcs3.exe";
std::wstring wchar_orig_path;
const auto tmp_size = MultiByteToWideChar(CP_UTF8, 0, orig_path.c_str(), -1, nullptr, 0);
@ -390,7 +391,7 @@ bool update_manager::handle_rpcs3(const QByteArray& data)
usz outBufferSize = 0;
// Creates temp folder for moving active files
const std::string tmp_folder = Emulator::GetEmuDir() + "rpcs3_old/";
const std::string tmp_folder = rpcs3::utils::get_emu_dir() + "rpcs3_old/";
fs::create_dir(tmp_folder);
for (UInt32 i = 0; i < db.NumFiles; i++)
@ -423,7 +424,7 @@ bool update_manager::handle_rpcs3(const QByteArray& data)
temp_u8[index] = static_cast<u8>(temp_u16[index]);
}
temp_u8[len] = 0;
const std::string name = Emulator::GetEmuDir() + std::string(reinterpret_cast<char*>(temp_u8));
const std::string name = rpcs3::utils::get_emu_dir() + std::string(reinterpret_cast<char*>(temp_u8));
if (!isDir)
{

6
rpcs3/rpcs3qt/user_account.cpp
View File

@ -1,6 +1,6 @@
#include "user_account.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Utilities/File.h"
#include "util/logs.hpp"
@ -12,7 +12,7 @@ user_account::user_account(const std::string& user_id)
m_user_id = user_id;
// Setting userDir.
m_user_dir = Emulator::GetHddDir() + "home/" + m_user_id + "/";
m_user_dir = rpcs3::utils::get_hdd0_dir() + "home/" + m_user_id + "/";
// Setting userName.
if (fs::file file; file.open(m_user_dir + "localusername", fs::read))
@ -46,7 +46,7 @@ std::map<u32, user_account> user_account::GetUserAccounts(const std::string& bas
}
// Is the folder name exactly 8 all-numerical characters long?
const u32 key = Emulator::CheckUsr(user_folder.name);
const u32 key = rpcs3::utils::check_user(user_folder.name);
if (key == 0)
{

11
rpcs3/rpcs3qt/user_manager_dialog.cpp
View File

@ -19,6 +19,7 @@
#include "persistent_settings.h"
#include "Emu/System.h"
#include "Emu/system_utils.hpp"
#include "Utilities/StrUtil.h"
#include "Utilities/File.h"
@ -167,7 +168,7 @@ void user_manager_dialog::UpdateTable(bool mark_only)
// Get the user folders in the home directory and the currently logged in user.
m_user_list.clear();
m_user_list = user_account::GetUserAccounts(Emulator::GetHddDir() + "home");
m_user_list = user_account::GetUserAccounts(rpcs3::utils::get_hdd0_dir() + "home");
// Clear and then repopulate the table with the list gathered above.
m_table->setRowCount(static_cast<int>(m_user_list.size()));
@ -232,10 +233,10 @@ void user_manager_dialog::OnUserRemove()
void user_manager_dialog::GenerateUser(const std::string& user_id, const std::string& username)
{
ensure(Emulator::CheckUsr(user_id) > 0);
ensure(rpcs3::utils::check_user(user_id) > 0);
// Create user folders and such.
const std::string home_dir = Emulator::GetHddDir() + "home/";
const std::string home_dir = rpcs3::utils::get_hdd0_dir() + "home/";
const std::string user_dir = home_dir + user_id;
fs::create_dir(home_dir);
fs::create_dir(user_dir + "/");
@ -285,7 +286,7 @@ void user_manager_dialog::OnUserRename()
continue;
}
const std::string username_file = Emulator::GetHddDir() + "home/" + user_id + "/localusername";
const std::string username_file = rpcs3::utils::get_hdd0_dir() + "home/" + user_id + "/localusername";
const std::string new_username = text_to_validate.toStdString();
if (fs::write_file(username_file, fs::rewrite, new_username))
@ -324,7 +325,7 @@ void user_manager_dialog::OnUserCreate()
}
const std::string next_user_id = fmt::format("%08d", smallest);
ensure(Emulator::CheckUsr(next_user_id) > 0);
ensure(rpcs3::utils::check_user(next_user_id) > 0);
QInputDialog* dialog = new QInputDialog(this);
dialog->setWindowTitle(tr("New User"));