From 0f9288e38d80c6c63a545934557501fae40d3d83 Mon Sep 17 00:00:00 2001 From: FearlessTobi Date: Tue, 16 Jan 2024 06:23:01 +0100 Subject: vfs: Move vfs files to their own directory --- src/core/CMakeLists.txt | 111 +++-- src/core/core.cpp | 4 +- src/core/core.h | 2 +- src/core/crypto/aes_util.h | 2 +- src/core/crypto/encryption_layer.h | 2 +- src/core/crypto/partition_data_manager.cpp | 6 +- src/core/crypto/partition_data_manager.h | 2 +- src/core/file_sys/bis_factory.cpp | 2 +- src/core/file_sys/bis_factory.h | 2 +- src/core/file_sys/card_image.cpp | 4 +- src/core/file_sys/card_image.h | 2 +- src/core/file_sys/content_archive.cpp | 2 +- src/core/file_sys/content_archive.h | 2 +- src/core/file_sys/control_metadata.cpp | 2 +- src/core/file_sys/control_metadata.h | 2 +- src/core/file_sys/fsmitm_romfsbuild.cpp | 4 +- src/core/file_sys/fsmitm_romfsbuild.h | 2 +- src/core/file_sys/fssystem/fs_i_storage.h | 2 +- .../fssystem_aes_ctr_counter_extended_storage.cpp | 2 +- .../file_sys/fssystem/fssystem_aes_ctr_storage.h | 2 +- src/core/file_sys/fssystem/fssystem_bucket_tree.h | 2 +- .../fssystem/fssystem_compressed_storage.h | 2 +- ...hierarchical_integrity_verification_storage.cpp | 2 +- ...m_hierarchical_integrity_verification_storage.h | 2 +- .../fssystem_hierarchical_sha256_storage.h | 2 +- .../file_sys/fssystem/fssystem_indirect_storage.h | 4 +- .../fssystem/fssystem_integrity_romfs_storage.h | 2 +- .../fssystem/fssystem_nca_file_system_driver.cpp | 4 +- .../fssystem/fssystem_nca_file_system_driver.h | 2 +- src/core/file_sys/fssystem/fssystem_nca_reader.cpp | 2 +- src/core/file_sys/ips_layer.cpp | 2 +- src/core/file_sys/ips_layer.h | 2 +- src/core/file_sys/kernel_executable.cpp | 2 +- src/core/file_sys/kernel_executable.h | 2 +- src/core/file_sys/nca_metadata.cpp | 2 +- src/core/file_sys/nca_metadata.h | 2 +- src/core/file_sys/partition_filesystem.cpp | 2 +- src/core/file_sys/partition_filesystem.h | 2 +- src/core/file_sys/patch_manager.cpp | 6 +- src/core/file_sys/patch_manager.h | 2 +- src/core/file_sys/program_metadata.cpp | 2 +- src/core/file_sys/program_metadata.h | 2 +- src/core/file_sys/registered_cache.cpp | 2 +- src/core/file_sys/registered_cache.h | 2 +- src/core/file_sys/romfs.cpp | 10 +- src/core/file_sys/romfs.h | 2 +- src/core/file_sys/romfs_factory.h | 2 +- src/core/file_sys/savedata_factory.cpp | 2 +- src/core/file_sys/savedata_factory.h | 2 +- src/core/file_sys/sdmc_factory.cpp | 2 +- src/core/file_sys/sdmc_factory.h | 2 +- src/core/file_sys/submission_package.h | 2 +- src/core/file_sys/system_archive/mii_model.cpp | 2 +- src/core/file_sys/system_archive/mii_model.h | 2 +- src/core/file_sys/system_archive/ng_word.cpp | 2 +- src/core/file_sys/system_archive/ng_word.h | 2 +- src/core/file_sys/system_archive/shared_font.cpp | 2 +- src/core/file_sys/system_archive/shared_font.h | 2 +- src/core/file_sys/system_archive/system_archive.h | 2 +- .../file_sys/system_archive/system_version.cpp | 2 +- src/core/file_sys/system_archive/system_version.h | 2 +- .../file_sys/system_archive/time_zone_binary.cpp | 2 +- .../file_sys/system_archive/time_zone_binary.h | 2 +- src/core/file_sys/vfs.cpp | 552 --------------------- src/core/file_sys/vfs.h | 327 ------------ src/core/file_sys/vfs/vfs.cpp | 552 +++++++++++++++++++++ src/core/file_sys/vfs/vfs.h | 327 ++++++++++++ src/core/file_sys/vfs/vfs_cached.cpp | 63 +++ src/core/file_sys/vfs/vfs_cached.h | 31 ++ src/core/file_sys/vfs/vfs_concat.cpp | 192 +++++++ src/core/file_sys/vfs/vfs_concat.h | 57 +++ src/core/file_sys/vfs/vfs_layered.cpp | 132 +++++ src/core/file_sys/vfs/vfs_layered.h | 46 ++ src/core/file_sys/vfs/vfs_offset.cpp | 98 ++++ src/core/file_sys/vfs/vfs_offset.h | 50 ++ src/core/file_sys/vfs/vfs_real.cpp | 528 ++++++++++++++++++++ src/core/file_sys/vfs/vfs_real.h | 145 ++++++ src/core/file_sys/vfs/vfs_static.h | 80 +++ src/core/file_sys/vfs/vfs_types.h | 29 ++ src/core/file_sys/vfs/vfs_vector.cpp | 133 +++++ src/core/file_sys/vfs/vfs_vector.h | 131 +++++ src/core/file_sys/vfs_cached.cpp | 63 --- src/core/file_sys/vfs_cached.h | 31 -- src/core/file_sys/vfs_concat.cpp | 192 ------- src/core/file_sys/vfs_concat.h | 57 --- src/core/file_sys/vfs_layered.cpp | 132 ----- src/core/file_sys/vfs_layered.h | 46 -- src/core/file_sys/vfs_offset.cpp | 98 ---- src/core/file_sys/vfs_offset.h | 50 -- src/core/file_sys/vfs_real.cpp | 528 -------------------- src/core/file_sys/vfs_real.h | 145 ------ src/core/file_sys/vfs_static.h | 80 --- src/core/file_sys/vfs_types.h | 29 -- src/core/file_sys/vfs_vector.cpp | 133 ----- src/core/file_sys/vfs_vector.h | 131 ----- src/core/file_sys/xts_archive.cpp | 2 +- src/core/file_sys/xts_archive.h | 2 +- .../hle/service/am/applets/applet_web_browser.cpp | 2 +- .../hle/service/am/applets/applet_web_browser.h | 2 +- src/core/hle/service/bcat/backend/backend.h | 2 +- src/core/hle/service/bcat/bcat_module.cpp | 2 +- src/core/hle/service/filesystem/filesystem.cpp | 4 +- src/core/hle/service/filesystem/filesystem.h | 2 +- .../hle/service/filesystem/fsp/fs_i_directory.h | 2 +- .../hle/service/filesystem/fsp/fs_i_filesystem.h | 2 +- src/core/hle/service/filesystem/fsp/fs_i_storage.h | 2 +- src/core/hle/service/filesystem/fsp/fsp_srv.cpp | 2 +- src/core/hle/service/filesystem/romfs_controller.h | 2 +- .../hle/service/filesystem/save_data_controller.h | 2 +- src/core/hle/service/ns/ns.cpp | 2 +- src/core/loader/loader.h | 2 +- src/core/loader/nro.cpp | 2 +- 112 files changed, 2754 insertions(+), 2731 deletions(-) delete mode 100644 src/core/file_sys/vfs.cpp delete mode 100644 src/core/file_sys/vfs.h create mode 100644 src/core/file_sys/vfs/vfs.cpp create mode 100644 src/core/file_sys/vfs/vfs.h create mode 100644 src/core/file_sys/vfs/vfs_cached.cpp create mode 100644 src/core/file_sys/vfs/vfs_cached.h create mode 100644 src/core/file_sys/vfs/vfs_concat.cpp create mode 100644 src/core/file_sys/vfs/vfs_concat.h create mode 100644 src/core/file_sys/vfs/vfs_layered.cpp create mode 100644 src/core/file_sys/vfs/vfs_layered.h create mode 100644 src/core/file_sys/vfs/vfs_offset.cpp create mode 100644 src/core/file_sys/vfs/vfs_offset.h create mode 100644 src/core/file_sys/vfs/vfs_real.cpp create mode 100644 src/core/file_sys/vfs/vfs_real.h create mode 100644 src/core/file_sys/vfs/vfs_static.h create mode 100644 src/core/file_sys/vfs/vfs_types.h create mode 100644 src/core/file_sys/vfs/vfs_vector.cpp create mode 100644 src/core/file_sys/vfs/vfs_vector.h delete mode 100644 src/core/file_sys/vfs_cached.cpp delete mode 100644 src/core/file_sys/vfs_cached.h delete mode 100644 src/core/file_sys/vfs_concat.cpp delete mode 100644 src/core/file_sys/vfs_concat.h delete mode 100644 src/core/file_sys/vfs_layered.cpp delete mode 100644 src/core/file_sys/vfs_layered.h delete mode 100644 src/core/file_sys/vfs_offset.cpp delete mode 100644 src/core/file_sys/vfs_offset.h delete mode 100644 src/core/file_sys/vfs_real.cpp delete mode 100644 src/core/file_sys/vfs_real.h delete mode 100644 src/core/file_sys/vfs_static.h delete mode 100644 src/core/file_sys/vfs_types.h delete mode 100644 src/core/file_sys/vfs_vector.cpp delete mode 100644 src/core/file_sys/vfs_vector.h (limited to 'src/core') diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 68c430a65..d71c2cead 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -20,28 +20,49 @@ add_library(core STATIC cpu_manager.h crypto/aes_util.cpp crypto/aes_util.h + crypto/ctr_encryption_layer.cpp + crypto/ctr_encryption_layer.h crypto/encryption_layer.cpp crypto/encryption_layer.h crypto/key_manager.cpp crypto/key_manager.h crypto/partition_data_manager.cpp crypto/partition_data_manager.h - crypto/ctr_encryption_layer.cpp - crypto/ctr_encryption_layer.h crypto/xts_encryption_layer.cpp crypto/xts_encryption_layer.h - debugger/debugger_interface.h debugger/debugger.cpp debugger/debugger.h - debugger/gdbstub_arch.cpp - debugger/gdbstub_arch.h + debugger/debugger_interface.h debugger/gdbstub.cpp debugger/gdbstub.h + debugger/gdbstub_arch.cpp + debugger/gdbstub_arch.h device_memory_manager.h device_memory_manager.inc device_memory.cpp device_memory.h + file_sys/bis_factory.cpp + file_sys/bis_factory.h + file_sys/card_image.cpp + file_sys/card_image.h + file_sys/common_funcs.h + file_sys/content_archive.cpp + file_sys/content_archive.h + file_sys/control_metadata.cpp + file_sys/control_metadata.h + file_sys/errors.h + file_sys/fs_directory.h + file_sys/fs_file.h + file_sys/fs_filesystem.h + file_sys/fs_memory_management.h + file_sys/fs_operate_range.h + file_sys/fs_path.h + file_sys/fs_path_utility.h + file_sys/fs_util_character_encoding.h + file_sys/fsmitm_romfsbuild.cpp + file_sys/fsmitm_romfsbuild.h file_sys/fssystem/fs_i_storage.h + file_sys/fssystem/fs_types.h file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h file_sys/fssystem/fssystem_aes_ctr_storage.cpp @@ -146,22 +167,22 @@ add_library(core STATIC file_sys/system_archive/system_version.h file_sys/system_archive/time_zone_binary.cpp file_sys/system_archive/time_zone_binary.h - file_sys/vfs.cpp - file_sys/vfs.h - file_sys/vfs_cached.cpp - file_sys/vfs_cached.h - file_sys/vfs_concat.cpp - file_sys/vfs_concat.h - file_sys/vfs_layered.cpp - file_sys/vfs_layered.h - file_sys/vfs_offset.cpp - file_sys/vfs_offset.h - file_sys/vfs_real.cpp - file_sys/vfs_real.h - file_sys/vfs_static.h - file_sys/vfs_types.h - file_sys/vfs_vector.cpp - file_sys/vfs_vector.h + file_sys/vfs/vfs.cpp + file_sys/vfs/vfs.h + file_sys/vfs/vfs_cached.cpp + file_sys/vfs/vfs_cached.h + file_sys/vfs/vfs_concat.cpp + file_sys/vfs/vfs_concat.h + file_sys/vfs/vfs_layered.cpp + file_sys/vfs/vfs_layered.h + file_sys/vfs/vfs_offset.cpp + file_sys/vfs/vfs_offset.h + file_sys/vfs/vfs_real.cpp + file_sys/vfs/vfs_real.h + file_sys/vfs/vfs_static.h + file_sys/vfs/vfs_types.h + file_sys/vfs/vfs_vector.cpp + file_sys/vfs/vfs_vector.h file_sys/xts_archive.cpp file_sys/xts_archive.h frontend/applets/cabinet.cpp @@ -486,6 +507,8 @@ add_library(core STATIC hle/service/fatal/fatal_p.h hle/service/fatal/fatal_u.cpp hle/service/fatal/fatal_u.h + hle/service/fgm/fgm.cpp + hle/service/fgm/fgm.h hle/service/filesystem/filesystem.cpp hle/service/filesystem/filesystem.h hle/service/filesystem/fsp/fs_i_directory.cpp @@ -560,13 +583,18 @@ add_library(core STATIC hle/service/hid/irs.h hle/service/hid/xcd.cpp hle/service/hid/xcd.h + hle/service/hle_ipc.cpp + hle/service/hle_ipc.h + hle/service/ipc_helpers.h + hle/service/kernel_helpers.cpp + hle/service/kernel_helpers.h hle/service/lbl/lbl.cpp hle/service/lbl/lbl.h hle/service/ldn/lan_discovery.cpp hle/service/ldn/lan_discovery.h - hle/service/ldn/ldn_results.h hle/service/ldn/ldn.cpp hle/service/ldn/ldn.h + hle/service/ldn/ldn_results.h hle/service/ldn/ldn_types.h hle/service/ldr/ldr.cpp hle/service/ldr/ldr.h @@ -574,16 +602,6 @@ add_library(core STATIC hle/service/lm/lm.h hle/service/mig/mig.cpp hle/service/mig/mig.h - hle/service/mii/types/char_info.cpp - hle/service/mii/types/char_info.h - hle/service/mii/types/core_data.cpp - hle/service/mii/types/core_data.h - hle/service/mii/types/raw_data.cpp - hle/service/mii/types/raw_data.h - hle/service/mii/types/store_data.cpp - hle/service/mii/types/store_data.h - hle/service/mii/types/ver3_store_data.cpp - hle/service/mii/types/ver3_store_data.h hle/service/mii/mii.cpp hle/service/mii/mii.h hle/service/mii/mii_database.cpp @@ -595,10 +613,22 @@ add_library(core STATIC hle/service/mii/mii_result.h hle/service/mii/mii_types.h hle/service/mii/mii_util.h + hle/service/mii/types/char_info.cpp + hle/service/mii/types/char_info.h + hle/service/mii/types/core_data.cpp + hle/service/mii/types/core_data.h + hle/service/mii/types/raw_data.cpp + hle/service/mii/types/raw_data.h + hle/service/mii/types/store_data.cpp + hle/service/mii/types/store_data.h + hle/service/mii/types/ver3_store_data.cpp + hle/service/mii/types/ver3_store_data.h hle/service/mm/mm_u.cpp hle/service/mm/mm_u.h hle/service/mnpp/mnpp_app.cpp hle/service/mnpp/mnpp_app.h + hle/service/mutex.cpp + hle/service/mutex.h hle/service/ncm/ncm.cpp hle/service/ncm/ncm.h hle/service/nfc/common/amiibo_crypto.cpp @@ -768,19 +798,12 @@ add_library(core STATIC hle/service/ptm/ptm.h hle/service/ptm/ts.cpp hle/service/ptm/ts.h - hle/service/hle_ipc.cpp - hle/service/hle_ipc.h - hle/service/ipc_helpers.h - hle/service/kernel_helpers.cpp - hle/service/kernel_helpers.h - hle/service/mutex.cpp - hle/service/mutex.h + hle/service/ro/ro.cpp + hle/service/ro/ro.h hle/service/ro/ro_nro_utils.cpp hle/service/ro/ro_nro_utils.h hle/service/ro/ro_results.h hle/service/ro/ro_types.h - hle/service/ro/ro.cpp - hle/service/ro/ro.h hle/service/server_manager.cpp hle/service/server_manager.h hle/service/service.cpp @@ -847,9 +870,9 @@ add_library(core STATIC internal_network/network.h internal_network/network_interface.cpp internal_network/network_interface.h - internal_network/sockets.h internal_network/socket_proxy.cpp internal_network/socket_proxy.h + internal_network/sockets.h loader/deconstructed_rom_directory.cpp loader/deconstructed_rom_directory.h loader/kip.cpp @@ -868,13 +891,13 @@ add_library(core STATIC loader/nsp.h loader/xci.cpp loader/xci.h + memory.cpp + memory.h memory/cheat_engine.cpp memory/cheat_engine.h memory/dmnt_cheat_types.h memory/dmnt_cheat_vm.cpp memory/dmnt_cheat_vm.h - memory.cpp - memory.h perf_stats.cpp perf_stats.h precompiled_headers.h diff --git a/src/core/core.cpp b/src/core/core.cpp index dd9de948c..8f9dd5efa 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -26,8 +26,8 @@ #include "core/file_sys/registered_cache.h" #include "core/file_sys/romfs_factory.h" #include "core/file_sys/savedata_factory.h" -#include "core/file_sys/vfs_concat.h" -#include "core/file_sys/vfs_real.h" +#include "core/file_sys/vfs/vfs_concat.h" +#include "core/file_sys/vfs/vfs_real.h" #include "core/gpu_dirty_memory_manager.h" #include "core/hle/kernel/k_memory_manager.h" #include "core/hle/kernel/k_process.h" diff --git a/src/core/core.h b/src/core/core.h index 183410602..d8862e9ce 100644 --- a/src/core/core.h +++ b/src/core/core.h @@ -13,7 +13,7 @@ #include #include "common/common_types.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace Core::Frontend { class EmuWindow; diff --git a/src/core/crypto/aes_util.h b/src/core/crypto/aes_util.h index a67ba5352..c2fd587a7 100644 --- a/src/core/crypto/aes_util.h +++ b/src/core/crypto/aes_util.h @@ -7,7 +7,7 @@ #include #include #include "common/common_types.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace Core::Crypto { diff --git a/src/core/crypto/encryption_layer.h b/src/core/crypto/encryption_layer.h index d3082ba53..b53f0b12e 100644 --- a/src/core/crypto/encryption_layer.h +++ b/src/core/crypto/encryption_layer.h @@ -4,7 +4,7 @@ #pragma once #include "common/common_types.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace Core::Crypto { diff --git a/src/core/crypto/partition_data_manager.cpp b/src/core/crypto/partition_data_manager.cpp index 97f5c8cea..4b45e72c4 100644 --- a/src/core/crypto/partition_data_manager.cpp +++ b/src/core/crypto/partition_data_manager.cpp @@ -21,9 +21,9 @@ #include "core/crypto/partition_data_manager.h" #include "core/crypto/xts_encryption_layer.h" #include "core/file_sys/kernel_executable.h" -#include "core/file_sys/vfs.h" -#include "core/file_sys/vfs_offset.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs.h" +#include "core/file_sys/vfs/vfs_offset.h" +#include "core/file_sys/vfs/vfs_vector.h" #include "core/loader/loader.h" using Common::AsArray; diff --git a/src/core/crypto/partition_data_manager.h b/src/core/crypto/partition_data_manager.h index 057a70683..4354a21e6 100644 --- a/src/core/crypto/partition_data_manager.h +++ b/src/core/crypto/partition_data_manager.h @@ -5,7 +5,7 @@ #include #include "common/common_types.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace Core::Crypto { diff --git a/src/core/file_sys/bis_factory.cpp b/src/core/file_sys/bis_factory.cpp index c750c0da7..f275f5fe4 100644 --- a/src/core/file_sys/bis_factory.cpp +++ b/src/core/file_sys/bis_factory.cpp @@ -6,7 +6,7 @@ #include "core/file_sys/bis_factory.h" #include "core/file_sys/mode.h" #include "core/file_sys/registered_cache.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/bis_factory.h b/src/core/file_sys/bis_factory.h index 26f0c6e5e..23680b60c 100644 --- a/src/core/file_sys/bis_factory.h +++ b/src/core/file_sys/bis_factory.h @@ -6,7 +6,7 @@ #include #include "common/common_types.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace FileSys { diff --git a/src/core/file_sys/card_image.cpp b/src/core/file_sys/card_image.cpp index 8b9a4fc5a..0bcf40cf8 100644 --- a/src/core/file_sys/card_image.cpp +++ b/src/core/file_sys/card_image.cpp @@ -13,8 +13,8 @@ #include "core/file_sys/nca_metadata.h" #include "core/file_sys/partition_filesystem.h" #include "core/file_sys/submission_package.h" -#include "core/file_sys/vfs_offset.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_offset.h" +#include "core/file_sys/vfs/vfs_vector.h" #include "core/loader/loader.h" namespace FileSys { diff --git a/src/core/file_sys/card_image.h b/src/core/file_sys/card_image.h index 9886123e7..97871da4a 100644 --- a/src/core/file_sys/card_image.h +++ b/src/core/file_sys/card_image.h @@ -8,7 +8,7 @@ #include #include "common/common_types.h" #include "common/swap.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace Core::Crypto { class KeyManager; diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp index 7d2f0abb8..285fe4db6 100644 --- a/src/core/file_sys/content_archive.cpp +++ b/src/core/file_sys/content_archive.cpp @@ -13,7 +13,7 @@ #include "core/crypto/key_manager.h" #include "core/file_sys/content_archive.h" #include "core/file_sys/partition_filesystem.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs_offset.h" #include "core/loader/loader.h" #include "core/file_sys/fssystem/fssystem_compression_configuration.h" diff --git a/src/core/file_sys/content_archive.h b/src/core/file_sys/content_archive.h index af521d453..f68464eb0 100644 --- a/src/core/file_sys/content_archive.h +++ b/src/core/file_sys/content_archive.h @@ -13,7 +13,7 @@ #include "common/common_types.h" #include "common/swap.h" #include "core/crypto/key_manager.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace Loader { enum class ResultStatus : u16; diff --git a/src/core/file_sys/control_metadata.cpp b/src/core/file_sys/control_metadata.cpp index 0697c29ae..f98594335 100644 --- a/src/core/file_sys/control_metadata.cpp +++ b/src/core/file_sys/control_metadata.cpp @@ -5,7 +5,7 @@ #include "common/string_util.h" #include "common/swap.h" #include "core/file_sys/control_metadata.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/control_metadata.h b/src/core/file_sys/control_metadata.h index c98efb00d..555b9d8f7 100644 --- a/src/core/file_sys/control_metadata.h +++ b/src/core/file_sys/control_metadata.h @@ -8,7 +8,7 @@ #include "common/common_funcs.h" #include "common/common_types.h" #include "common/swap.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace FileSys { diff --git a/src/core/file_sys/fsmitm_romfsbuild.cpp b/src/core/file_sys/fsmitm_romfsbuild.cpp index dd9cca103..8807bbd0f 100644 --- a/src/core/file_sys/fsmitm_romfsbuild.cpp +++ b/src/core/file_sys/fsmitm_romfsbuild.cpp @@ -8,8 +8,8 @@ #include "common/assert.h" #include "core/file_sys/fsmitm_romfsbuild.h" #include "core/file_sys/ips_layer.h" -#include "core/file_sys/vfs.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs.h" +#include "core/file_sys/vfs/vfs_vector.h" namespace FileSys { diff --git a/src/core/file_sys/fsmitm_romfsbuild.h b/src/core/file_sys/fsmitm_romfsbuild.h index f387c79f1..dd7ed4a7b 100644 --- a/src/core/file_sys/fsmitm_romfsbuild.h +++ b/src/core/file_sys/fsmitm_romfsbuild.h @@ -7,7 +7,7 @@ #include #include #include "common/common_types.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fs_i_storage.h b/src/core/file_sys/fssystem/fs_i_storage.h index 416dd57b8..37336c9ae 100644 --- a/src/core/file_sys/fssystem/fs_i_storage.h +++ b/src/core/file_sys/fssystem/fs_i_storage.h @@ -5,7 +5,7 @@ #include "common/overflow.h" #include "core/file_sys/errors.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp index f25c95472..bc1cddbb0 100644 --- a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp +++ b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp @@ -4,7 +4,7 @@ #include "core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h" #include "core/file_sys/fssystem/fssystem_aes_ctr_storage.h" #include "core/file_sys/fssystem/fssystem_nca_header.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs_offset.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h b/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h index 339e49697..5abd93d33 100644 --- a/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h +++ b/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h @@ -9,7 +9,7 @@ #include "core/crypto/key_manager.h" #include "core/file_sys/errors.h" #include "core/file_sys/fssystem/fs_i_storage.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_bucket_tree.h b/src/core/file_sys/fssystem/fssystem_bucket_tree.h index 46850cd48..3a5e21d1a 100644 --- a/src/core/file_sys/fssystem/fssystem_bucket_tree.h +++ b/src/core/file_sys/fssystem/fssystem_bucket_tree.h @@ -10,7 +10,7 @@ #include "common/common_types.h" #include "common/literals.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/hle/result.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_compressed_storage.h b/src/core/file_sys/fssystem/fssystem_compressed_storage.h index 33d93938e..74c98630e 100644 --- a/src/core/file_sys/fssystem/fssystem_compressed_storage.h +++ b/src/core/file_sys/fssystem/fssystem_compressed_storage.h @@ -10,7 +10,7 @@ #include "core/file_sys/fssystem/fssystem_bucket_tree.h" #include "core/file_sys/fssystem/fssystem_compression_common.h" #include "core/file_sys/fssystem/fssystem_pooled_buffer.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.cpp b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.cpp index 4a75b5308..39bb7b808 100644 --- a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.cpp +++ b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.cpp @@ -2,7 +2,7 @@ // SPDX-License-Identifier: GPL-2.0-or-later #include "core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs_offset.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h index 5cf697efe..bd129db47 100644 --- a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h +++ b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h @@ -8,7 +8,7 @@ #include "core/file_sys/fssystem/fs_types.h" #include "core/file_sys/fssystem/fssystem_alignment_matching_storage.h" #include "core/file_sys/fssystem/fssystem_integrity_verification_storage.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs_offset.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h b/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h index 18df400af..41d3960b8 100644 --- a/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h +++ b/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h @@ -7,7 +7,7 @@ #include "core/file_sys/errors.h" #include "core/file_sys/fssystem/fs_i_storage.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_indirect_storage.h b/src/core/file_sys/fssystem/fssystem_indirect_storage.h index 7854335bf..d4b95fd27 100644 --- a/src/core/file_sys/fssystem/fssystem_indirect_storage.h +++ b/src/core/file_sys/fssystem/fssystem_indirect_storage.h @@ -7,8 +7,8 @@ #include "core/file_sys/fssystem/fs_i_storage.h" #include "core/file_sys/fssystem/fssystem_bucket_tree.h" #include "core/file_sys/fssystem/fssystem_bucket_tree_template_impl.h" -#include "core/file_sys/vfs.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs.h" +#include "core/file_sys/vfs/vfs_offset.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h b/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h index 5f8512b2a..240d1e388 100644 --- a/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h +++ b/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h @@ -5,7 +5,7 @@ #include "core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h" #include "core/file_sys/fssystem/fssystem_nca_header.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_vector.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp index 0f5432203..ab5a7984e 100644 --- a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp +++ b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp @@ -14,8 +14,8 @@ #include "core/file_sys/fssystem/fssystem_nca_file_system_driver.h" #include "core/file_sys/fssystem/fssystem_sparse_storage.h" #include "core/file_sys/fssystem/fssystem_switch_storage.h" -#include "core/file_sys/vfs_offset.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_offset.h" +#include "core/file_sys/vfs/vfs_vector.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h index 5771a21fc..5bc838de6 100644 --- a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h +++ b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h @@ -5,7 +5,7 @@ #include "core/file_sys/fssystem/fssystem_compression_common.h" #include "core/file_sys/fssystem/fssystem_nca_header.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_nca_reader.cpp b/src/core/file_sys/fssystem/fssystem_nca_reader.cpp index a3714ab37..08924e2a6 100644 --- a/src/core/file_sys/fssystem/fssystem_nca_reader.cpp +++ b/src/core/file_sys/fssystem/fssystem_nca_reader.cpp @@ -3,7 +3,7 @@ #include "core/file_sys/fssystem/fssystem_aes_xts_storage.h" #include "core/file_sys/fssystem/fssystem_nca_file_system_driver.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs_offset.h" namespace FileSys { diff --git a/src/core/file_sys/ips_layer.cpp b/src/core/file_sys/ips_layer.cpp index 31033634c..d1ac24072 100644 --- a/src/core/file_sys/ips_layer.cpp +++ b/src/core/file_sys/ips_layer.cpp @@ -12,7 +12,7 @@ #include "common/logging/log.h" #include "common/swap.h" #include "core/file_sys/ips_layer.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_vector.h" namespace FileSys { diff --git a/src/core/file_sys/ips_layer.h b/src/core/file_sys/ips_layer.h index f2717bae7..d81378e8a 100644 --- a/src/core/file_sys/ips_layer.h +++ b/src/core/file_sys/ips_layer.h @@ -8,7 +8,7 @@ #include #include "common/common_types.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/kernel_executable.cpp b/src/core/file_sys/kernel_executable.cpp index 70c062f4c..b84492d30 100644 --- a/src/core/file_sys/kernel_executable.cpp +++ b/src/core/file_sys/kernel_executable.cpp @@ -5,7 +5,7 @@ #include "common/string_util.h" #include "core/file_sys/kernel_executable.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs_offset.h" #include "core/loader/loader.h" namespace FileSys { diff --git a/src/core/file_sys/kernel_executable.h b/src/core/file_sys/kernel_executable.h index d5b9199b5..928ba2d99 100644 --- a/src/core/file_sys/kernel_executable.h +++ b/src/core/file_sys/kernel_executable.h @@ -10,7 +10,7 @@ #include "common/common_funcs.h" #include "common/common_types.h" #include "common/swap.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace Loader { enum class ResultStatus : u16; diff --git a/src/core/file_sys/nca_metadata.cpp b/src/core/file_sys/nca_metadata.cpp index f4a774675..9e855c50d 100644 --- a/src/core/file_sys/nca_metadata.cpp +++ b/src/core/file_sys/nca_metadata.cpp @@ -6,7 +6,7 @@ #include "common/logging/log.h" #include "common/swap.h" #include "core/file_sys/nca_metadata.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/nca_metadata.h b/src/core/file_sys/nca_metadata.h index 68e463b5f..6243b822a 100644 --- a/src/core/file_sys/nca_metadata.h +++ b/src/core/file_sys/nca_metadata.h @@ -8,7 +8,7 @@ #include "common/common_funcs.h" #include "common/common_types.h" #include "common/swap.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace FileSys { class CNMT; diff --git a/src/core/file_sys/partition_filesystem.cpp b/src/core/file_sys/partition_filesystem.cpp index 2422cb51b..dd8de9d8a 100644 --- a/src/core/file_sys/partition_filesystem.cpp +++ b/src/core/file_sys/partition_filesystem.cpp @@ -9,7 +9,7 @@ #include "common/logging/log.h" #include "core/file_sys/partition_filesystem.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs_offset.h" #include "core/loader/loader.h" namespace FileSys { diff --git a/src/core/file_sys/partition_filesystem.h b/src/core/file_sys/partition_filesystem.h index b6e3a2b0c..777b9ead9 100644 --- a/src/core/file_sys/partition_filesystem.h +++ b/src/core/file_sys/partition_filesystem.h @@ -9,7 +9,7 @@ #include "common/common_funcs.h" #include "common/common_types.h" #include "common/swap.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace Loader { enum class ResultStatus : u16; diff --git a/src/core/file_sys/patch_manager.cpp b/src/core/file_sys/patch_manager.cpp index 612122224..21d45235e 100644 --- a/src/core/file_sys/patch_manager.cpp +++ b/src/core/file_sys/patch_manager.cpp @@ -21,9 +21,9 @@ #include "core/file_sys/patch_manager.h" #include "core/file_sys/registered_cache.h" #include "core/file_sys/romfs.h" -#include "core/file_sys/vfs_cached.h" -#include "core/file_sys/vfs_layered.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_cached.h" +#include "core/file_sys/vfs/vfs_layered.h" +#include "core/file_sys/vfs/vfs_vector.h" #include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/ns/language.h" #include "core/hle/service/set/settings_server.h" diff --git a/src/core/file_sys/patch_manager.h b/src/core/file_sys/patch_manager.h index 2601b8217..552c0fbe2 100644 --- a/src/core/file_sys/patch_manager.h +++ b/src/core/file_sys/patch_manager.h @@ -9,7 +9,7 @@ #include #include "common/common_types.h" #include "core/file_sys/nca_metadata.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" #include "core/memory/dmnt_cheat_types.h" namespace Core { diff --git a/src/core/file_sys/program_metadata.cpp b/src/core/file_sys/program_metadata.cpp index 539c7f7af..ae4e441c9 100644 --- a/src/core/file_sys/program_metadata.cpp +++ b/src/core/file_sys/program_metadata.cpp @@ -7,7 +7,7 @@ #include "common/logging/log.h" #include "common/scope_exit.h" #include "core/file_sys/program_metadata.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/loader/loader.h" namespace FileSys { diff --git a/src/core/file_sys/program_metadata.h b/src/core/file_sys/program_metadata.h index a53092b87..115e6d6cd 100644 --- a/src/core/file_sys/program_metadata.h +++ b/src/core/file_sys/program_metadata.h @@ -10,7 +10,7 @@ #include "common/common_funcs.h" #include "common/common_types.h" #include "common/swap.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace Loader { enum class ResultStatus : u16; diff --git a/src/core/file_sys/registered_cache.cpp b/src/core/file_sys/registered_cache.cpp index 1cc77ad14..85d30543c 100644 --- a/src/core/file_sys/registered_cache.cpp +++ b/src/core/file_sys/registered_cache.cpp @@ -17,7 +17,7 @@ #include "core/file_sys/nca_metadata.h" #include "core/file_sys/registered_cache.h" #include "core/file_sys/submission_package.h" -#include "core/file_sys/vfs_concat.h" +#include "core/file_sys/vfs/vfs_concat.h" #include "core/loader/loader.h" namespace FileSys { diff --git a/src/core/file_sys/registered_cache.h b/src/core/file_sys/registered_cache.h index 64815a845..a7fc55673 100644 --- a/src/core/file_sys/registered_cache.h +++ b/src/core/file_sys/registered_cache.h @@ -11,7 +11,7 @@ #include #include "common/common_types.h" #include "core/crypto/key_manager.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { class CNMT; diff --git a/src/core/file_sys/romfs.cpp b/src/core/file_sys/romfs.cpp index 6182598ae..a2b280973 100644 --- a/src/core/file_sys/romfs.cpp +++ b/src/core/file_sys/romfs.cpp @@ -9,11 +9,11 @@ #include "common/swap.h" #include "core/file_sys/fsmitm_romfsbuild.h" #include "core/file_sys/romfs.h" -#include "core/file_sys/vfs.h" -#include "core/file_sys/vfs_cached.h" -#include "core/file_sys/vfs_concat.h" -#include "core/file_sys/vfs_offset.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs.h" +#include "core/file_sys/vfs/vfs_cached.h" +#include "core/file_sys/vfs/vfs_concat.h" +#include "core/file_sys/vfs/vfs_offset.h" +#include "core/file_sys/vfs/vfs_vector.h" namespace FileSys { namespace { diff --git a/src/core/file_sys/romfs.h b/src/core/file_sys/romfs.h index b75ff1aad..3c0aca291 100644 --- a/src/core/file_sys/romfs.h +++ b/src/core/file_sys/romfs.h @@ -3,7 +3,7 @@ #pragma once -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/romfs_factory.h b/src/core/file_sys/romfs_factory.h index e4809bc94..11ecfabdf 100644 --- a/src/core/file_sys/romfs_factory.h +++ b/src/core/file_sys/romfs_factory.h @@ -6,7 +6,7 @@ #include #include "common/common_types.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" #include "core/hle/result.h" namespace Loader { diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp index 23196cd5f..cbf411a20 100644 --- a/src/core/file_sys/savedata_factory.cpp +++ b/src/core/file_sys/savedata_factory.cpp @@ -8,7 +8,7 @@ #include "common/uuid.h" #include "core/core.h" #include "core/file_sys/savedata_factory.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace FileSys { diff --git a/src/core/file_sys/savedata_factory.h b/src/core/file_sys/savedata_factory.h index 30d96928e..5ab7e4d32 100644 --- a/src/core/file_sys/savedata_factory.h +++ b/src/core/file_sys/savedata_factory.h @@ -7,7 +7,7 @@ #include #include "common/common_funcs.h" #include "common/common_types.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/hle/result.h" namespace Core { diff --git a/src/core/file_sys/sdmc_factory.cpp b/src/core/file_sys/sdmc_factory.cpp index d5158cd64..f3e2e21f4 100644 --- a/src/core/file_sys/sdmc_factory.cpp +++ b/src/core/file_sys/sdmc_factory.cpp @@ -4,7 +4,7 @@ #include #include "core/file_sys/registered_cache.h" #include "core/file_sys/sdmc_factory.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/file_sys/xts_archive.h" namespace FileSys { diff --git a/src/core/file_sys/sdmc_factory.h b/src/core/file_sys/sdmc_factory.h index a445fdb16..ee69ccd07 100644 --- a/src/core/file_sys/sdmc_factory.h +++ b/src/core/file_sys/sdmc_factory.h @@ -4,7 +4,7 @@ #pragma once #include -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" #include "core/hle/result.h" namespace FileSys { diff --git a/src/core/file_sys/submission_package.h b/src/core/file_sys/submission_package.h index 915bffca9..935e9589d 100644 --- a/src/core/file_sys/submission_package.h +++ b/src/core/file_sys/submission_package.h @@ -9,7 +9,7 @@ #include #include "common/common_types.h" #include "core/file_sys/nca_metadata.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace Core::Crypto { class KeyManager; diff --git a/src/core/file_sys/system_archive/mii_model.cpp b/src/core/file_sys/system_archive/mii_model.cpp index 5c87b42f8..a96cb2cd2 100644 --- a/src/core/file_sys/system_archive/mii_model.cpp +++ b/src/core/file_sys/system_archive/mii_model.cpp @@ -2,7 +2,7 @@ // SPDX-License-Identifier: GPL-2.0-or-later #include "core/file_sys/system_archive/mii_model.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_vector.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/system_archive/mii_model.h b/src/core/file_sys/system_archive/mii_model.h index b6cbefe24..61723ed0d 100644 --- a/src/core/file_sys/system_archive/mii_model.h +++ b/src/core/file_sys/system_archive/mii_model.h @@ -3,7 +3,7 @@ #pragma once -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/system_archive/ng_word.cpp b/src/core/file_sys/system_archive/ng_word.cpp index 5cf6749da..1fa67877d 100644 --- a/src/core/file_sys/system_archive/ng_word.cpp +++ b/src/core/file_sys/system_archive/ng_word.cpp @@ -4,7 +4,7 @@ #include #include "common/common_types.h" #include "core/file_sys/system_archive/ng_word.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_vector.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/system_archive/ng_word.h b/src/core/file_sys/system_archive/ng_word.h index 1d7b49532..51bcc3327 100644 --- a/src/core/file_sys/system_archive/ng_word.h +++ b/src/core/file_sys/system_archive/ng_word.h @@ -3,7 +3,7 @@ #pragma once -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/system_archive/shared_font.cpp b/src/core/file_sys/system_archive/shared_font.cpp index 3210583f0..deb52069d 100644 --- a/src/core/file_sys/system_archive/shared_font.cpp +++ b/src/core/file_sys/system_archive/shared_font.cpp @@ -8,7 +8,7 @@ #include "core/file_sys/system_archive/data/font_nintendo_extended.h" #include "core/file_sys/system_archive/data/font_standard.h" #include "core/file_sys/system_archive/shared_font.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_vector.h" #include "core/hle/service/ns/iplatform_service_manager.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/system_archive/shared_font.h b/src/core/file_sys/system_archive/shared_font.h index d1cd1dc44..2d19fcde3 100644 --- a/src/core/file_sys/system_archive/shared_font.h +++ b/src/core/file_sys/system_archive/shared_font.h @@ -3,7 +3,7 @@ #pragma once -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/system_archive/system_archive.h b/src/core/file_sys/system_archive/system_archive.h index 02d9157bb..2f64247bc 100644 --- a/src/core/file_sys/system_archive/system_archive.h +++ b/src/core/file_sys/system_archive/system_archive.h @@ -4,7 +4,7 @@ #pragma once #include "common/common_types.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/system_archive/system_version.cpp b/src/core/file_sys/system_archive/system_version.cpp index e4751c2b4..5662004b7 100644 --- a/src/core/file_sys/system_archive/system_version.cpp +++ b/src/core/file_sys/system_archive/system_version.cpp @@ -3,7 +3,7 @@ #include "common/logging/log.h" #include "core/file_sys/system_archive/system_version.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_vector.h" #include "core/hle/api_version.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/system_archive/system_version.h b/src/core/file_sys/system_archive/system_version.h index 21b5514a9..e5f7b952e 100644 --- a/src/core/file_sys/system_archive/system_version.h +++ b/src/core/file_sys/system_archive/system_version.h @@ -4,7 +4,7 @@ #pragma once #include -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/system_archive/time_zone_binary.cpp b/src/core/file_sys/system_archive/time_zone_binary.cpp index d4d2eae76..316ff0dc6 100644 --- a/src/core/file_sys/system_archive/time_zone_binary.cpp +++ b/src/core/file_sys/system_archive/time_zone_binary.cpp @@ -5,7 +5,7 @@ #include "common/swap.h" #include "core/file_sys/system_archive/time_zone_binary.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_vector.h" #include "nx_tzdb.h" diff --git a/src/core/file_sys/system_archive/time_zone_binary.h b/src/core/file_sys/system_archive/time_zone_binary.h index d0e1a4acd..e44fc5007 100644 --- a/src/core/file_sys/system_archive/time_zone_binary.h +++ b/src/core/file_sys/system_archive/time_zone_binary.h @@ -3,7 +3,7 @@ #pragma once -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace FileSys::SystemArchive { diff --git a/src/core/file_sys/vfs.cpp b/src/core/file_sys/vfs.cpp deleted file mode 100644 index b7105c8ff..000000000 --- a/src/core/file_sys/vfs.cpp +++ /dev/null @@ -1,552 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include -#include -#include -#include "common/fs/path_util.h" -#include "core/file_sys/mode.h" -#include "core/file_sys/vfs.h" - -namespace FileSys { - -VfsFilesystem::VfsFilesystem(VirtualDir root_) : root(std::move(root_)) {} - -VfsFilesystem::~VfsFilesystem() = default; - -std::string VfsFilesystem::GetName() const { - return root->GetName(); -} - -bool VfsFilesystem::IsReadable() const { - return root->IsReadable(); -} - -bool VfsFilesystem::IsWritable() const { - return root->IsWritable(); -} - -VfsEntryType VfsFilesystem::GetEntryType(std::string_view path_) const { - const auto path = Common::FS::SanitizePath(path_); - if (root->GetFileRelative(path) != nullptr) - return VfsEntryType::File; - if (root->GetDirectoryRelative(path) != nullptr) - return VfsEntryType::Directory; - - return VfsEntryType::None; -} - -VirtualFile VfsFilesystem::OpenFile(std::string_view path_, Mode perms) { - const auto path = Common::FS::SanitizePath(path_); - return root->GetFileRelative(path); -} - -VirtualFile VfsFilesystem::CreateFile(std::string_view path_, Mode perms) { - const auto path = Common::FS::SanitizePath(path_); - return root->CreateFileRelative(path); -} - -VirtualFile VfsFilesystem::CopyFile(std::string_view old_path_, std::string_view new_path_) { - const auto old_path = Common::FS::SanitizePath(old_path_); - const auto new_path = Common::FS::SanitizePath(new_path_); - - // VfsDirectory impls are only required to implement copy across the current directory. - if (Common::FS::GetParentPath(old_path) == Common::FS::GetParentPath(new_path)) { - if (!root->Copy(Common::FS::GetFilename(old_path), Common::FS::GetFilename(new_path))) - return nullptr; - return OpenFile(new_path, Mode::ReadWrite); - } - - // Do it using RawCopy. Non-default impls are encouraged to optimize this. - const auto old_file = OpenFile(old_path, Mode::Read); - if (old_file == nullptr) - return nullptr; - auto new_file = OpenFile(new_path, Mode::Read); - if (new_file != nullptr) - return nullptr; - new_file = CreateFile(new_path, Mode::Write); - if (new_file == nullptr) - return nullptr; - if (!VfsRawCopy(old_file, new_file)) - return nullptr; - return new_file; -} - -VirtualFile VfsFilesystem::MoveFile(std::string_view old_path, std::string_view new_path) { - const auto sanitized_old_path = Common::FS::SanitizePath(old_path); - const auto sanitized_new_path = Common::FS::SanitizePath(new_path); - - // Again, non-default impls are highly encouraged to provide a more optimized version of this. - auto out = CopyFile(sanitized_old_path, sanitized_new_path); - if (out == nullptr) - return nullptr; - if (DeleteFile(sanitized_old_path)) - return out; - return nullptr; -} - -bool VfsFilesystem::DeleteFile(std::string_view path_) { - const auto path = Common::FS::SanitizePath(path_); - auto parent = OpenDirectory(Common::FS::GetParentPath(path), Mode::Write); - if (parent == nullptr) - return false; - return parent->DeleteFile(Common::FS::GetFilename(path)); -} - -VirtualDir VfsFilesystem::OpenDirectory(std::string_view path_, Mode perms) { - const auto path = Common::FS::SanitizePath(path_); - return root->GetDirectoryRelative(path); -} - -VirtualDir VfsFilesystem::CreateDirectory(std::string_view path_, Mode perms) { - const auto path = Common::FS::SanitizePath(path_); - return root->CreateDirectoryRelative(path); -} - -VirtualDir VfsFilesystem::CopyDirectory(std::string_view old_path_, std::string_view new_path_) { - const auto old_path = Common::FS::SanitizePath(old_path_); - const auto new_path = Common::FS::SanitizePath(new_path_); - - // Non-default impls are highly encouraged to provide a more optimized version of this. - auto old_dir = OpenDirectory(old_path, Mode::Read); - if (old_dir == nullptr) - return nullptr; - auto new_dir = OpenDirectory(new_path, Mode::Read); - if (new_dir != nullptr) - return nullptr; - new_dir = CreateDirectory(new_path, Mode::Write); - if (new_dir == nullptr) - return nullptr; - - for (const auto& file : old_dir->GetFiles()) { - const auto x = CopyFile(old_path + '/' + file->GetName(), new_path + '/' + file->GetName()); - if (x == nullptr) - return nullptr; - } - - for (const auto& dir : old_dir->GetSubdirectories()) { - const auto x = - CopyDirectory(old_path + '/' + dir->GetName(), new_path + '/' + dir->GetName()); - if (x == nullptr) - return nullptr; - } - - return new_dir; -} - -VirtualDir VfsFilesystem::MoveDirectory(std::string_view old_path, std::string_view new_path) { - const auto sanitized_old_path = Common::FS::SanitizePath(old_path); - const auto sanitized_new_path = Common::FS::SanitizePath(new_path); - - // Non-default impls are highly encouraged to provide a more optimized version of this. - auto out = CopyDirectory(sanitized_old_path, sanitized_new_path); - if (out == nullptr) - return nullptr; - if (DeleteDirectory(sanitized_old_path)) - return out; - return nullptr; -} - -bool VfsFilesystem::DeleteDirectory(std::string_view path_) { - const auto path = Common::FS::SanitizePath(path_); - auto parent = OpenDirectory(Common::FS::GetParentPath(path), Mode::Write); - if (parent == nullptr) - return false; - return parent->DeleteSubdirectoryRecursive(Common::FS::GetFilename(path)); -} - -VfsFile::~VfsFile() = default; - -std::string VfsFile::GetExtension() const { - return std::string(Common::FS::GetExtensionFromFilename(GetName())); -} - -VfsDirectory::~VfsDirectory() = default; - -std::optional VfsFile::ReadByte(std::size_t offset) const { - u8 out{}; - const std::size_t size = Read(&out, sizeof(u8), offset); - if (size == 1) { - return out; - } - - return std::nullopt; -} - -std::vector VfsFile::ReadBytes(std::size_t size, std::size_t offset) const { - std::vector out(size); - std::size_t read_size = Read(out.data(), size, offset); - out.resize(read_size); - return out; -} - -std::vector VfsFile::ReadAllBytes() const { - return ReadBytes(GetSize()); -} - -bool VfsFile::WriteByte(u8 data, std::size_t offset) { - return Write(&data, 1, offset) == 1; -} - -std::size_t VfsFile::WriteBytes(const std::vector& data, std::size_t offset) { - return Write(data.data(), data.size(), offset); -} - -std::string VfsFile::GetFullPath() const { - if (GetContainingDirectory() == nullptr) - return '/' + GetName(); - - return GetContainingDirectory()->GetFullPath() + '/' + GetName(); -} - -VirtualFile VfsDirectory::GetFileRelative(std::string_view path) const { - auto vec = Common::FS::SplitPathComponents(path); - if (vec.empty()) { - return nullptr; - } - - if (vec.size() == 1) { - return GetFile(vec[0]); - } - - auto dir = GetSubdirectory(vec[0]); - for (std::size_t component = 1; component < vec.size() - 1; ++component) { - if (dir == nullptr) { - return nullptr; - } - - dir = dir->GetSubdirectory(vec[component]); - } - - if (dir == nullptr) { - return nullptr; - } - - return dir->GetFile(vec.back()); -} - -VirtualFile VfsDirectory::GetFileAbsolute(std::string_view path) const { - if (IsRoot()) { - return GetFileRelative(path); - } - - return GetParentDirectory()->GetFileAbsolute(path); -} - -VirtualDir VfsDirectory::GetDirectoryRelative(std::string_view path) const { - auto vec = Common::FS::SplitPathComponents(path); - if (vec.empty()) { - // TODO(DarkLordZach): Return this directory if path is '/' or similar. Can't currently - // because of const-ness - return nullptr; - } - - auto dir = GetSubdirectory(vec[0]); - for (std::size_t component = 1; component < vec.size(); ++component) { - if (dir == nullptr) { - return nullptr; - } - - dir = dir->GetSubdirectory(vec[component]); - } - - return dir; -} - -VirtualDir VfsDirectory::GetDirectoryAbsolute(std::string_view path) const { - if (IsRoot()) { - return GetDirectoryRelative(path); - } - - return GetParentDirectory()->GetDirectoryAbsolute(path); -} - -VirtualFile VfsDirectory::GetFile(std::string_view name) const { - const auto& files = GetFiles(); - const auto iter = std::find_if(files.begin(), files.end(), - [&name](const auto& file1) { return name == file1->GetName(); }); - return iter == files.end() ? nullptr : *iter; -} - -FileTimeStampRaw VfsDirectory::GetFileTimeStamp([[maybe_unused]] std::string_view path) const { - return {}; -} - -VirtualDir VfsDirectory::GetSubdirectory(std::string_view name) const { - const auto& subs = GetSubdirectories(); - const auto iter = std::find_if(subs.begin(), subs.end(), - [&name](const auto& file1) { return name == file1->GetName(); }); - return iter == subs.end() ? nullptr : *iter; -} - -bool VfsDirectory::IsRoot() const { - return GetParentDirectory() == nullptr; -} - -std::size_t VfsDirectory::GetSize() const { - const auto& files = GetFiles(); - const auto sum_sizes = [](const auto& range) { - return std::accumulate(range.begin(), range.end(), 0ULL, - [](const auto& f1, const auto& f2) { return f1 + f2->GetSize(); }); - }; - - const auto file_total = sum_sizes(files); - const auto& sub_dir = GetSubdirectories(); - const auto subdir_total = sum_sizes(sub_dir); - - return file_total + subdir_total; -} - -VirtualFile VfsDirectory::CreateFileRelative(std::string_view path) { - auto vec = Common::FS::SplitPathComponents(path); - if (vec.empty()) { - return nullptr; - } - - if (vec.size() == 1) { - return CreateFile(vec[0]); - } - - auto dir = GetSubdirectory(vec[0]); - if (dir == nullptr) { - dir = CreateSubdirectory(vec[0]); - if (dir == nullptr) { - return nullptr; - } - } - - return dir->CreateFileRelative(Common::FS::GetPathWithoutTop(path)); -} - -VirtualFile VfsDirectory::CreateFileAbsolute(std::string_view path) { - if (IsRoot()) { - return CreateFileRelative(path); - } - - return GetParentDirectory()->CreateFileAbsolute(path); -} - -VirtualDir VfsDirectory::CreateDirectoryRelative(std::string_view path) { - auto vec = Common::FS::SplitPathComponents(path); - if (vec.empty()) { - return nullptr; - } - - if (vec.size() == 1) { - return CreateSubdirectory(vec[0]); - } - - auto dir = GetSubdirectory(vec[0]); - if (dir == nullptr) { - dir = CreateSubdirectory(vec[0]); - if (dir == nullptr) { - return nullptr; - } - } - - return dir->CreateDirectoryRelative(Common::FS::GetPathWithoutTop(path)); -} - -VirtualDir VfsDirectory::CreateDirectoryAbsolute(std::string_view path) { - if (IsRoot()) { - return CreateDirectoryRelative(path); - } - - return GetParentDirectory()->CreateDirectoryAbsolute(path); -} - -bool VfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) { - auto dir = GetSubdirectory(name); - if (dir == nullptr) { - return false; - } - - bool success = true; - for (const auto& file : dir->GetFiles()) { - if (!DeleteFile(file->GetName())) { - success = false; - } - } - - for (const auto& sdir : dir->GetSubdirectories()) { - if (!dir->DeleteSubdirectoryRecursive(sdir->GetName())) { - success = false; - } - } - - return success; -} - -bool VfsDirectory::CleanSubdirectoryRecursive(std::string_view name) { - auto dir = GetSubdirectory(name); - if (dir == nullptr) { - return false; - } - - bool success = true; - for (const auto& file : dir->GetFiles()) { - if (!dir->DeleteFile(file->GetName())) { - success = false; - } - } - - for (const auto& sdir : dir->GetSubdirectories()) { - if (!dir->DeleteSubdirectoryRecursive(sdir->GetName())) { - success = false; - } - } - - return success; -} - -bool VfsDirectory::Copy(std::string_view src, std::string_view dest) { - const auto f1 = GetFile(src); - auto f2 = CreateFile(dest); - if (f1 == nullptr || f2 == nullptr) { - return false; - } - - if (!f2->Resize(f1->GetSize())) { - DeleteFile(dest); - return false; - } - - return f2->WriteBytes(f1->ReadAllBytes()) == f1->GetSize(); -} - -std::map> VfsDirectory::GetEntries() const { - std::map> out; - for (const auto& dir : GetSubdirectories()) - out.emplace(dir->GetName(), VfsEntryType::Directory); - for (const auto& file : GetFiles()) - out.emplace(file->GetName(), VfsEntryType::File); - return out; -} - -std::string VfsDirectory::GetFullPath() const { - if (IsRoot()) - return GetName(); - - return GetParentDirectory()->GetFullPath() + '/' + GetName(); -} - -bool ReadOnlyVfsDirectory::IsWritable() const { - return false; -} - -bool ReadOnlyVfsDirectory::IsReadable() const { - return true; -} - -VirtualDir ReadOnlyVfsDirectory::CreateSubdirectory(std::string_view name) { - return nullptr; -} - -VirtualFile ReadOnlyVfsDirectory::CreateFile(std::string_view name) { - return nullptr; -} - -VirtualFile ReadOnlyVfsDirectory::CreateFileAbsolute(std::string_view path) { - return nullptr; -} - -VirtualFile ReadOnlyVfsDirectory::CreateFileRelative(std::string_view path) { - return nullptr; -} - -VirtualDir ReadOnlyVfsDirectory::CreateDirectoryAbsolute(std::string_view path) { - return nullptr; -} - -VirtualDir ReadOnlyVfsDirectory::CreateDirectoryRelative(std::string_view path) { - return nullptr; -} - -bool ReadOnlyVfsDirectory::DeleteSubdirectory(std::string_view name) { - return false; -} - -bool ReadOnlyVfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) { - return false; -} - -bool ReadOnlyVfsDirectory::CleanSubdirectoryRecursive(std::string_view name) { - return false; -} - -bool ReadOnlyVfsDirectory::DeleteFile(std::string_view name) { - return false; -} - -bool ReadOnlyVfsDirectory::Rename(std::string_view name) { - return false; -} - -bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, std::size_t block_size) { - if (file1->GetSize() != file2->GetSize()) - return false; - - std::vector f1_v(block_size); - std::vector f2_v(block_size); - for (std::size_t i = 0; i < file1->GetSize(); i += block_size) { - auto f1_vs = file1->Read(f1_v.data(), block_size, i); - auto f2_vs = file2->Read(f2_v.data(), block_size, i); - - if (f1_vs != f2_vs) - return false; - auto iters = std::mismatch(f1_v.begin(), f1_v.end(), f2_v.begin(), f2_v.end()); - if (iters.first != f1_v.end() && iters.second != f2_v.end()) - return false; - } - - return true; -} - -bool VfsRawCopy(const VirtualFile& src, const VirtualFile& dest, std::size_t block_size) { - if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable()) - return false; - if (!dest->Resize(src->GetSize())) - return false; - - std::vector temp(std::min(block_size, src->GetSize())); - for (std::size_t i = 0; i < src->GetSize(); i += block_size) { - const auto read = std::min(block_size, src->GetSize() - i); - - if (src->Read(temp.data(), read, i) != read) { - return false; - } - - if (dest->Write(temp.data(), read, i) != read) { - return false; - } - } - - return true; -} - -bool VfsRawCopyD(const VirtualDir& src, const VirtualDir& dest, std::size_t block_size) { - if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable()) - return false; - - for (const auto& file : src->GetFiles()) { - const auto out = dest->CreateFile(file->GetName()); - if (!VfsRawCopy(file, out, block_size)) - return false; - } - - for (const auto& dir : src->GetSubdirectories()) { - const auto out = dest->CreateSubdirectory(dir->GetName()); - if (!VfsRawCopyD(dir, out, block_size)) - return false; - } - - return true; -} - -VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path) { - const auto res = rel->GetDirectoryRelative(path); - if (res == nullptr) - return rel->CreateDirectoryRelative(path); - return res; -} -} // namespace FileSys diff --git a/src/core/file_sys/vfs.h b/src/core/file_sys/vfs.h deleted file mode 100644 index a7cd1cae3..000000000 --- a/src/core/file_sys/vfs.h +++ /dev/null @@ -1,327 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include -#include -#include -#include -#include -#include -#include - -#include "common/common_funcs.h" -#include "common/common_types.h" -#include "core/file_sys/vfs_types.h" - -namespace FileSys { - -enum class Mode : u32; - -// An enumeration representing what can be at the end of a path in a VfsFilesystem -enum class VfsEntryType { - None, - File, - Directory, -}; - -// A class representing an abstract filesystem. A default implementation given the root VirtualDir -// is provided for convenience, but if the Vfs implementation has any additional state or -// functionality, they will need to override. -class VfsFilesystem { -public: - YUZU_NON_COPYABLE(VfsFilesystem); - YUZU_NON_MOVEABLE(VfsFilesystem); - - explicit VfsFilesystem(VirtualDir root); - virtual ~VfsFilesystem(); - - // Gets the friendly name for the filesystem. - virtual std::string GetName() const; - - // Return whether or not the user has read permissions on this filesystem. - virtual bool IsReadable() const; - // Return whether or not the user has write permission on this filesystem. - virtual bool IsWritable() const; - - // Determine if the entry at path is non-existent, a file, or a directory. - virtual VfsEntryType GetEntryType(std::string_view path) const; - - // Opens the file with path relative to root. If it doesn't exist, returns nullptr. - virtual VirtualFile OpenFile(std::string_view path, Mode perms); - // Creates a new, empty file at path - virtual VirtualFile CreateFile(std::string_view path, Mode perms); - // Copies the file from old_path to new_path, returning the new file on success and nullptr on - // failure. - virtual VirtualFile CopyFile(std::string_view old_path, std::string_view new_path); - // Moves the file from old_path to new_path, returning the moved file on success and nullptr on - // failure. - virtual VirtualFile MoveFile(std::string_view old_path, std::string_view new_path); - // Deletes the file with path relative to root, returning true on success. - virtual bool DeleteFile(std::string_view path); - - // Opens the directory with path relative to root. If it doesn't exist, returns nullptr. - virtual VirtualDir OpenDirectory(std::string_view path, Mode perms); - // Creates a new, empty directory at path - virtual VirtualDir CreateDirectory(std::string_view path, Mode perms); - // Copies the directory from old_path to new_path, returning the new directory on success and - // nullptr on failure. - virtual VirtualDir CopyDirectory(std::string_view old_path, std::string_view new_path); - // Moves the directory from old_path to new_path, returning the moved directory on success and - // nullptr on failure. - virtual VirtualDir MoveDirectory(std::string_view old_path, std::string_view new_path); - // Deletes the directory with path relative to root, returning true on success. - virtual bool DeleteDirectory(std::string_view path); - -protected: - // Root directory in default implementation. - VirtualDir root; -}; - -// A class representing a file in an abstract filesystem. -class VfsFile { -public: - YUZU_NON_COPYABLE(VfsFile); - YUZU_NON_MOVEABLE(VfsFile); - - VfsFile() = default; - virtual ~VfsFile(); - - // Retrieves the file name. - virtual std::string GetName() const = 0; - // Retrieves the extension of the file name. - virtual std::string GetExtension() const; - // Retrieves the size of the file. - virtual std::size_t GetSize() const = 0; - // Resizes the file to new_size. Returns whether or not the operation was successful. - virtual bool Resize(std::size_t new_size) = 0; - // Gets a pointer to the directory containing this file, returning nullptr if there is none. - virtual VirtualDir GetContainingDirectory() const = 0; - - // Returns whether or not the file can be written to. - virtual bool IsWritable() const = 0; - // Returns whether or not the file can be read from. - virtual bool IsReadable() const = 0; - - // The primary method of reading from the file. Reads length bytes into data starting at offset - // into file. Returns number of bytes successfully read. - virtual std::size_t Read(u8* data, std::size_t length, std::size_t offset = 0) const = 0; - // The primary method of writing to the file. Writes length bytes from data starting at offset - // into file. Returns number of bytes successfully written. - virtual std::size_t Write(const u8* data, std::size_t length, std::size_t offset = 0) = 0; - - // Reads exactly one byte at the offset provided, returning std::nullopt on error. - virtual std::optional ReadByte(std::size_t offset = 0) const; - // Reads size bytes starting at offset in file into a vector. - virtual std::vector ReadBytes(std::size_t size, std::size_t offset = 0) const; - // Reads all the bytes from the file into a vector. Equivalent to 'file->Read(file->GetSize(), - // 0)' - virtual std::vector ReadAllBytes() const; - - // Reads an array of type T, size number_elements starting at offset. - // Returns the number of bytes (sizeof(T)*number_elements) read successfully. - template - std::size_t ReadArray(T* data, std::size_t number_elements, std::size_t offset = 0) const { - static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); - - return Read(reinterpret_cast(data), number_elements * sizeof(T), offset); - } - - // Reads size bytes into the memory starting at data starting at offset into the file. - // Returns the number of bytes read successfully. - template - std::size_t ReadBytes(T* data, std::size_t size, std::size_t offset = 0) const { - static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); - return Read(reinterpret_cast(data), size, offset); - } - - // Reads one object of type T starting at offset in file. - // Returns the number of bytes read successfully (sizeof(T)). - template - std::size_t ReadObject(T* data, std::size_t offset = 0) const { - static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); - return Read(reinterpret_cast(data), sizeof(T), offset); - } - - // Writes exactly one byte to offset in file and returns whether or not the byte was written - // successfully. - virtual bool WriteByte(u8 data, std::size_t offset = 0); - // Writes a vector of bytes to offset in file and returns the number of bytes successfully - // written. - virtual std::size_t WriteBytes(const std::vector& data, std::size_t offset = 0); - - // Writes an array of type T, size number_elements to offset in file. - // Returns the number of bytes (sizeof(T)*number_elements) written successfully. - template - std::size_t WriteArray(const T* data, std::size_t number_elements, std::size_t offset = 0) { - static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); - return Write(reinterpret_cast(data), number_elements * sizeof(T), offset); - } - - // Writes size bytes starting at memory location data to offset in file. - // Returns the number of bytes written successfully. - template - std::size_t WriteBytes(const T* data, std::size_t size, std::size_t offset = 0) { - static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); - return Write(reinterpret_cast(data), size, offset); - } - - // Writes one object of type T to offset in file. - // Returns the number of bytes written successfully (sizeof(T)). - template - std::size_t WriteObject(const T& data, std::size_t offset = 0) { - static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); - return Write(reinterpret_cast(&data), sizeof(T), offset); - } - - // Renames the file to name. Returns whether or not the operation was successful. - virtual bool Rename(std::string_view name) = 0; - - // Returns the full path of this file as a string, recursively - virtual std::string GetFullPath() const; -}; - -// A class representing a directory in an abstract filesystem. -class VfsDirectory { -public: - YUZU_NON_COPYABLE(VfsDirectory); - YUZU_NON_MOVEABLE(VfsDirectory); - - VfsDirectory() = default; - virtual ~VfsDirectory(); - - // Retrieves the file located at path as if the current directory was root. Returns nullptr if - // not found. - virtual VirtualFile GetFileRelative(std::string_view path) const; - // Calls GetFileRelative(path) on the root of the current directory. - virtual VirtualFile GetFileAbsolute(std::string_view path) const; - - // Retrieves the directory located at path as if the current directory was root. Returns nullptr - // if not found. - virtual VirtualDir GetDirectoryRelative(std::string_view path) const; - // Calls GetDirectoryRelative(path) on the root of the current directory. - virtual VirtualDir GetDirectoryAbsolute(std::string_view path) const; - - // Returns a vector containing all of the files in this directory. - virtual std::vector GetFiles() const = 0; - // Returns the file with filename matching name. Returns nullptr if directory doesn't have a - // file with name. - virtual VirtualFile GetFile(std::string_view name) const; - - // Returns a struct containing the file's timestamp. - virtual FileTimeStampRaw GetFileTimeStamp(std::string_view path) const; - - // Returns a vector containing all of the subdirectories in this directory. - virtual std::vector GetSubdirectories() const = 0; - // Returns the directory with name matching name. Returns nullptr if directory doesn't have a - // directory with name. - virtual VirtualDir GetSubdirectory(std::string_view name) const; - - // Returns whether or not the directory can be written to. - virtual bool IsWritable() const = 0; - // Returns whether of not the directory can be read from. - virtual bool IsReadable() const = 0; - - // Returns whether or not the directory is the root of the current file tree. - virtual bool IsRoot() const; - - // Returns the name of the directory. - virtual std::string GetName() const = 0; - // Returns the total size of all files and subdirectories in this directory. - virtual std::size_t GetSize() const; - // Returns the parent directory of this directory. Returns nullptr if this directory is root or - // has no parent. - virtual VirtualDir GetParentDirectory() const = 0; - - // Creates a new subdirectory with name name. Returns a pointer to the new directory or nullptr - // if the operation failed. - virtual VirtualDir CreateSubdirectory(std::string_view name) = 0; - // Creates a new file with name name. Returns a pointer to the new file or nullptr if the - // operation failed. - virtual VirtualFile CreateFile(std::string_view name) = 0; - - // Creates a new file at the path relative to this directory. Also creates directories if - // they do not exist and is supported by this implementation. Returns nullptr on any failure. - virtual VirtualFile CreateFileRelative(std::string_view path); - - // Creates a new file at the path relative to root of this directory. Also creates directories - // if they do not exist and is supported by this implementation. Returns nullptr on any failure. - virtual VirtualFile CreateFileAbsolute(std::string_view path); - - // Creates a new directory at the path relative to this directory. Also creates directories if - // they do not exist and is supported by this implementation. Returns nullptr on any failure. - virtual VirtualDir CreateDirectoryRelative(std::string_view path); - - // Creates a new directory at the path relative to root of this directory. Also creates - // directories if they do not exist and is supported by this implementation. Returns nullptr on - // any failure. - virtual VirtualDir CreateDirectoryAbsolute(std::string_view path); - - // Deletes the subdirectory with the given name and returns true on success. - virtual bool DeleteSubdirectory(std::string_view name) = 0; - - // Deletes all subdirectories and files within the provided directory and then deletes - // the directory itself. Returns true on success. - virtual bool DeleteSubdirectoryRecursive(std::string_view name); - - // Deletes all subdirectories and files within the provided directory. - // Unlike DeleteSubdirectoryRecursive, this does not delete the provided directory. - virtual bool CleanSubdirectoryRecursive(std::string_view name); - - // Returns whether or not the file with name name was deleted successfully. - virtual bool DeleteFile(std::string_view name) = 0; - - // Returns whether or not this directory was renamed to name. - virtual bool Rename(std::string_view name) = 0; - - // Returns whether or not the file with name src was successfully copied to a new file with name - // dest. - virtual bool Copy(std::string_view src, std::string_view dest); - - // Gets all of the entries directly in the directory (files and dirs), returning a map between - // item name -> type. - virtual std::map> GetEntries() const; - - // Returns the full path of this directory as a string, recursively - virtual std::string GetFullPath() const; -}; - -// A convenience partial-implementation of VfsDirectory that stubs out methods that should only work -// if writable. This is to avoid redundant empty methods everywhere. -class ReadOnlyVfsDirectory : public VfsDirectory { -public: - bool IsWritable() const override; - bool IsReadable() const override; - VirtualDir CreateSubdirectory(std::string_view name) override; - VirtualFile CreateFile(std::string_view name) override; - VirtualFile CreateFileAbsolute(std::string_view path) override; - VirtualFile CreateFileRelative(std::string_view path) override; - VirtualDir CreateDirectoryAbsolute(std::string_view path) override; - VirtualDir CreateDirectoryRelative(std::string_view path) override; - bool DeleteSubdirectory(std::string_view name) override; - bool DeleteSubdirectoryRecursive(std::string_view name) override; - bool CleanSubdirectoryRecursive(std::string_view name) override; - bool DeleteFile(std::string_view name) override; - bool Rename(std::string_view name) override; -}; - -// Compare the two files, byte-for-byte, in increments specified by block_size -bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, - std::size_t block_size = 0x1000); - -// A method that copies the raw data between two different implementations of VirtualFile. If you -// are using the same implementation, it is probably better to use the Copy method in the parent -// directory of src/dest. -bool VfsRawCopy(const VirtualFile& src, const VirtualFile& dest, std::size_t block_size = 0x1000); - -// A method that performs a similar function to VfsRawCopy above, but instead copies entire -// directories. It suffers the same performance penalties as above and an implementation-specific -// Copy should always be preferred. -bool VfsRawCopyD(const VirtualDir& src, const VirtualDir& dest, std::size_t block_size = 0x1000); - -// Checks if the directory at path relative to rel exists. If it does, returns that. If it does not -// it attempts to create it and returns the new dir or nullptr on failure. -VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path); - -} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs.cpp b/src/core/file_sys/vfs/vfs.cpp new file mode 100644 index 000000000..b88a5f91d --- /dev/null +++ b/src/core/file_sys/vfs/vfs.cpp @@ -0,0 +1,552 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include +#include +#include "common/fs/path_util.h" +#include "core/file_sys/mode.h" +#include "core/file_sys/vfs/vfs.h" + +namespace FileSys { + +VfsFilesystem::VfsFilesystem(VirtualDir root_) : root(std::move(root_)) {} + +VfsFilesystem::~VfsFilesystem() = default; + +std::string VfsFilesystem::GetName() const { + return root->GetName(); +} + +bool VfsFilesystem::IsReadable() const { + return root->IsReadable(); +} + +bool VfsFilesystem::IsWritable() const { + return root->IsWritable(); +} + +VfsEntryType VfsFilesystem::GetEntryType(std::string_view path_) const { + const auto path = Common::FS::SanitizePath(path_); + if (root->GetFileRelative(path) != nullptr) + return VfsEntryType::File; + if (root->GetDirectoryRelative(path) != nullptr) + return VfsEntryType::Directory; + + return VfsEntryType::None; +} + +VirtualFile VfsFilesystem::OpenFile(std::string_view path_, Mode perms) { + const auto path = Common::FS::SanitizePath(path_); + return root->GetFileRelative(path); +} + +VirtualFile VfsFilesystem::CreateFile(std::string_view path_, Mode perms) { + const auto path = Common::FS::SanitizePath(path_); + return root->CreateFileRelative(path); +} + +VirtualFile VfsFilesystem::CopyFile(std::string_view old_path_, std::string_view new_path_) { + const auto old_path = Common::FS::SanitizePath(old_path_); + const auto new_path = Common::FS::SanitizePath(new_path_); + + // VfsDirectory impls are only required to implement copy across the current directory. + if (Common::FS::GetParentPath(old_path) == Common::FS::GetParentPath(new_path)) { + if (!root->Copy(Common::FS::GetFilename(old_path), Common::FS::GetFilename(new_path))) + return nullptr; + return OpenFile(new_path, Mode::ReadWrite); + } + + // Do it using RawCopy. Non-default impls are encouraged to optimize this. + const auto old_file = OpenFile(old_path, Mode::Read); + if (old_file == nullptr) + return nullptr; + auto new_file = OpenFile(new_path, Mode::Read); + if (new_file != nullptr) + return nullptr; + new_file = CreateFile(new_path, Mode::Write); + if (new_file == nullptr) + return nullptr; + if (!VfsRawCopy(old_file, new_file)) + return nullptr; + return new_file; +} + +VirtualFile VfsFilesystem::MoveFile(std::string_view old_path, std::string_view new_path) { + const auto sanitized_old_path = Common::FS::SanitizePath(old_path); + const auto sanitized_new_path = Common::FS::SanitizePath(new_path); + + // Again, non-default impls are highly encouraged to provide a more optimized version of this. + auto out = CopyFile(sanitized_old_path, sanitized_new_path); + if (out == nullptr) + return nullptr; + if (DeleteFile(sanitized_old_path)) + return out; + return nullptr; +} + +bool VfsFilesystem::DeleteFile(std::string_view path_) { + const auto path = Common::FS::SanitizePath(path_); + auto parent = OpenDirectory(Common::FS::GetParentPath(path), Mode::Write); + if (parent == nullptr) + return false; + return parent->DeleteFile(Common::FS::GetFilename(path)); +} + +VirtualDir VfsFilesystem::OpenDirectory(std::string_view path_, Mode perms) { + const auto path = Common::FS::SanitizePath(path_); + return root->GetDirectoryRelative(path); +} + +VirtualDir VfsFilesystem::CreateDirectory(std::string_view path_, Mode perms) { + const auto path = Common::FS::SanitizePath(path_); + return root->CreateDirectoryRelative(path); +} + +VirtualDir VfsFilesystem::CopyDirectory(std::string_view old_path_, std::string_view new_path_) { + const auto old_path = Common::FS::SanitizePath(old_path_); + const auto new_path = Common::FS::SanitizePath(new_path_); + + // Non-default impls are highly encouraged to provide a more optimized version of this. + auto old_dir = OpenDirectory(old_path, Mode::Read); + if (old_dir == nullptr) + return nullptr; + auto new_dir = OpenDirectory(new_path, Mode::Read); + if (new_dir != nullptr) + return nullptr; + new_dir = CreateDirectory(new_path, Mode::Write); + if (new_dir == nullptr) + return nullptr; + + for (const auto& file : old_dir->GetFiles()) { + const auto x = CopyFile(old_path + '/' + file->GetName(), new_path + '/' + file->GetName()); + if (x == nullptr) + return nullptr; + } + + for (const auto& dir : old_dir->GetSubdirectories()) { + const auto x = + CopyDirectory(old_path + '/' + dir->GetName(), new_path + '/' + dir->GetName()); + if (x == nullptr) + return nullptr; + } + + return new_dir; +} + +VirtualDir VfsFilesystem::MoveDirectory(std::string_view old_path, std::string_view new_path) { + const auto sanitized_old_path = Common::FS::SanitizePath(old_path); + const auto sanitized_new_path = Common::FS::SanitizePath(new_path); + + // Non-default impls are highly encouraged to provide a more optimized version of this. + auto out = CopyDirectory(sanitized_old_path, sanitized_new_path); + if (out == nullptr) + return nullptr; + if (DeleteDirectory(sanitized_old_path)) + return out; + return nullptr; +} + +bool VfsFilesystem::DeleteDirectory(std::string_view path_) { + const auto path = Common::FS::SanitizePath(path_); + auto parent = OpenDirectory(Common::FS::GetParentPath(path), Mode::Write); + if (parent == nullptr) + return false; + return parent->DeleteSubdirectoryRecursive(Common::FS::GetFilename(path)); +} + +VfsFile::~VfsFile() = default; + +std::string VfsFile::GetExtension() const { + return std::string(Common::FS::GetExtensionFromFilename(GetName())); +} + +VfsDirectory::~VfsDirectory() = default; + +std::optional VfsFile::ReadByte(std::size_t offset) const { + u8 out{}; + const std::size_t size = Read(&out, sizeof(u8), offset); + if (size == 1) { + return out; + } + + return std::nullopt; +} + +std::vector VfsFile::ReadBytes(std::size_t size, std::size_t offset) const { + std::vector out(size); + std::size_t read_size = Read(out.data(), size, offset); + out.resize(read_size); + return out; +} + +std::vector VfsFile::ReadAllBytes() const { + return ReadBytes(GetSize()); +} + +bool VfsFile::WriteByte(u8 data, std::size_t offset) { + return Write(&data, 1, offset) == 1; +} + +std::size_t VfsFile::WriteBytes(const std::vector& data, std::size_t offset) { + return Write(data.data(), data.size(), offset); +} + +std::string VfsFile::GetFullPath() const { + if (GetContainingDirectory() == nullptr) + return '/' + GetName(); + + return GetContainingDirectory()->GetFullPath() + '/' + GetName(); +} + +VirtualFile VfsDirectory::GetFileRelative(std::string_view path) const { + auto vec = Common::FS::SplitPathComponents(path); + if (vec.empty()) { + return nullptr; + } + + if (vec.size() == 1) { + return GetFile(vec[0]); + } + + auto dir = GetSubdirectory(vec[0]); + for (std::size_t component = 1; component < vec.size() - 1; ++component) { + if (dir == nullptr) { + return nullptr; + } + + dir = dir->GetSubdirectory(vec[component]); + } + + if (dir == nullptr) { + return nullptr; + } + + return dir->GetFile(vec.back()); +} + +VirtualFile VfsDirectory::GetFileAbsolute(std::string_view path) const { + if (IsRoot()) { + return GetFileRelative(path); + } + + return GetParentDirectory()->GetFileAbsolute(path); +} + +VirtualDir VfsDirectory::GetDirectoryRelative(std::string_view path) const { + auto vec = Common::FS::SplitPathComponents(path); + if (vec.empty()) { + // TODO(DarkLordZach): Return this directory if path is '/' or similar. Can't currently + // because of const-ness + return nullptr; + } + + auto dir = GetSubdirectory(vec[0]); + for (std::size_t component = 1; component < vec.size(); ++component) { + if (dir == nullptr) { + return nullptr; + } + + dir = dir->GetSubdirectory(vec[component]); + } + + return dir; +} + +VirtualDir VfsDirectory::GetDirectoryAbsolute(std::string_view path) const { + if (IsRoot()) { + return GetDirectoryRelative(path); + } + + return GetParentDirectory()->GetDirectoryAbsolute(path); +} + +VirtualFile VfsDirectory::GetFile(std::string_view name) const { + const auto& files = GetFiles(); + const auto iter = std::find_if(files.begin(), files.end(), + [&name](const auto& file1) { return name == file1->GetName(); }); + return iter == files.end() ? nullptr : *iter; +} + +FileTimeStampRaw VfsDirectory::GetFileTimeStamp([[maybe_unused]] std::string_view path) const { + return {}; +} + +VirtualDir VfsDirectory::GetSubdirectory(std::string_view name) const { + const auto& subs = GetSubdirectories(); + const auto iter = std::find_if(subs.begin(), subs.end(), + [&name](const auto& file1) { return name == file1->GetName(); }); + return iter == subs.end() ? nullptr : *iter; +} + +bool VfsDirectory::IsRoot() const { + return GetParentDirectory() == nullptr; +} + +std::size_t VfsDirectory::GetSize() const { + const auto& files = GetFiles(); + const auto sum_sizes = [](const auto& range) { + return std::accumulate(range.begin(), range.end(), 0ULL, + [](const auto& f1, const auto& f2) { return f1 + f2->GetSize(); }); + }; + + const auto file_total = sum_sizes(files); + const auto& sub_dir = GetSubdirectories(); + const auto subdir_total = sum_sizes(sub_dir); + + return file_total + subdir_total; +} + +VirtualFile VfsDirectory::CreateFileRelative(std::string_view path) { + auto vec = Common::FS::SplitPathComponents(path); + if (vec.empty()) { + return nullptr; + } + + if (vec.size() == 1) { + return CreateFile(vec[0]); + } + + auto dir = GetSubdirectory(vec[0]); + if (dir == nullptr) { + dir = CreateSubdirectory(vec[0]); + if (dir == nullptr) { + return nullptr; + } + } + + return dir->CreateFileRelative(Common::FS::GetPathWithoutTop(path)); +} + +VirtualFile VfsDirectory::CreateFileAbsolute(std::string_view path) { + if (IsRoot()) { + return CreateFileRelative(path); + } + + return GetParentDirectory()->CreateFileAbsolute(path); +} + +VirtualDir VfsDirectory::CreateDirectoryRelative(std::string_view path) { + auto vec = Common::FS::SplitPathComponents(path); + if (vec.empty()) { + return nullptr; + } + + if (vec.size() == 1) { + return CreateSubdirectory(vec[0]); + } + + auto dir = GetSubdirectory(vec[0]); + if (dir == nullptr) { + dir = CreateSubdirectory(vec[0]); + if (dir == nullptr) { + return nullptr; + } + } + + return dir->CreateDirectoryRelative(Common::FS::GetPathWithoutTop(path)); +} + +VirtualDir VfsDirectory::CreateDirectoryAbsolute(std::string_view path) { + if (IsRoot()) { + return CreateDirectoryRelative(path); + } + + return GetParentDirectory()->CreateDirectoryAbsolute(path); +} + +bool VfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) { + auto dir = GetSubdirectory(name); + if (dir == nullptr) { + return false; + } + + bool success = true; + for (const auto& file : dir->GetFiles()) { + if (!DeleteFile(file->GetName())) { + success = false; + } + } + + for (const auto& sdir : dir->GetSubdirectories()) { + if (!dir->DeleteSubdirectoryRecursive(sdir->GetName())) { + success = false; + } + } + + return success; +} + +bool VfsDirectory::CleanSubdirectoryRecursive(std::string_view name) { + auto dir = GetSubdirectory(name); + if (dir == nullptr) { + return false; + } + + bool success = true; + for (const auto& file : dir->GetFiles()) { + if (!dir->DeleteFile(file->GetName())) { + success = false; + } + } + + for (const auto& sdir : dir->GetSubdirectories()) { + if (!dir->DeleteSubdirectoryRecursive(sdir->GetName())) { + success = false; + } + } + + return success; +} + +bool VfsDirectory::Copy(std::string_view src, std::string_view dest) { + const auto f1 = GetFile(src); + auto f2 = CreateFile(dest); + if (f1 == nullptr || f2 == nullptr) { + return false; + } + + if (!f2->Resize(f1->GetSize())) { + DeleteFile(dest); + return false; + } + + return f2->WriteBytes(f1->ReadAllBytes()) == f1->GetSize(); +} + +std::map> VfsDirectory::GetEntries() const { + std::map> out; + for (const auto& dir : GetSubdirectories()) + out.emplace(dir->GetName(), VfsEntryType::Directory); + for (const auto& file : GetFiles()) + out.emplace(file->GetName(), VfsEntryType::File); + return out; +} + +std::string VfsDirectory::GetFullPath() const { + if (IsRoot()) + return GetName(); + + return GetParentDirectory()->GetFullPath() + '/' + GetName(); +} + +bool ReadOnlyVfsDirectory::IsWritable() const { + return false; +} + +bool ReadOnlyVfsDirectory::IsReadable() const { + return true; +} + +VirtualDir ReadOnlyVfsDirectory::CreateSubdirectory(std::string_view name) { + return nullptr; +} + +VirtualFile ReadOnlyVfsDirectory::CreateFile(std::string_view name) { + return nullptr; +} + +VirtualFile ReadOnlyVfsDirectory::CreateFileAbsolute(std::string_view path) { + return nullptr; +} + +VirtualFile ReadOnlyVfsDirectory::CreateFileRelative(std::string_view path) { + return nullptr; +} + +VirtualDir ReadOnlyVfsDirectory::CreateDirectoryAbsolute(std::string_view path) { + return nullptr; +} + +VirtualDir ReadOnlyVfsDirectory::CreateDirectoryRelative(std::string_view path) { + return nullptr; +} + +bool ReadOnlyVfsDirectory::DeleteSubdirectory(std::string_view name) { + return false; +} + +bool ReadOnlyVfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) { + return false; +} + +bool ReadOnlyVfsDirectory::CleanSubdirectoryRecursive(std::string_view name) { + return false; +} + +bool ReadOnlyVfsDirectory::DeleteFile(std::string_view name) { + return false; +} + +bool ReadOnlyVfsDirectory::Rename(std::string_view name) { + return false; +} + +bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, std::size_t block_size) { + if (file1->GetSize() != file2->GetSize()) + return false; + + std::vector f1_v(block_size); + std::vector f2_v(block_size); + for (std::size_t i = 0; i < file1->GetSize(); i += block_size) { + auto f1_vs = file1->Read(f1_v.data(), block_size, i); + auto f2_vs = file2->Read(f2_v.data(), block_size, i); + + if (f1_vs != f2_vs) + return false; + auto iters = std::mismatch(f1_v.begin(), f1_v.end(), f2_v.begin(), f2_v.end()); + if (iters.first != f1_v.end() && iters.second != f2_v.end()) + return false; + } + + return true; +} + +bool VfsRawCopy(const VirtualFile& src, const VirtualFile& dest, std::size_t block_size) { + if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable()) + return false; + if (!dest->Resize(src->GetSize())) + return false; + + std::vector temp(std::min(block_size, src->GetSize())); + for (std::size_t i = 0; i < src->GetSize(); i += block_size) { + const auto read = std::min(block_size, src->GetSize() - i); + + if (src->Read(temp.data(), read, i) != read) { + return false; + } + + if (dest->Write(temp.data(), read, i) != read) { + return false; + } + } + + return true; +} + +bool VfsRawCopyD(const VirtualDir& src, const VirtualDir& dest, std::size_t block_size) { + if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable()) + return false; + + for (const auto& file : src->GetFiles()) { + const auto out = dest->CreateFile(file->GetName()); + if (!VfsRawCopy(file, out, block_size)) + return false; + } + + for (const auto& dir : src->GetSubdirectories()) { + const auto out = dest->CreateSubdirectory(dir->GetName()); + if (!VfsRawCopyD(dir, out, block_size)) + return false; + } + + return true; +} + +VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path) { + const auto res = rel->GetDirectoryRelative(path); + if (res == nullptr) + return rel->CreateDirectoryRelative(path); + return res; +} +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs.h b/src/core/file_sys/vfs/vfs.h new file mode 100644 index 000000000..6830244e3 --- /dev/null +++ b/src/core/file_sys/vfs/vfs.h @@ -0,0 +1,327 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include "common/common_funcs.h" +#include "common/common_types.h" +#include "core/file_sys/vfs/vfs_types.h" + +namespace FileSys { + +enum class Mode : u32; + +// An enumeration representing what can be at the end of a path in a VfsFilesystem +enum class VfsEntryType { + None, + File, + Directory, +}; + +// A class representing an abstract filesystem. A default implementation given the root VirtualDir +// is provided for convenience, but if the Vfs implementation has any additional state or +// functionality, they will need to override. +class VfsFilesystem { +public: + YUZU_NON_COPYABLE(VfsFilesystem); + YUZU_NON_MOVEABLE(VfsFilesystem); + + explicit VfsFilesystem(VirtualDir root); + virtual ~VfsFilesystem(); + + // Gets the friendly name for the filesystem. + virtual std::string GetName() const; + + // Return whether or not the user has read permissions on this filesystem. + virtual bool IsReadable() const; + // Return whether or not the user has write permission on this filesystem. + virtual bool IsWritable() const; + + // Determine if the entry at path is non-existent, a file, or a directory. + virtual VfsEntryType GetEntryType(std::string_view path) const; + + // Opens the file with path relative to root. If it doesn't exist, returns nullptr. + virtual VirtualFile OpenFile(std::string_view path, Mode perms); + // Creates a new, empty file at path + virtual VirtualFile CreateFile(std::string_view path, Mode perms); + // Copies the file from old_path to new_path, returning the new file on success and nullptr on + // failure. + virtual VirtualFile CopyFile(std::string_view old_path, std::string_view new_path); + // Moves the file from old_path to new_path, returning the moved file on success and nullptr on + // failure. + virtual VirtualFile MoveFile(std::string_view old_path, std::string_view new_path); + // Deletes the file with path relative to root, returning true on success. + virtual bool DeleteFile(std::string_view path); + + // Opens the directory with path relative to root. If it doesn't exist, returns nullptr. + virtual VirtualDir OpenDirectory(std::string_view path, Mode perms); + // Creates a new, empty directory at path + virtual VirtualDir CreateDirectory(std::string_view path, Mode perms); + // Copies the directory from old_path to new_path, returning the new directory on success and + // nullptr on failure. + virtual VirtualDir CopyDirectory(std::string_view old_path, std::string_view new_path); + // Moves the directory from old_path to new_path, returning the moved directory on success and + // nullptr on failure. + virtual VirtualDir MoveDirectory(std::string_view old_path, std::string_view new_path); + // Deletes the directory with path relative to root, returning true on success. + virtual bool DeleteDirectory(std::string_view path); + +protected: + // Root directory in default implementation. + VirtualDir root; +}; + +// A class representing a file in an abstract filesystem. +class VfsFile { +public: + YUZU_NON_COPYABLE(VfsFile); + YUZU_NON_MOVEABLE(VfsFile); + + VfsFile() = default; + virtual ~VfsFile(); + + // Retrieves the file name. + virtual std::string GetName() const = 0; + // Retrieves the extension of the file name. + virtual std::string GetExtension() const; + // Retrieves the size of the file. + virtual std::size_t GetSize() const = 0; + // Resizes the file to new_size. Returns whether or not the operation was successful. + virtual bool Resize(std::size_t new_size) = 0; + // Gets a pointer to the directory containing this file, returning nullptr if there is none. + virtual VirtualDir GetContainingDirectory() const = 0; + + // Returns whether or not the file can be written to. + virtual bool IsWritable() const = 0; + // Returns whether or not the file can be read from. + virtual bool IsReadable() const = 0; + + // The primary method of reading from the file. Reads length bytes into data starting at offset + // into file. Returns number of bytes successfully read. + virtual std::size_t Read(u8* data, std::size_t length, std::size_t offset = 0) const = 0; + // The primary method of writing to the file. Writes length bytes from data starting at offset + // into file. Returns number of bytes successfully written. + virtual std::size_t Write(const u8* data, std::size_t length, std::size_t offset = 0) = 0; + + // Reads exactly one byte at the offset provided, returning std::nullopt on error. + virtual std::optional ReadByte(std::size_t offset = 0) const; + // Reads size bytes starting at offset in file into a vector. + virtual std::vector ReadBytes(std::size_t size, std::size_t offset = 0) const; + // Reads all the bytes from the file into a vector. Equivalent to 'file->Read(file->GetSize(), + // 0)' + virtual std::vector ReadAllBytes() const; + + // Reads an array of type T, size number_elements starting at offset. + // Returns the number of bytes (sizeof(T)*number_elements) read successfully. + template + std::size_t ReadArray(T* data, std::size_t number_elements, std::size_t offset = 0) const { + static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); + + return Read(reinterpret_cast(data), number_elements * sizeof(T), offset); + } + + // Reads size bytes into the memory starting at data starting at offset into the file. + // Returns the number of bytes read successfully. + template + std::size_t ReadBytes(T* data, std::size_t size, std::size_t offset = 0) const { + static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); + return Read(reinterpret_cast(data), size, offset); + } + + // Reads one object of type T starting at offset in file. + // Returns the number of bytes read successfully (sizeof(T)). + template + std::size_t ReadObject(T* data, std::size_t offset = 0) const { + static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); + return Read(reinterpret_cast(data), sizeof(T), offset); + } + + // Writes exactly one byte to offset in file and returns whether or not the byte was written + // successfully. + virtual bool WriteByte(u8 data, std::size_t offset = 0); + // Writes a vector of bytes to offset in file and returns the number of bytes successfully + // written. + virtual std::size_t WriteBytes(const std::vector& data, std::size_t offset = 0); + + // Writes an array of type T, size number_elements to offset in file. + // Returns the number of bytes (sizeof(T)*number_elements) written successfully. + template + std::size_t WriteArray(const T* data, std::size_t number_elements, std::size_t offset = 0) { + static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); + return Write(reinterpret_cast(data), number_elements * sizeof(T), offset); + } + + // Writes size bytes starting at memory location data to offset in file. + // Returns the number of bytes written successfully. + template + std::size_t WriteBytes(const T* data, std::size_t size, std::size_t offset = 0) { + static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); + return Write(reinterpret_cast(data), size, offset); + } + + // Writes one object of type T to offset in file. + // Returns the number of bytes written successfully (sizeof(T)). + template + std::size_t WriteObject(const T& data, std::size_t offset = 0) { + static_assert(std::is_trivially_copyable_v, "Data type must be trivially copyable."); + return Write(reinterpret_cast(&data), sizeof(T), offset); + } + + // Renames the file to name. Returns whether or not the operation was successful. + virtual bool Rename(std::string_view name) = 0; + + // Returns the full path of this file as a string, recursively + virtual std::string GetFullPath() const; +}; + +// A class representing a directory in an abstract filesystem. +class VfsDirectory { +public: + YUZU_NON_COPYABLE(VfsDirectory); + YUZU_NON_MOVEABLE(VfsDirectory); + + VfsDirectory() = default; + virtual ~VfsDirectory(); + + // Retrieves the file located at path as if the current directory was root. Returns nullptr if + // not found. + virtual VirtualFile GetFileRelative(std::string_view path) const; + // Calls GetFileRelative(path) on the root of the current directory. + virtual VirtualFile GetFileAbsolute(std::string_view path) const; + + // Retrieves the directory located at path as if the current directory was root. Returns nullptr + // if not found. + virtual VirtualDir GetDirectoryRelative(std::string_view path) const; + // Calls GetDirectoryRelative(path) on the root of the current directory. + virtual VirtualDir GetDirectoryAbsolute(std::string_view path) const; + + // Returns a vector containing all of the files in this directory. + virtual std::vector GetFiles() const = 0; + // Returns the file with filename matching name. Returns nullptr if directory doesn't have a + // file with name. + virtual VirtualFile GetFile(std::string_view name) const; + + // Returns a struct containing the file's timestamp. + virtual FileTimeStampRaw GetFileTimeStamp(std::string_view path) const; + + // Returns a vector containing all of the subdirectories in this directory. + virtual std::vector GetSubdirectories() const = 0; + // Returns the directory with name matching name. Returns nullptr if directory doesn't have a + // directory with name. + virtual VirtualDir GetSubdirectory(std::string_view name) const; + + // Returns whether or not the directory can be written to. + virtual bool IsWritable() const = 0; + // Returns whether of not the directory can be read from. + virtual bool IsReadable() const = 0; + + // Returns whether or not the directory is the root of the current file tree. + virtual bool IsRoot() const; + + // Returns the name of the directory. + virtual std::string GetName() const = 0; + // Returns the total size of all files and subdirectories in this directory. + virtual std::size_t GetSize() const; + // Returns the parent directory of this directory. Returns nullptr if this directory is root or + // has no parent. + virtual VirtualDir GetParentDirectory() const = 0; + + // Creates a new subdirectory with name name. Returns a pointer to the new directory or nullptr + // if the operation failed. + virtual VirtualDir CreateSubdirectory(std::string_view name) = 0; + // Creates a new file with name name. Returns a pointer to the new file or nullptr if the + // operation failed. + virtual VirtualFile CreateFile(std::string_view name) = 0; + + // Creates a new file at the path relative to this directory. Also creates directories if + // they do not exist and is supported by this implementation. Returns nullptr on any failure. + virtual VirtualFile CreateFileRelative(std::string_view path); + + // Creates a new file at the path relative to root of this directory. Also creates directories + // if they do not exist and is supported by this implementation. Returns nullptr on any failure. + virtual VirtualFile CreateFileAbsolute(std::string_view path); + + // Creates a new directory at the path relative to this directory. Also creates directories if + // they do not exist and is supported by this implementation. Returns nullptr on any failure. + virtual VirtualDir CreateDirectoryRelative(std::string_view path); + + // Creates a new directory at the path relative to root of this directory. Also creates + // directories if they do not exist and is supported by this implementation. Returns nullptr on + // any failure. + virtual VirtualDir CreateDirectoryAbsolute(std::string_view path); + + // Deletes the subdirectory with the given name and returns true on success. + virtual bool DeleteSubdirectory(std::string_view name) = 0; + + // Deletes all subdirectories and files within the provided directory and then deletes + // the directory itself. Returns true on success. + virtual bool DeleteSubdirectoryRecursive(std::string_view name); + + // Deletes all subdirectories and files within the provided directory. + // Unlike DeleteSubdirectoryRecursive, this does not delete the provided directory. + virtual bool CleanSubdirectoryRecursive(std::string_view name); + + // Returns whether or not the file with name name was deleted successfully. + virtual bool DeleteFile(std::string_view name) = 0; + + // Returns whether or not this directory was renamed to name. + virtual bool Rename(std::string_view name) = 0; + + // Returns whether or not the file with name src was successfully copied to a new file with name + // dest. + virtual bool Copy(std::string_view src, std::string_view dest); + + // Gets all of the entries directly in the directory (files and dirs), returning a map between + // item name -> type. + virtual std::map> GetEntries() const; + + // Returns the full path of this directory as a string, recursively + virtual std::string GetFullPath() const; +}; + +// A convenience partial-implementation of VfsDirectory that stubs out methods that should only work +// if writable. This is to avoid redundant empty methods everywhere. +class ReadOnlyVfsDirectory : public VfsDirectory { +public: + bool IsWritable() const override; + bool IsReadable() const override; + VirtualDir CreateSubdirectory(std::string_view name) override; + VirtualFile CreateFile(std::string_view name) override; + VirtualFile CreateFileAbsolute(std::string_view path) override; + VirtualFile CreateFileRelative(std::string_view path) override; + VirtualDir CreateDirectoryAbsolute(std::string_view path) override; + VirtualDir CreateDirectoryRelative(std::string_view path) override; + bool DeleteSubdirectory(std::string_view name) override; + bool DeleteSubdirectoryRecursive(std::string_view name) override; + bool CleanSubdirectoryRecursive(std::string_view name) override; + bool DeleteFile(std::string_view name) override; + bool Rename(std::string_view name) override; +}; + +// Compare the two files, byte-for-byte, in increments specified by block_size +bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, + std::size_t block_size = 0x1000); + +// A method that copies the raw data between two different implementations of VirtualFile. If you +// are using the same implementation, it is probably better to use the Copy method in the parent +// directory of src/dest. +bool VfsRawCopy(const VirtualFile& src, const VirtualFile& dest, std::size_t block_size = 0x1000); + +// A method that performs a similar function to VfsRawCopy above, but instead copies entire +// directories. It suffers the same performance penalties as above and an implementation-specific +// Copy should always be preferred. +bool VfsRawCopyD(const VirtualDir& src, const VirtualDir& dest, std::size_t block_size = 0x1000); + +// Checks if the directory at path relative to rel exists. If it does, returns that. If it does not +// it attempts to create it and returns the new dir or nullptr on failure. +VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path); + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_cached.cpp b/src/core/file_sys/vfs/vfs_cached.cpp new file mode 100644 index 000000000..01cd0f1e0 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_cached.cpp @@ -0,0 +1,63 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core/file_sys/vfs/vfs_cached.h" +#include "core/file_sys/vfs/vfs_types.h" + +namespace FileSys { + +CachedVfsDirectory::CachedVfsDirectory(VirtualDir&& source_dir) + : name(source_dir->GetName()), parent(source_dir->GetParentDirectory()) { + for (auto& dir : source_dir->GetSubdirectories()) { + dirs.emplace(dir->GetName(), std::make_shared(std::move(dir))); + } + for (auto& file : source_dir->GetFiles()) { + files.emplace(file->GetName(), std::move(file)); + } +} + +CachedVfsDirectory::~CachedVfsDirectory() = default; + +VirtualFile CachedVfsDirectory::GetFile(std::string_view file_name) const { + auto it = files.find(file_name); + if (it != files.end()) { + return it->second; + } + + return nullptr; +} + +VirtualDir CachedVfsDirectory::GetSubdirectory(std::string_view dir_name) const { + auto it = dirs.find(dir_name); + if (it != dirs.end()) { + return it->second; + } + + return nullptr; +} + +std::vector CachedVfsDirectory::GetFiles() const { + std::vector out; + for (auto& [file_name, file] : files) { + out.push_back(file); + } + return out; +} + +std::vector CachedVfsDirectory::GetSubdirectories() const { + std::vector out; + for (auto& [dir_name, dir] : dirs) { + out.push_back(dir); + } + return out; +} + +std::string CachedVfsDirectory::GetName() const { + return name; +} + +VirtualDir CachedVfsDirectory::GetParentDirectory() const { + return parent; +} + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_cached.h b/src/core/file_sys/vfs/vfs_cached.h new file mode 100644 index 000000000..47dff7224 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_cached.h @@ -0,0 +1,31 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include "core/file_sys/vfs/vfs.h" + +namespace FileSys { + +class CachedVfsDirectory : public ReadOnlyVfsDirectory { +public: + CachedVfsDirectory(VirtualDir&& source_directory); + + ~CachedVfsDirectory() override; + VirtualFile GetFile(std::string_view file_name) const override; + VirtualDir GetSubdirectory(std::string_view dir_name) const override; + std::vector GetFiles() const override; + std::vector GetSubdirectories() const override; + std::string GetName() const override; + VirtualDir GetParentDirectory() const override; + +private: + std::string name; + VirtualDir parent; + std::map> dirs; + std::map> files; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_concat.cpp b/src/core/file_sys/vfs/vfs_concat.cpp new file mode 100644 index 000000000..b5cc9a9e9 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_concat.cpp @@ -0,0 +1,192 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include + +#include "common/assert.h" +#include "core/file_sys/vfs/vfs_concat.h" +#include "core/file_sys/vfs/vfs_static.h" + +namespace FileSys { + +ConcatenatedVfsFile::ConcatenatedVfsFile(std::string&& name_, ConcatenationMap&& concatenation_map_) + : concatenation_map(std::move(concatenation_map_)), name(std::move(name_)) { + DEBUG_ASSERT(this->VerifyContinuity()); +} + +bool ConcatenatedVfsFile::VerifyContinuity() const { + u64 last_offset = 0; + for (auto& entry : concatenation_map) { + if (entry.offset != last_offset) { + return false; + } + + last_offset = entry.offset + entry.file->GetSize(); + } + + return true; +} + +ConcatenatedVfsFile::~ConcatenatedVfsFile() = default; + +VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::string&& name, + std::vector&& files) { + // Fold trivial cases. + if (files.empty()) { + return nullptr; + } + if (files.size() == 1) { + return files.front(); + } + + // Make the concatenation map from the input. + std::vector concatenation_map; + concatenation_map.reserve(files.size()); + u64 last_offset = 0; + + for (auto& file : files) { + const auto size = file->GetSize(); + + concatenation_map.emplace_back(ConcatenationEntry{ + .offset = last_offset, + .file = std::move(file), + }); + + last_offset += size; + } + + return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map))); +} + +VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile( + u8 filler_byte, std::string&& name, std::vector>&& files) { + // Fold trivial cases. + if (files.empty()) { + return nullptr; + } + if (files.size() == 1) { + return files.begin()->second; + } + + // Make the concatenation map from the input. + std::vector concatenation_map; + + concatenation_map.reserve(files.size()); + u64 last_offset = 0; + + // Iteration of a multimap is ordered, so offset will be strictly non-decreasing. + for (auto& [offset, file] : files) { + const auto size = file->GetSize(); + + if (offset > last_offset) { + concatenation_map.emplace_back(ConcatenationEntry{ + .offset = last_offset, + .file = std::make_shared(filler_byte, offset - last_offset), + }); + } + + concatenation_map.emplace_back(ConcatenationEntry{ + .offset = offset, + .file = std::move(file), + }); + + last_offset = offset + size; + } + + return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map))); +} + +std::string ConcatenatedVfsFile::GetName() const { + if (concatenation_map.empty()) { + return ""; + } + if (!name.empty()) { + return name; + } + return concatenation_map.front().file->GetName(); +} + +std::size_t ConcatenatedVfsFile::GetSize() const { + if (concatenation_map.empty()) { + return 0; + } + return concatenation_map.back().offset + concatenation_map.back().file->GetSize(); +} + +bool ConcatenatedVfsFile::Resize(std::size_t new_size) { + return false; +} + +VirtualDir ConcatenatedVfsFile::GetContainingDirectory() const { + if (concatenation_map.empty()) { + return nullptr; + } + return concatenation_map.front().file->GetContainingDirectory(); +} + +bool ConcatenatedVfsFile::IsWritable() const { + return false; +} + +bool ConcatenatedVfsFile::IsReadable() const { + return true; +} + +std::size_t ConcatenatedVfsFile::Read(u8* data, std::size_t length, std::size_t offset) const { + const ConcatenationEntry key{ + .offset = offset, + .file = nullptr, + }; + + // Read nothing if the map is empty. + if (concatenation_map.empty()) { + return 0; + } + + // Binary search to find the iterator to the first position we can check. + // It must exist, since we are not empty and are comparing unsigned integers. + auto it = std::prev(std::upper_bound(concatenation_map.begin(), concatenation_map.end(), key)); + u64 cur_length = length; + u64 cur_offset = offset; + + while (cur_length > 0 && it != concatenation_map.end()) { + // Check if we can read the file at this position. + const auto& file = it->file; + const u64 map_offset = it->offset; + const u64 file_size = file->GetSize(); + + if (cur_offset > map_offset + file_size) { + // Entirely out of bounds read. + break; + } + + // Read the file at this position. + const u64 file_seek = cur_offset - map_offset; + const u64 intended_read_size = std::min(cur_length, file_size - file_seek); + const u64 actual_read_size = + file->Read(data + (cur_offset - offset), intended_read_size, file_seek); + + // Update tracking. + cur_offset += actual_read_size; + cur_length -= actual_read_size; + it++; + + // If we encountered a short read, we're done. + if (actual_read_size < intended_read_size) { + break; + } + } + + return cur_offset - offset; +} + +std::size_t ConcatenatedVfsFile::Write(const u8* data, std::size_t length, std::size_t offset) { + return 0; +} + +bool ConcatenatedVfsFile::Rename(std::string_view new_name) { + return false; +} + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_concat.h b/src/core/file_sys/vfs/vfs_concat.h new file mode 100644 index 000000000..6d12af762 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_concat.h @@ -0,0 +1,57 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include +#include "core/file_sys/vfs/vfs.h" + +namespace FileSys { + +// Class that wraps multiple vfs files and concatenates them, making reads seamless. Currently +// read-only. +class ConcatenatedVfsFile : public VfsFile { +private: + struct ConcatenationEntry { + u64 offset; + VirtualFile file; + + auto operator<=>(const ConcatenationEntry& other) const { + return this->offset <=> other.offset; + } + }; + using ConcatenationMap = std::vector; + + explicit ConcatenatedVfsFile(std::string&& name, + std::vector&& concatenation_map); + bool VerifyContinuity() const; + +public: + ~ConcatenatedVfsFile() override; + + /// Wrapper function to allow for more efficient handling of files.size() == 0, 1 cases. + static VirtualFile MakeConcatenatedFile(std::string&& name, std::vector&& files); + + /// Convenience function that turns a map of offsets to files into a concatenated file, filling + /// gaps with a given filler byte. + static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::string&& name, + std::vector>&& files); + + std::string GetName() const override; + std::size_t GetSize() const override; + bool Resize(std::size_t new_size) override; + VirtualDir GetContainingDirectory() const override; + bool IsWritable() const override; + bool IsReadable() const override; + std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override; + std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override; + bool Rename(std::string_view new_name) override; + +private: + ConcatenationMap concatenation_map; + std::string name; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_layered.cpp b/src/core/file_sys/vfs/vfs_layered.cpp new file mode 100644 index 000000000..47b2a3c78 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_layered.cpp @@ -0,0 +1,132 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include +#include +#include +#include "core/file_sys/vfs/vfs_layered.h" + +namespace FileSys { + +LayeredVfsDirectory::LayeredVfsDirectory(std::vector dirs_, std::string name_) + : dirs(std::move(dirs_)), name(std::move(name_)) {} + +LayeredVfsDirectory::~LayeredVfsDirectory() = default; + +VirtualDir LayeredVfsDirectory::MakeLayeredDirectory(std::vector dirs, + std::string name) { + if (dirs.empty()) + return nullptr; + if (dirs.size() == 1) + return dirs[0]; + + return VirtualDir(new LayeredVfsDirectory(std::move(dirs), std::move(name))); +} + +VirtualFile LayeredVfsDirectory::GetFileRelative(std::string_view path) const { + for (const auto& layer : dirs) { + const auto file = layer->GetFileRelative(path); + if (file != nullptr) + return file; + } + + return nullptr; +} + +VirtualDir LayeredVfsDirectory::GetDirectoryRelative(std::string_view path) const { + std::vector out; + for (const auto& layer : dirs) { + auto dir = layer->GetDirectoryRelative(path); + if (dir != nullptr) { + out.emplace_back(std::move(dir)); + } + } + + return MakeLayeredDirectory(std::move(out)); +} + +VirtualFile LayeredVfsDirectory::GetFile(std::string_view file_name) const { + return GetFileRelative(file_name); +} + +VirtualDir LayeredVfsDirectory::GetSubdirectory(std::string_view subdir_name) const { + return GetDirectoryRelative(subdir_name); +} + +std::string LayeredVfsDirectory::GetFullPath() const { + return dirs[0]->GetFullPath(); +} + +std::vector LayeredVfsDirectory::GetFiles() const { + std::vector out; + std::unordered_set out_names; + + for (const auto& layer : dirs) { + for (auto& file : layer->GetFiles()) { + const auto [it, is_new] = out_names.emplace(file->GetName()); + if (is_new) { + out.emplace_back(std::move(file)); + } + } + } + + return out; +} + +std::vector LayeredVfsDirectory::GetSubdirectories() const { + std::vector out; + std::unordered_set out_names; + + for (const auto& layer : dirs) { + for (const auto& sd : layer->GetSubdirectories()) { + out_names.emplace(sd->GetName()); + } + } + + out.reserve(out_names.size()); + for (const auto& subdir : out_names) { + out.emplace_back(GetSubdirectory(subdir)); + } + + return out; +} + +bool LayeredVfsDirectory::IsWritable() const { + return false; +} + +bool LayeredVfsDirectory::IsReadable() const { + return true; +} + +std::string LayeredVfsDirectory::GetName() const { + return name.empty() ? dirs[0]->GetName() : name; +} + +VirtualDir LayeredVfsDirectory::GetParentDirectory() const { + return dirs[0]->GetParentDirectory(); +} + +VirtualDir LayeredVfsDirectory::CreateSubdirectory(std::string_view subdir_name) { + return nullptr; +} + +VirtualFile LayeredVfsDirectory::CreateFile(std::string_view file_name) { + return nullptr; +} + +bool LayeredVfsDirectory::DeleteSubdirectory(std::string_view subdir_name) { + return false; +} + +bool LayeredVfsDirectory::DeleteFile(std::string_view file_name) { + return false; +} + +bool LayeredVfsDirectory::Rename(std::string_view new_name) { + name = new_name; + return true; +} + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_layered.h b/src/core/file_sys/vfs/vfs_layered.h new file mode 100644 index 000000000..0027ffa9a --- /dev/null +++ b/src/core/file_sys/vfs/vfs_layered.h @@ -0,0 +1,46 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include "core/file_sys/vfs/vfs.h" + +namespace FileSys { + +// Class that stacks multiple VfsDirectories on top of each other, attempting to read from the first +// one and falling back to the one after. The highest priority directory (overwrites all others) +// should be element 0 in the dirs vector. +class LayeredVfsDirectory : public VfsDirectory { + explicit LayeredVfsDirectory(std::vector dirs_, std::string name_); + +public: + ~LayeredVfsDirectory() override; + + /// Wrapper function to allow for more efficient handling of dirs.size() == 0, 1 cases. + static VirtualDir MakeLayeredDirectory(std::vector dirs, std::string name = ""); + + VirtualFile GetFileRelative(std::string_view path) const override; + VirtualDir GetDirectoryRelative(std::string_view path) const override; + VirtualFile GetFile(std::string_view file_name) const override; + VirtualDir GetSubdirectory(std::string_view subdir_name) const override; + std::string GetFullPath() const override; + + std::vector GetFiles() const override; + std::vector GetSubdirectories() const override; + bool IsWritable() const override; + bool IsReadable() const override; + std::string GetName() const override; + VirtualDir GetParentDirectory() const override; + VirtualDir CreateSubdirectory(std::string_view subdir_name) override; + VirtualFile CreateFile(std::string_view file_name) override; + bool DeleteSubdirectory(std::string_view subdir_name) override; + bool DeleteFile(std::string_view file_name) override; + bool Rename(std::string_view new_name) override; + +private: + std::vector dirs; + std::string name; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_offset.cpp b/src/core/file_sys/vfs/vfs_offset.cpp new file mode 100644 index 000000000..1a37d2670 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_offset.cpp @@ -0,0 +1,98 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include + +#include "core/file_sys/vfs/vfs_offset.h" + +namespace FileSys { + +OffsetVfsFile::OffsetVfsFile(VirtualFile file_, std::size_t size_, std::size_t offset_, + std::string name_, VirtualDir parent_) + : file(file_), offset(offset_), size(size_), name(std::move(name_)), + parent(parent_ == nullptr ? file->GetContainingDirectory() : std::move(parent_)) {} + +OffsetVfsFile::~OffsetVfsFile() = default; + +std::string OffsetVfsFile::GetName() const { + return name.empty() ? file->GetName() : name; +} + +std::size_t OffsetVfsFile::GetSize() const { + return size; +} + +bool OffsetVfsFile::Resize(std::size_t new_size) { + if (offset + new_size < file->GetSize()) { + size = new_size; + } else { + auto res = file->Resize(offset + new_size); + if (!res) + return false; + size = new_size; + } + + return true; +} + +VirtualDir OffsetVfsFile::GetContainingDirectory() const { + return parent; +} + +bool OffsetVfsFile::IsWritable() const { + return file->IsWritable(); +} + +bool OffsetVfsFile::IsReadable() const { + return file->IsReadable(); +} + +std::size_t OffsetVfsFile::Read(u8* data, std::size_t length, std::size_t r_offset) const { + return file->Read(data, TrimToFit(length, r_offset), offset + r_offset); +} + +std::size_t OffsetVfsFile::Write(const u8* data, std::size_t length, std::size_t r_offset) { + return file->Write(data, TrimToFit(length, r_offset), offset + r_offset); +} + +std::optional OffsetVfsFile::ReadByte(std::size_t r_offset) const { + if (r_offset >= size) { + return std::nullopt; + } + + return file->ReadByte(offset + r_offset); +} + +std::vector OffsetVfsFile::ReadBytes(std::size_t r_size, std::size_t r_offset) const { + return file->ReadBytes(TrimToFit(r_size, r_offset), offset + r_offset); +} + +std::vector OffsetVfsFile::ReadAllBytes() const { + return file->ReadBytes(size, offset); +} + +bool OffsetVfsFile::WriteByte(u8 data, std::size_t r_offset) { + if (r_offset < size) + return file->WriteByte(data, offset + r_offset); + + return false; +} + +std::size_t OffsetVfsFile::WriteBytes(const std::vector& data, std::size_t r_offset) { + return file->Write(data.data(), TrimToFit(data.size(), r_offset), offset + r_offset); +} + +bool OffsetVfsFile::Rename(std::string_view new_name) { + return file->Rename(new_name); +} + +std::size_t OffsetVfsFile::GetOffset() const { + return offset; +} + +std::size_t OffsetVfsFile::TrimToFit(std::size_t r_size, std::size_t r_offset) const { + return std::clamp(r_size, std::size_t{0}, size - r_offset); +} + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_offset.h b/src/core/file_sys/vfs/vfs_offset.h new file mode 100644 index 000000000..4abe41d8e --- /dev/null +++ b/src/core/file_sys/vfs/vfs_offset.h @@ -0,0 +1,50 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include + +#include "core/file_sys/vfs/vfs.h" + +namespace FileSys { + +// An implementation of VfsFile that wraps around another VfsFile at a certain offset. +// Similar to seeking to an offset. +// If the file is writable, operations that would write past the end of the offset file will expand +// the size of this wrapper. +class OffsetVfsFile : public VfsFile { +public: + OffsetVfsFile(VirtualFile file, std::size_t size, std::size_t offset = 0, + std::string new_name = "", VirtualDir new_parent = nullptr); + ~OffsetVfsFile() override; + + std::string GetName() const override; + std::size_t GetSize() const override; + bool Resize(std::size_t new_size) override; + VirtualDir GetContainingDirectory() const override; + bool IsWritable() const override; + bool IsReadable() const override; + std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override; + std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override; + std::optional ReadByte(std::size_t offset) const override; + std::vector ReadBytes(std::size_t size, std::size_t offset) const override; + std::vector ReadAllBytes() const override; + bool WriteByte(u8 data, std::size_t offset) override; + std::size_t WriteBytes(const std::vector& data, std::size_t offset) override; + + bool Rename(std::string_view new_name) override; + + std::size_t GetOffset() const; + +private: + std::size_t TrimToFit(std::size_t r_size, std::size_t r_offset) const; + + VirtualFile file; + std::size_t offset; + std::size_t size; + std::string name; + VirtualDir parent; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_real.cpp b/src/core/file_sys/vfs/vfs_real.cpp new file mode 100644 index 000000000..1e6d8163b --- /dev/null +++ b/src/core/file_sys/vfs/vfs_real.cpp @@ -0,0 +1,528 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include +#include +#include +#include "common/assert.h" +#include "common/fs/file.h" +#include "common/fs/fs.h" +#include "common/fs/path_util.h" +#include "common/logging/log.h" +#include "core/file_sys/vfs/vfs.h" +#include "core/file_sys/vfs/vfs_real.h" + +// For FileTimeStampRaw +#include + +#ifdef _MSC_VER +#define stat _stat64 +#endif + +namespace FileSys { + +namespace FS = Common::FS; + +namespace { + +constexpr size_t MaxOpenFiles = 512; + +constexpr FS::FileAccessMode ModeFlagsToFileAccessMode(Mode mode) { + switch (mode) { + case Mode::Read: + return FS::FileAccessMode::Read; + case Mode::Write: + case Mode::ReadWrite: + case Mode::Append: + case Mode::ReadAppend: + case Mode::WriteAppend: + case Mode::All: + return FS::FileAccessMode::ReadWrite; + default: + return {}; + } +} + +} // Anonymous namespace + +RealVfsFilesystem::RealVfsFilesystem() : VfsFilesystem(nullptr) {} +RealVfsFilesystem::~RealVfsFilesystem() = default; + +std::string RealVfsFilesystem::GetName() const { + return "Real"; +} + +bool RealVfsFilesystem::IsReadable() const { + return true; +} + +bool RealVfsFilesystem::IsWritable() const { + return true; +} + +VfsEntryType RealVfsFilesystem::GetEntryType(std::string_view path_) const { + const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); + if (!FS::Exists(path)) { + return VfsEntryType::None; + } + if (FS::IsDir(path)) { + return VfsEntryType::Directory; + } + + return VfsEntryType::File; +} + +VirtualFile RealVfsFilesystem::OpenFileFromEntry(std::string_view path_, std::optional size, + Mode perms) { + const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); + std::scoped_lock lk{list_lock}; + + if (auto it = cache.find(path); it != cache.end()) { + if (auto file = it->second.lock(); file) { + return file; + } + } + + if (!size && !FS::IsFile(path)) { + return nullptr; + } + + auto reference = std::make_unique(); + this->InsertReferenceIntoListLocked(*reference); + + auto file = std::shared_ptr( + new RealVfsFile(*this, std::move(reference), path, perms, size)); + cache[path] = file; + + return file; +} + +VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, Mode perms) { + return OpenFileFromEntry(path_, {}, perms); +} + +VirtualFile RealVfsFilesystem::CreateFile(std::string_view path_, Mode perms) { + const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); + { + std::scoped_lock lk{list_lock}; + cache.erase(path); + } + + // Current usages of CreateFile expect to delete the contents of an existing file. + if (FS::IsFile(path)) { + FS::IOFile temp{path, FS::FileAccessMode::Write, FS::FileType::BinaryFile}; + + if (!temp.IsOpen()) { + return nullptr; + } + + temp.Close(); + + return OpenFile(path, perms); + } + + if (!FS::NewFile(path)) { + return nullptr; + } + + return OpenFile(path, perms); +} + +VirtualFile RealVfsFilesystem::CopyFile(std::string_view old_path_, std::string_view new_path_) { + // Unused + return nullptr; +} + +VirtualFile RealVfsFilesystem::MoveFile(std::string_view old_path_, std::string_view new_path_) { + const auto old_path = FS::SanitizePath(old_path_, FS::DirectorySeparator::PlatformDefault); + const auto new_path = FS::SanitizePath(new_path_, FS::DirectorySeparator::PlatformDefault); + { + std::scoped_lock lk{list_lock}; + cache.erase(old_path); + cache.erase(new_path); + } + if (!FS::RenameFile(old_path, new_path)) { + return nullptr; + } + return OpenFile(new_path, Mode::ReadWrite); +} + +bool RealVfsFilesystem::DeleteFile(std::string_view path_) { + const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); + { + std::scoped_lock lk{list_lock}; + cache.erase(path); + } + return FS::RemoveFile(path); +} + +VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, Mode perms) { + const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); + return std::shared_ptr(new RealVfsDirectory(*this, path, perms)); +} + +VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, Mode perms) { + const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); + if (!FS::CreateDirs(path)) { + return nullptr; + } + return std::shared_ptr(new RealVfsDirectory(*this, path, perms)); +} + +VirtualDir RealVfsFilesystem::CopyDirectory(std::string_view old_path_, + std::string_view new_path_) { + // Unused + return nullptr; +} + +VirtualDir RealVfsFilesystem::MoveDirectory(std::string_view old_path_, + std::string_view new_path_) { + const auto old_path = FS::SanitizePath(old_path_, FS::DirectorySeparator::PlatformDefault); + const auto new_path = FS::SanitizePath(new_path_, FS::DirectorySeparator::PlatformDefault); + + if (!FS::RenameDir(old_path, new_path)) { + return nullptr; + } + return OpenDirectory(new_path, Mode::ReadWrite); +} + +bool RealVfsFilesystem::DeleteDirectory(std::string_view path_) { + const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); + return FS::RemoveDirRecursively(path); +} + +std::unique_lock RealVfsFilesystem::RefreshReference(const std::string& path, + Mode perms, + FileReference& reference) { + std::unique_lock lk{list_lock}; + + // Temporarily remove from list. + this->RemoveReferenceFromListLocked(reference); + + // Restore file if needed. + if (!reference.file) { + this->EvictSingleReferenceLocked(); + + reference.file = + FS::FileOpen(path, ModeFlagsToFileAccessMode(perms), FS::FileType::BinaryFile); + if (reference.file) { + num_open_files++; + } + } + + // Reinsert into list. + this->InsertReferenceIntoListLocked(reference); + + return lk; +} + +void RealVfsFilesystem::DropReference(std::unique_ptr&& reference) { + std::scoped_lock lk{list_lock}; + + // Remove from list. + this->RemoveReferenceFromListLocked(*reference); + + // Close the file. + if (reference->file) { + reference->file.reset(); + num_open_files--; + } +} + +void RealVfsFilesystem::EvictSingleReferenceLocked() { + if (num_open_files < MaxOpenFiles || open_references.empty()) { + return; + } + + // Get and remove from list. + auto& reference = open_references.back(); + this->RemoveReferenceFromListLocked(reference); + + // Close the file. + if (reference.file) { + reference.file.reset(); + num_open_files--; + } + + // Reinsert into closed list. + this->InsertReferenceIntoListLocked(reference); +} + +void RealVfsFilesystem::InsertReferenceIntoListLocked(FileReference& reference) { + if (reference.file) { + open_references.push_front(reference); + } else { + closed_references.push_front(reference); + } +} + +void RealVfsFilesystem::RemoveReferenceFromListLocked(FileReference& reference) { + if (reference.file) { + open_references.erase(open_references.iterator_to(reference)); + } else { + closed_references.erase(closed_references.iterator_to(reference)); + } +} + +RealVfsFile::RealVfsFile(RealVfsFilesystem& base_, std::unique_ptr reference_, + const std::string& path_, Mode perms_, std::optional size_) + : base(base_), reference(std::move(reference_)), path(path_), + parent_path(FS::GetParentPath(path_)), path_components(FS::SplitPathComponentsCopy(path_)), + size(size_), perms(perms_) {} + +RealVfsFile::~RealVfsFile() { + base.DropReference(std::move(reference)); +} + +std::string RealVfsFile::GetName() const { + return path_components.empty() ? "" : std::string(path_components.back()); +} + +std::size_t RealVfsFile::GetSize() const { + if (size) { + return *size; + } + auto lk = base.RefreshReference(path, perms, *reference); + return reference->file ? reference->file->GetSize() : 0; +} + +bool RealVfsFile::Resize(std::size_t new_size) { + size.reset(); + auto lk = base.RefreshReference(path, perms, *reference); + return reference->file ? reference->file->SetSize(new_size) : false; +} + +VirtualDir RealVfsFile::GetContainingDirectory() const { + return base.OpenDirectory(parent_path, perms); +} + +bool RealVfsFile::IsWritable() const { + return True(perms & Mode::Write); +} + +bool RealVfsFile::IsReadable() const { + return True(perms & Mode::Read); +} + +std::size_t RealVfsFile::Read(u8* data, std::size_t length, std::size_t offset) const { + auto lk = base.RefreshReference(path, perms, *reference); + if (!reference->file || !reference->file->Seek(static_cast(offset))) { + return 0; + } + return reference->file->ReadSpan(std::span{data, length}); +} + +std::size_t RealVfsFile::Write(const u8* data, std::size_t length, std::size_t offset) { + size.reset(); + auto lk = base.RefreshReference(path, perms, *reference); + if (!reference->file || !reference->file->Seek(static_cast(offset))) { + return 0; + } + return reference->file->WriteSpan(std::span{data, length}); +} + +bool RealVfsFile::Rename(std::string_view name) { + return base.MoveFile(path, parent_path + '/' + std::string(name)) != nullptr; +} + +// TODO(DarkLordZach): MSVC would not let me combine the following two functions using 'if +// constexpr' because there is a compile error in the branch not used. + +template <> +std::vector RealVfsDirectory::IterateEntries() const { + if (perms == Mode::Append) { + return {}; + } + + std::vector out; + + const FS::DirEntryCallable callback = [this, + &out](const std::filesystem::directory_entry& entry) { + const auto full_path_string = FS::PathToUTF8String(entry.path()); + + out.emplace_back(base.OpenFileFromEntry(full_path_string, entry.file_size(), perms)); + + return true; + }; + + FS::IterateDirEntries(path, callback, FS::DirEntryFilter::File); + + return out; +} + +template <> +std::vector RealVfsDirectory::IterateEntries() const { + if (perms == Mode::Append) { + return {}; + } + + std::vector out; + + const FS::DirEntryCallable callback = [this, + &out](const std::filesystem::directory_entry& entry) { + const auto full_path_string = FS::PathToUTF8String(entry.path()); + + out.emplace_back(base.OpenDirectory(full_path_string, perms)); + + return true; + }; + + FS::IterateDirEntries(path, callback, FS::DirEntryFilter::Directory); + + return out; +} + +RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string& path_, Mode perms_) + : base(base_), path(FS::RemoveTrailingSlash(path_)), parent_path(FS::GetParentPath(path)), + path_components(FS::SplitPathComponentsCopy(path)), perms(perms_) { + if (!FS::Exists(path) && True(perms & Mode::Write)) { + void(FS::CreateDirs(path)); + } +} + +RealVfsDirectory::~RealVfsDirectory() = default; + +VirtualFile RealVfsDirectory::GetFileRelative(std::string_view relative_path) const { + const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path)); + if (!FS::Exists(full_path) || FS::IsDir(full_path)) { + return nullptr; + } + return base.OpenFile(full_path, perms); +} + +VirtualDir RealVfsDirectory::GetDirectoryRelative(std::string_view relative_path) const { + const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path)); + if (!FS::Exists(full_path) || !FS::IsDir(full_path)) { + return nullptr; + } + return base.OpenDirectory(full_path, perms); +} + +VirtualFile RealVfsDirectory::GetFile(std::string_view name) const { + return GetFileRelative(name); +} + +VirtualDir RealVfsDirectory::GetSubdirectory(std::string_view name) const { + return GetDirectoryRelative(name); +} + +VirtualFile RealVfsDirectory::CreateFileRelative(std::string_view relative_path) { + const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path)); + if (!FS::CreateParentDirs(full_path)) { + return nullptr; + } + return base.CreateFile(full_path, perms); +} + +VirtualDir RealVfsDirectory::CreateDirectoryRelative(std::string_view relative_path) { + const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path)); + return base.CreateDirectory(full_path, perms); +} + +bool RealVfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) { + const auto full_path = FS::SanitizePath(this->path + '/' + std::string(name)); + return base.DeleteDirectory(full_path); +} + +std::vector RealVfsDirectory::GetFiles() const { + return IterateEntries(); +} + +FileTimeStampRaw RealVfsDirectory::GetFileTimeStamp(std::string_view path_) const { + const auto full_path = FS::SanitizePath(path + '/' + std::string(path_)); + const auto fs_path = std::filesystem::path{FS::ToU8String(full_path)}; + struct stat file_status; + +#ifdef _WIN32 + const auto stat_result = _wstat64(fs_path.c_str(), &file_status); +#else + const auto stat_result = stat(fs_path.c_str(), &file_status); +#endif + + if (stat_result != 0) { + return {}; + } + + return { + .created{static_cast(file_status.st_ctime)}, + .accessed{static_cast(file_status.st_atime)}, + .modified{static_cast(file_status.st_mtime)}, + }; +} + +std::vector RealVfsDirectory::GetSubdirectories() const { + return IterateEntries(); +} + +bool RealVfsDirectory::IsWritable() const { + return True(perms & Mode::Write); +} + +bool RealVfsDirectory::IsReadable() const { + return True(perms & Mode::Read); +} + +std::string RealVfsDirectory::GetName() const { + return path_components.empty() ? "" : std::string(path_components.back()); +} + +VirtualDir RealVfsDirectory::GetParentDirectory() const { + if (path_components.size() <= 1) { + return nullptr; + } + + return base.OpenDirectory(parent_path, perms); +} + +VirtualDir RealVfsDirectory::CreateSubdirectory(std::string_view name) { + const std::string subdir_path = (path + '/').append(name); + return base.CreateDirectory(subdir_path, perms); +} + +VirtualFile RealVfsDirectory::CreateFile(std::string_view name) { + const std::string file_path = (path + '/').append(name); + return base.CreateFile(file_path, perms); +} + +bool RealVfsDirectory::DeleteSubdirectory(std::string_view name) { + const std::string subdir_path = (path + '/').append(name); + return base.DeleteDirectory(subdir_path); +} + +bool RealVfsDirectory::DeleteFile(std::string_view name) { + const std::string file_path = (path + '/').append(name); + return base.DeleteFile(file_path); +} + +bool RealVfsDirectory::Rename(std::string_view name) { + const std::string new_name = (parent_path + '/').append(name); + return base.MoveFile(path, new_name) != nullptr; +} + +std::string RealVfsDirectory::GetFullPath() const { + auto out = path; + std::replace(out.begin(), out.end(), '\\', '/'); + return out; +} + +std::map> RealVfsDirectory::GetEntries() const { + if (perms == Mode::Append) { + return {}; + } + + std::map> out; + + const FS::DirEntryCallable callback = [&out](const std::filesystem::directory_entry& entry) { + const auto filename = FS::PathToUTF8String(entry.path().filename()); + out.insert_or_assign(filename, + entry.is_directory() ? VfsEntryType::Directory : VfsEntryType::File); + return true; + }; + + FS::IterateDirEntries(path, callback); + + return out; +} + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_real.h b/src/core/file_sys/vfs/vfs_real.h new file mode 100644 index 000000000..1560bc1f9 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_real.h @@ -0,0 +1,145 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include +#include +#include "common/intrusive_list.h" +#include "core/file_sys/mode.h" +#include "core/file_sys/vfs/vfs.h" + +namespace Common::FS { +class IOFile; +} + +namespace FileSys { + +struct FileReference : public Common::IntrusiveListBaseNode { + std::shared_ptr file{}; +}; + +class RealVfsFile; +class RealVfsDirectory; + +class RealVfsFilesystem : public VfsFilesystem { +public: + RealVfsFilesystem(); + ~RealVfsFilesystem() override; + + std::string GetName() const override; + bool IsReadable() const override; + bool IsWritable() const override; + VfsEntryType GetEntryType(std::string_view path) const override; + VirtualFile OpenFile(std::string_view path, Mode perms = Mode::Read) override; + VirtualFile CreateFile(std::string_view path, Mode perms = Mode::ReadWrite) override; + VirtualFile CopyFile(std::string_view old_path, std::string_view new_path) override; + VirtualFile MoveFile(std::string_view old_path, std::string_view new_path) override; + bool DeleteFile(std::string_view path) override; + VirtualDir OpenDirectory(std::string_view path, Mode perms = Mode::Read) override; + VirtualDir CreateDirectory(std::string_view path, Mode perms = Mode::ReadWrite) override; + VirtualDir CopyDirectory(std::string_view old_path, std::string_view new_path) override; + VirtualDir MoveDirectory(std::string_view old_path, std::string_view new_path) override; + bool DeleteDirectory(std::string_view path) override; + +private: + using ReferenceListType = Common::IntrusiveListBaseTraits::ListType; + std::map, std::less<>> cache; + ReferenceListType open_references; + ReferenceListType closed_references; + std::mutex list_lock; + size_t num_open_files{}; + +private: + friend class RealVfsFile; + std::unique_lock RefreshReference(const std::string& path, Mode perms, + FileReference& reference); + void DropReference(std::unique_ptr&& reference); + +private: + friend class RealVfsDirectory; + VirtualFile OpenFileFromEntry(std::string_view path, std::optional size, + Mode perms = Mode::Read); + +private: + void EvictSingleReferenceLocked(); + void InsertReferenceIntoListLocked(FileReference& reference); + void RemoveReferenceFromListLocked(FileReference& reference); +}; + +// An implementation of VfsFile that represents a file on the user's computer. +class RealVfsFile : public VfsFile { + friend class RealVfsDirectory; + friend class RealVfsFilesystem; + +public: + ~RealVfsFile() override; + + std::string GetName() const override; + std::size_t GetSize() const override; + bool Resize(std::size_t new_size) override; + VirtualDir GetContainingDirectory() const override; + bool IsWritable() const override; + bool IsReadable() const override; + std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override; + std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override; + bool Rename(std::string_view name) override; + +private: + RealVfsFile(RealVfsFilesystem& base, std::unique_ptr reference, + const std::string& path, Mode perms = Mode::Read, std::optional size = {}); + + RealVfsFilesystem& base; + std::unique_ptr reference; + std::string path; + std::string parent_path; + std::vector path_components; + std::optional size; + Mode perms; +}; + +// An implementation of VfsDirectory that represents a directory on the user's computer. +class RealVfsDirectory : public VfsDirectory { + friend class RealVfsFilesystem; + +public: + ~RealVfsDirectory() override; + + VirtualFile GetFileRelative(std::string_view relative_path) const override; + VirtualDir GetDirectoryRelative(std::string_view relative_path) const override; + VirtualFile GetFile(std::string_view name) const override; + VirtualDir GetSubdirectory(std::string_view name) const override; + VirtualFile CreateFileRelative(std::string_view relative_path) override; + VirtualDir CreateDirectoryRelative(std::string_view relative_path) override; + bool DeleteSubdirectoryRecursive(std::string_view name) override; + std::vector GetFiles() const override; + FileTimeStampRaw GetFileTimeStamp(std::string_view path) const override; + std::vector GetSubdirectories() const override; + bool IsWritable() const override; + bool IsReadable() const override; + std::string GetName() const override; + VirtualDir GetParentDirectory() const override; + VirtualDir CreateSubdirectory(std::string_view name) override; + VirtualFile CreateFile(std::string_view name) override; + bool DeleteSubdirectory(std::string_view name) override; + bool DeleteFile(std::string_view name) override; + bool Rename(std::string_view name) override; + std::string GetFullPath() const override; + std::map> GetEntries() const override; + +private: + RealVfsDirectory(RealVfsFilesystem& base, const std::string& path, Mode perms = Mode::Read); + + template + std::vector> IterateEntries() const; + + RealVfsFilesystem& base; + std::string path; + std::string parent_path; + std::vector path_components; + Mode perms; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_static.h b/src/core/file_sys/vfs/vfs_static.h new file mode 100644 index 000000000..bb53560ac --- /dev/null +++ b/src/core/file_sys/vfs/vfs_static.h @@ -0,0 +1,80 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include + +#include "core/file_sys/vfs/vfs.h" + +namespace FileSys { + +class StaticVfsFile : public VfsFile { +public: + explicit StaticVfsFile(u8 value_, std::size_t size_ = 0, std::string name_ = "", + VirtualDir parent_ = nullptr) + : value{value_}, size{size_}, name{std::move(name_)}, parent{std::move(parent_)} {} + + std::string GetName() const override { + return name; + } + + std::size_t GetSize() const override { + return size; + } + + bool Resize(std::size_t new_size) override { + size = new_size; + return true; + } + + VirtualDir GetContainingDirectory() const override { + return parent; + } + + bool IsWritable() const override { + return false; + } + + bool IsReadable() const override { + return true; + } + + std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override { + const auto read = std::min(length, size - offset); + std::fill(data, data + read, value); + return read; + } + + std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override { + return 0; + } + + std::optional ReadByte(std::size_t offset) const override { + if (offset >= size) { + return std::nullopt; + } + + return value; + } + + std::vector ReadBytes(std::size_t length, std::size_t offset) const override { + const auto read = std::min(length, size - offset); + return std::vector(read, value); + } + + bool Rename(std::string_view new_name) override { + name = new_name; + return true; + } + +private: + u8 value; + std::size_t size; + std::string name; + VirtualDir parent; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_types.h b/src/core/file_sys/vfs/vfs_types.h new file mode 100644 index 000000000..4a583ed64 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_types.h @@ -0,0 +1,29 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include + +#include "common/common_types.h" + +namespace FileSys { + +class VfsDirectory; +class VfsFile; +class VfsFilesystem; + +// Declarations for Vfs* pointer types + +using VirtualDir = std::shared_ptr; +using VirtualFile = std::shared_ptr; +using VirtualFilesystem = std::shared_ptr; + +struct FileTimeStampRaw { + u64 created{}; + u64 accessed{}; + u64 modified{}; + u64 padding{}; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_vector.cpp b/src/core/file_sys/vfs/vfs_vector.cpp new file mode 100644 index 000000000..0d54461c8 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_vector.cpp @@ -0,0 +1,133 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include +#include "core/file_sys/vfs/vfs_vector.h" + +namespace FileSys { +VectorVfsFile::VectorVfsFile(std::vector initial_data, std::string name_, VirtualDir parent_) + : data(std::move(initial_data)), parent(std::move(parent_)), name(std::move(name_)) {} + +VectorVfsFile::~VectorVfsFile() = default; + +std::string VectorVfsFile::GetName() const { + return name; +} + +size_t VectorVfsFile::GetSize() const { + return data.size(); +} + +bool VectorVfsFile::Resize(size_t new_size) { + data.resize(new_size); + return true; +} + +VirtualDir VectorVfsFile::GetContainingDirectory() const { + return parent; +} + +bool VectorVfsFile::IsWritable() const { + return true; +} + +bool VectorVfsFile::IsReadable() const { + return true; +} + +std::size_t VectorVfsFile::Read(u8* data_, std::size_t length, std::size_t offset) const { + const auto read = std::min(length, data.size() - offset); + std::memcpy(data_, data.data() + offset, read); + return read; +} + +std::size_t VectorVfsFile::Write(const u8* data_, std::size_t length, std::size_t offset) { + if (offset + length > data.size()) + data.resize(offset + length); + const auto write = std::min(length, data.size() - offset); + std::memcpy(data.data() + offset, data_, write); + return write; +} + +bool VectorVfsFile::Rename(std::string_view name_) { + name = name_; + return true; +} + +void VectorVfsFile::Assign(std::vector new_data) { + data = std::move(new_data); +} + +VectorVfsDirectory::VectorVfsDirectory(std::vector files_, + std::vector dirs_, std::string name_, + VirtualDir parent_) + : files(std::move(files_)), dirs(std::move(dirs_)), parent(std::move(parent_)), + name(std::move(name_)) {} + +VectorVfsDirectory::~VectorVfsDirectory() = default; + +std::vector VectorVfsDirectory::GetFiles() const { + return files; +} + +std::vector VectorVfsDirectory::GetSubdirectories() const { + return dirs; +} + +bool VectorVfsDirectory::IsWritable() const { + return false; +} + +bool VectorVfsDirectory::IsReadable() const { + return true; +} + +std::string VectorVfsDirectory::GetName() const { + return name; +} + +VirtualDir VectorVfsDirectory::GetParentDirectory() const { + return parent; +} + +template +static bool FindAndRemoveVectorElement(std::vector& vec, std::string_view name) { + const auto iter = + std::find_if(vec.begin(), vec.end(), [name](const T& e) { return e->GetName() == name; }); + if (iter == vec.end()) + return false; + + vec.erase(iter); + return true; +} + +bool VectorVfsDirectory::DeleteSubdirectory(std::string_view subdir_name) { + return FindAndRemoveVectorElement(dirs, subdir_name); +} + +bool VectorVfsDirectory::DeleteFile(std::string_view file_name) { + return FindAndRemoveVectorElement(files, file_name); +} + +bool VectorVfsDirectory::Rename(std::string_view name_) { + name = name_; + return true; +} + +VirtualDir VectorVfsDirectory::CreateSubdirectory(std::string_view subdir_name) { + return nullptr; +} + +VirtualFile VectorVfsDirectory::CreateFile(std::string_view file_name) { + return nullptr; +} + +void VectorVfsDirectory::AddFile(VirtualFile file) { + files.push_back(std::move(file)); +} + +void VectorVfsDirectory::AddDirectory(VirtualDir dir) { + dirs.push_back(std::move(dir)); +} +} // namespace FileSys diff --git a/src/core/file_sys/vfs/vfs_vector.h b/src/core/file_sys/vfs/vfs_vector.h new file mode 100644 index 000000000..587187dd2 --- /dev/null +++ b/src/core/file_sys/vfs/vfs_vector.h @@ -0,0 +1,131 @@ +// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include +#include +#include +#include "core/file_sys/vfs/vfs.h" + +namespace FileSys { + +// An implementation of VfsFile that is backed by a statically-sized array +template +class ArrayVfsFile : public VfsFile { +public: + explicit ArrayVfsFile(const std::array& data_, std::string name_ = "", + VirtualDir parent_ = nullptr) + : data(data_), name(std::move(name_)), parent(std::move(parent_)) {} + + std::string GetName() const override { + return name; + } + + std::size_t GetSize() const override { + return size; + } + + bool Resize(std::size_t new_size) override { + return false; + } + + VirtualDir GetContainingDirectory() const override { + return parent; + } + + bool IsWritable() const override { + return false; + } + + bool IsReadable() const override { + return true; + } + + std::size_t Read(u8* data_, std::size_t length, std::size_t offset) const override { + const auto read = std::min(length, size - offset); + std::memcpy(data_, data.data() + offset, read); + return read; + } + + std::size_t Write(const u8* data_, std::size_t length, std::size_t offset) override { + return 0; + } + + bool Rename(std::string_view new_name) override { + name = new_name; + return true; + } + +private: + std::array data; + std::string name; + VirtualDir parent; +}; + +template +std::shared_ptr> MakeArrayFile(const std::array& data, + Args&&... args) { + return std::make_shared>(data, std::forward(args)...); +} + +// An implementation of VfsFile that is backed by a vector optionally supplied upon construction +class VectorVfsFile : public VfsFile { +public: + explicit VectorVfsFile(std::vector initial_data = {}, std::string name_ = "", + VirtualDir parent_ = nullptr); + ~VectorVfsFile() override; + + std::string GetName() const override; + std::size_t GetSize() const override; + bool Resize(std::size_t new_size) override; + VirtualDir GetContainingDirectory() const override; + bool IsWritable() const override; + bool IsReadable() const override; + std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override; + std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override; + bool Rename(std::string_view name) override; + + virtual void Assign(std::vector new_data); + +private: + std::vector data; + VirtualDir parent; + std::string name; +}; + +// An implementation of VfsDirectory that maintains two vectors for subdirectories and files. +// Vector data is supplied upon construction. +class VectorVfsDirectory : public VfsDirectory { +public: + explicit VectorVfsDirectory(std::vector files = {}, + std::vector dirs = {}, std::string name = "", + VirtualDir parent = nullptr); + ~VectorVfsDirectory() override; + + std::vector GetFiles() const override; + std::vector GetSubdirectories() const override; + bool IsWritable() const override; + bool IsReadable() const override; + std::string GetName() const override; + VirtualDir GetParentDirectory() const override; + bool DeleteSubdirectory(std::string_view subdir_name) override; + bool DeleteFile(std::string_view file_name) override; + bool Rename(std::string_view name) override; + VirtualDir CreateSubdirectory(std::string_view subdir_name) override; + VirtualFile CreateFile(std::string_view file_name) override; + + virtual void AddFile(VirtualFile file); + virtual void AddDirectory(VirtualDir dir); + +private: + std::vector files; + std::vector dirs; + + VirtualDir parent; + std::string name; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/vfs_cached.cpp b/src/core/file_sys/vfs_cached.cpp deleted file mode 100644 index 7ee5300e5..000000000 --- a/src/core/file_sys/vfs_cached.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include "core/file_sys/vfs_cached.h" -#include "core/file_sys/vfs_types.h" - -namespace FileSys { - -CachedVfsDirectory::CachedVfsDirectory(VirtualDir&& source_dir) - : name(source_dir->GetName()), parent(source_dir->GetParentDirectory()) { - for (auto& dir : source_dir->GetSubdirectories()) { - dirs.emplace(dir->GetName(), std::make_shared(std::move(dir))); - } - for (auto& file : source_dir->GetFiles()) { - files.emplace(file->GetName(), std::move(file)); - } -} - -CachedVfsDirectory::~CachedVfsDirectory() = default; - -VirtualFile CachedVfsDirectory::GetFile(std::string_view file_name) const { - auto it = files.find(file_name); - if (it != files.end()) { - return it->second; - } - - return nullptr; -} - -VirtualDir CachedVfsDirectory::GetSubdirectory(std::string_view dir_name) const { - auto it = dirs.find(dir_name); - if (it != dirs.end()) { - return it->second; - } - - return nullptr; -} - -std::vector CachedVfsDirectory::GetFiles() const { - std::vector out; - for (auto& [file_name, file] : files) { - out.push_back(file); - } - return out; -} - -std::vector CachedVfsDirectory::GetSubdirectories() const { - std::vector out; - for (auto& [dir_name, dir] : dirs) { - out.push_back(dir); - } - return out; -} - -std::string CachedVfsDirectory::GetName() const { - return name; -} - -VirtualDir CachedVfsDirectory::GetParentDirectory() const { - return parent; -} - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_cached.h b/src/core/file_sys/vfs_cached.h deleted file mode 100644 index 1e5300784..000000000 --- a/src/core/file_sys/vfs_cached.h +++ /dev/null @@ -1,31 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include -#include -#include "core/file_sys/vfs.h" - -namespace FileSys { - -class CachedVfsDirectory : public ReadOnlyVfsDirectory { -public: - CachedVfsDirectory(VirtualDir&& source_directory); - - ~CachedVfsDirectory() override; - VirtualFile GetFile(std::string_view file_name) const override; - VirtualDir GetSubdirectory(std::string_view dir_name) const override; - std::vector GetFiles() const override; - std::vector GetSubdirectories() const override; - std::string GetName() const override; - VirtualDir GetParentDirectory() const override; - -private: - std::string name; - VirtualDir parent; - std::map> dirs; - std::map> files; -}; - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_concat.cpp b/src/core/file_sys/vfs_concat.cpp deleted file mode 100644 index 7c7298527..000000000 --- a/src/core/file_sys/vfs_concat.cpp +++ /dev/null @@ -1,192 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include -#include - -#include "common/assert.h" -#include "core/file_sys/vfs_concat.h" -#include "core/file_sys/vfs_static.h" - -namespace FileSys { - -ConcatenatedVfsFile::ConcatenatedVfsFile(std::string&& name_, ConcatenationMap&& concatenation_map_) - : concatenation_map(std::move(concatenation_map_)), name(std::move(name_)) { - DEBUG_ASSERT(this->VerifyContinuity()); -} - -bool ConcatenatedVfsFile::VerifyContinuity() const { - u64 last_offset = 0; - for (auto& entry : concatenation_map) { - if (entry.offset != last_offset) { - return false; - } - - last_offset = entry.offset + entry.file->GetSize(); - } - - return true; -} - -ConcatenatedVfsFile::~ConcatenatedVfsFile() = default; - -VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::string&& name, - std::vector&& files) { - // Fold trivial cases. - if (files.empty()) { - return nullptr; - } - if (files.size() == 1) { - return files.front(); - } - - // Make the concatenation map from the input. - std::vector concatenation_map; - concatenation_map.reserve(files.size()); - u64 last_offset = 0; - - for (auto& file : files) { - const auto size = file->GetSize(); - - concatenation_map.emplace_back(ConcatenationEntry{ - .offset = last_offset, - .file = std::move(file), - }); - - last_offset += size; - } - - return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map))); -} - -VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile( - u8 filler_byte, std::string&& name, std::vector>&& files) { - // Fold trivial cases. - if (files.empty()) { - return nullptr; - } - if (files.size() == 1) { - return files.begin()->second; - } - - // Make the concatenation map from the input. - std::vector concatenation_map; - - concatenation_map.reserve(files.size()); - u64 last_offset = 0; - - // Iteration of a multimap is ordered, so offset will be strictly non-decreasing. - for (auto& [offset, file] : files) { - const auto size = file->GetSize(); - - if (offset > last_offset) { - concatenation_map.emplace_back(ConcatenationEntry{ - .offset = last_offset, - .file = std::make_shared(filler_byte, offset - last_offset), - }); - } - - concatenation_map.emplace_back(ConcatenationEntry{ - .offset = offset, - .file = std::move(file), - }); - - last_offset = offset + size; - } - - return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map))); -} - -std::string ConcatenatedVfsFile::GetName() const { - if (concatenation_map.empty()) { - return ""; - } - if (!name.empty()) { - return name; - } - return concatenation_map.front().file->GetName(); -} - -std::size_t ConcatenatedVfsFile::GetSize() const { - if (concatenation_map.empty()) { - return 0; - } - return concatenation_map.back().offset + concatenation_map.back().file->GetSize(); -} - -bool ConcatenatedVfsFile::Resize(std::size_t new_size) { - return false; -} - -VirtualDir ConcatenatedVfsFile::GetContainingDirectory() const { - if (concatenation_map.empty()) { - return nullptr; - } - return concatenation_map.front().file->GetContainingDirectory(); -} - -bool ConcatenatedVfsFile::IsWritable() const { - return false; -} - -bool ConcatenatedVfsFile::IsReadable() const { - return true; -} - -std::size_t ConcatenatedVfsFile::Read(u8* data, std::size_t length, std::size_t offset) const { - const ConcatenationEntry key{ - .offset = offset, - .file = nullptr, - }; - - // Read nothing if the map is empty. - if (concatenation_map.empty()) { - return 0; - } - - // Binary search to find the iterator to the first position we can check. - // It must exist, since we are not empty and are comparing unsigned integers. - auto it = std::prev(std::upper_bound(concatenation_map.begin(), concatenation_map.end(), key)); - u64 cur_length = length; - u64 cur_offset = offset; - - while (cur_length > 0 && it != concatenation_map.end()) { - // Check if we can read the file at this position. - const auto& file = it->file; - const u64 map_offset = it->offset; - const u64 file_size = file->GetSize(); - - if (cur_offset > map_offset + file_size) { - // Entirely out of bounds read. - break; - } - - // Read the file at this position. - const u64 file_seek = cur_offset - map_offset; - const u64 intended_read_size = std::min(cur_length, file_size - file_seek); - const u64 actual_read_size = - file->Read(data + (cur_offset - offset), intended_read_size, file_seek); - - // Update tracking. - cur_offset += actual_read_size; - cur_length -= actual_read_size; - it++; - - // If we encountered a short read, we're done. - if (actual_read_size < intended_read_size) { - break; - } - } - - return cur_offset - offset; -} - -std::size_t ConcatenatedVfsFile::Write(const u8* data, std::size_t length, std::size_t offset) { - return 0; -} - -bool ConcatenatedVfsFile::Rename(std::string_view new_name) { - return false; -} - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_concat.h b/src/core/file_sys/vfs_concat.h deleted file mode 100644 index b5f3d72e3..000000000 --- a/src/core/file_sys/vfs_concat.h +++ /dev/null @@ -1,57 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include -#include -#include -#include "core/file_sys/vfs.h" - -namespace FileSys { - -// Class that wraps multiple vfs files and concatenates them, making reads seamless. Currently -// read-only. -class ConcatenatedVfsFile : public VfsFile { -private: - struct ConcatenationEntry { - u64 offset; - VirtualFile file; - - auto operator<=>(const ConcatenationEntry& other) const { - return this->offset <=> other.offset; - } - }; - using ConcatenationMap = std::vector; - - explicit ConcatenatedVfsFile(std::string&& name, - std::vector&& concatenation_map); - bool VerifyContinuity() const; - -public: - ~ConcatenatedVfsFile() override; - - /// Wrapper function to allow for more efficient handling of files.size() == 0, 1 cases. - static VirtualFile MakeConcatenatedFile(std::string&& name, std::vector&& files); - - /// Convenience function that turns a map of offsets to files into a concatenated file, filling - /// gaps with a given filler byte. - static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::string&& name, - std::vector>&& files); - - std::string GetName() const override; - std::size_t GetSize() const override; - bool Resize(std::size_t new_size) override; - VirtualDir GetContainingDirectory() const override; - bool IsWritable() const override; - bool IsReadable() const override; - std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override; - std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override; - bool Rename(std::string_view new_name) override; - -private: - ConcatenationMap concatenation_map; - std::string name; -}; - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_layered.cpp b/src/core/file_sys/vfs_layered.cpp deleted file mode 100644 index 5551743fb..000000000 --- a/src/core/file_sys/vfs_layered.cpp +++ /dev/null @@ -1,132 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include -#include -#include -#include -#include "core/file_sys/vfs_layered.h" - -namespace FileSys { - -LayeredVfsDirectory::LayeredVfsDirectory(std::vector dirs_, std::string name_) - : dirs(std::move(dirs_)), name(std::move(name_)) {} - -LayeredVfsDirectory::~LayeredVfsDirectory() = default; - -VirtualDir LayeredVfsDirectory::MakeLayeredDirectory(std::vector dirs, - std::string name) { - if (dirs.empty()) - return nullptr; - if (dirs.size() == 1) - return dirs[0]; - - return VirtualDir(new LayeredVfsDirectory(std::move(dirs), std::move(name))); -} - -VirtualFile LayeredVfsDirectory::GetFileRelative(std::string_view path) const { - for (const auto& layer : dirs) { - const auto file = layer->GetFileRelative(path); - if (file != nullptr) - return file; - } - - return nullptr; -} - -VirtualDir LayeredVfsDirectory::GetDirectoryRelative(std::string_view path) const { - std::vector out; - for (const auto& layer : dirs) { - auto dir = layer->GetDirectoryRelative(path); - if (dir != nullptr) { - out.emplace_back(std::move(dir)); - } - } - - return MakeLayeredDirectory(std::move(out)); -} - -VirtualFile LayeredVfsDirectory::GetFile(std::string_view file_name) const { - return GetFileRelative(file_name); -} - -VirtualDir LayeredVfsDirectory::GetSubdirectory(std::string_view subdir_name) const { - return GetDirectoryRelative(subdir_name); -} - -std::string LayeredVfsDirectory::GetFullPath() const { - return dirs[0]->GetFullPath(); -} - -std::vector LayeredVfsDirectory::GetFiles() const { - std::vector out; - std::unordered_set out_names; - - for (const auto& layer : dirs) { - for (auto& file : layer->GetFiles()) { - const auto [it, is_new] = out_names.emplace(file->GetName()); - if (is_new) { - out.emplace_back(std::move(file)); - } - } - } - - return out; -} - -std::vector LayeredVfsDirectory::GetSubdirectories() const { - std::vector out; - std::unordered_set out_names; - - for (const auto& layer : dirs) { - for (const auto& sd : layer->GetSubdirectories()) { - out_names.emplace(sd->GetName()); - } - } - - out.reserve(out_names.size()); - for (const auto& subdir : out_names) { - out.emplace_back(GetSubdirectory(subdir)); - } - - return out; -} - -bool LayeredVfsDirectory::IsWritable() const { - return false; -} - -bool LayeredVfsDirectory::IsReadable() const { - return true; -} - -std::string LayeredVfsDirectory::GetName() const { - return name.empty() ? dirs[0]->GetName() : name; -} - -VirtualDir LayeredVfsDirectory::GetParentDirectory() const { - return dirs[0]->GetParentDirectory(); -} - -VirtualDir LayeredVfsDirectory::CreateSubdirectory(std::string_view subdir_name) { - return nullptr; -} - -VirtualFile LayeredVfsDirectory::CreateFile(std::string_view file_name) { - return nullptr; -} - -bool LayeredVfsDirectory::DeleteSubdirectory(std::string_view subdir_name) { - return false; -} - -bool LayeredVfsDirectory::DeleteFile(std::string_view file_name) { - return false; -} - -bool LayeredVfsDirectory::Rename(std::string_view new_name) { - name = new_name; - return true; -} - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_layered.h b/src/core/file_sys/vfs_layered.h deleted file mode 100644 index a62112e9d..000000000 --- a/src/core/file_sys/vfs_layered.h +++ /dev/null @@ -1,46 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include -#include "core/file_sys/vfs.h" - -namespace FileSys { - -// Class that stacks multiple VfsDirectories on top of each other, attempting to read from the first -// one and falling back to the one after. The highest priority directory (overwrites all others) -// should be element 0 in the dirs vector. -class LayeredVfsDirectory : public VfsDirectory { - explicit LayeredVfsDirectory(std::vector dirs_, std::string name_); - -public: - ~LayeredVfsDirectory() override; - - /// Wrapper function to allow for more efficient handling of dirs.size() == 0, 1 cases. - static VirtualDir MakeLayeredDirectory(std::vector dirs, std::string name = ""); - - VirtualFile GetFileRelative(std::string_view path) const override; - VirtualDir GetDirectoryRelative(std::string_view path) const override; - VirtualFile GetFile(std::string_view file_name) const override; - VirtualDir GetSubdirectory(std::string_view subdir_name) const override; - std::string GetFullPath() const override; - - std::vector GetFiles() const override; - std::vector GetSubdirectories() const override; - bool IsWritable() const override; - bool IsReadable() const override; - std::string GetName() const override; - VirtualDir GetParentDirectory() const override; - VirtualDir CreateSubdirectory(std::string_view subdir_name) override; - VirtualFile CreateFile(std::string_view file_name) override; - bool DeleteSubdirectory(std::string_view subdir_name) override; - bool DeleteFile(std::string_view file_name) override; - bool Rename(std::string_view new_name) override; - -private: - std::vector dirs; - std::string name; -}; - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_offset.cpp b/src/core/file_sys/vfs_offset.cpp deleted file mode 100644 index d950a6633..000000000 --- a/src/core/file_sys/vfs_offset.cpp +++ /dev/null @@ -1,98 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include -#include - -#include "core/file_sys/vfs_offset.h" - -namespace FileSys { - -OffsetVfsFile::OffsetVfsFile(VirtualFile file_, std::size_t size_, std::size_t offset_, - std::string name_, VirtualDir parent_) - : file(file_), offset(offset_), size(size_), name(std::move(name_)), - parent(parent_ == nullptr ? file->GetContainingDirectory() : std::move(parent_)) {} - -OffsetVfsFile::~OffsetVfsFile() = default; - -std::string OffsetVfsFile::GetName() const { - return name.empty() ? file->GetName() : name; -} - -std::size_t OffsetVfsFile::GetSize() const { - return size; -} - -bool OffsetVfsFile::Resize(std::size_t new_size) { - if (offset + new_size < file->GetSize()) { - size = new_size; - } else { - auto res = file->Resize(offset + new_size); - if (!res) - return false; - size = new_size; - } - - return true; -} - -VirtualDir OffsetVfsFile::GetContainingDirectory() const { - return parent; -} - -bool OffsetVfsFile::IsWritable() const { - return file->IsWritable(); -} - -bool OffsetVfsFile::IsReadable() const { - return file->IsReadable(); -} - -std::size_t OffsetVfsFile::Read(u8* data, std::size_t length, std::size_t r_offset) const { - return file->Read(data, TrimToFit(length, r_offset), offset + r_offset); -} - -std::size_t OffsetVfsFile::Write(const u8* data, std::size_t length, std::size_t r_offset) { - return file->Write(data, TrimToFit(length, r_offset), offset + r_offset); -} - -std::optional OffsetVfsFile::ReadByte(std::size_t r_offset) const { - if (r_offset >= size) { - return std::nullopt; - } - - return file->ReadByte(offset + r_offset); -} - -std::vector OffsetVfsFile::ReadBytes(std::size_t r_size, std::size_t r_offset) const { - return file->ReadBytes(TrimToFit(r_size, r_offset), offset + r_offset); -} - -std::vector OffsetVfsFile::ReadAllBytes() const { - return file->ReadBytes(size, offset); -} - -bool OffsetVfsFile::WriteByte(u8 data, std::size_t r_offset) { - if (r_offset < size) - return file->WriteByte(data, offset + r_offset); - - return false; -} - -std::size_t OffsetVfsFile::WriteBytes(const std::vector& data, std::size_t r_offset) { - return file->Write(data.data(), TrimToFit(data.size(), r_offset), offset + r_offset); -} - -bool OffsetVfsFile::Rename(std::string_view new_name) { - return file->Rename(new_name); -} - -std::size_t OffsetVfsFile::GetOffset() const { - return offset; -} - -std::size_t OffsetVfsFile::TrimToFit(std::size_t r_size, std::size_t r_offset) const { - return std::clamp(r_size, std::size_t{0}, size - r_offset); -} - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_offset.h b/src/core/file_sys/vfs_offset.h deleted file mode 100644 index 6c051ca00..000000000 --- a/src/core/file_sys/vfs_offset.h +++ /dev/null @@ -1,50 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include - -#include "core/file_sys/vfs.h" - -namespace FileSys { - -// An implementation of VfsFile that wraps around another VfsFile at a certain offset. -// Similar to seeking to an offset. -// If the file is writable, operations that would write past the end of the offset file will expand -// the size of this wrapper. -class OffsetVfsFile : public VfsFile { -public: - OffsetVfsFile(VirtualFile file, std::size_t size, std::size_t offset = 0, - std::string new_name = "", VirtualDir new_parent = nullptr); - ~OffsetVfsFile() override; - - std::string GetName() const override; - std::size_t GetSize() const override; - bool Resize(std::size_t new_size) override; - VirtualDir GetContainingDirectory() const override; - bool IsWritable() const override; - bool IsReadable() const override; - std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override; - std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override; - std::optional ReadByte(std::size_t offset) const override; - std::vector ReadBytes(std::size_t size, std::size_t offset) const override; - std::vector ReadAllBytes() const override; - bool WriteByte(u8 data, std::size_t offset) override; - std::size_t WriteBytes(const std::vector& data, std::size_t offset) override; - - bool Rename(std::string_view new_name) override; - - std::size_t GetOffset() const; - -private: - std::size_t TrimToFit(std::size_t r_size, std::size_t r_offset) const; - - VirtualFile file; - std::size_t offset; - std::size_t size; - std::string name; - VirtualDir parent; -}; - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_real.cpp b/src/core/file_sys/vfs_real.cpp deleted file mode 100644 index cd9b79786..000000000 --- a/src/core/file_sys/vfs_real.cpp +++ /dev/null @@ -1,528 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include -#include -#include -#include -#include "common/assert.h" -#include "common/fs/file.h" -#include "common/fs/fs.h" -#include "common/fs/path_util.h" -#include "common/logging/log.h" -#include "core/file_sys/vfs.h" -#include "core/file_sys/vfs_real.h" - -// For FileTimeStampRaw -#include - -#ifdef _MSC_VER -#define stat _stat64 -#endif - -namespace FileSys { - -namespace FS = Common::FS; - -namespace { - -constexpr size_t MaxOpenFiles = 512; - -constexpr FS::FileAccessMode ModeFlagsToFileAccessMode(Mode mode) { - switch (mode) { - case Mode::Read: - return FS::FileAccessMode::Read; - case Mode::Write: - case Mode::ReadWrite: - case Mode::Append: - case Mode::ReadAppend: - case Mode::WriteAppend: - case Mode::All: - return FS::FileAccessMode::ReadWrite; - default: - return {}; - } -} - -} // Anonymous namespace - -RealVfsFilesystem::RealVfsFilesystem() : VfsFilesystem(nullptr) {} -RealVfsFilesystem::~RealVfsFilesystem() = default; - -std::string RealVfsFilesystem::GetName() const { - return "Real"; -} - -bool RealVfsFilesystem::IsReadable() const { - return true; -} - -bool RealVfsFilesystem::IsWritable() const { - return true; -} - -VfsEntryType RealVfsFilesystem::GetEntryType(std::string_view path_) const { - const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); - if (!FS::Exists(path)) { - return VfsEntryType::None; - } - if (FS::IsDir(path)) { - return VfsEntryType::Directory; - } - - return VfsEntryType::File; -} - -VirtualFile RealVfsFilesystem::OpenFileFromEntry(std::string_view path_, std::optional size, - Mode perms) { - const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); - std::scoped_lock lk{list_lock}; - - if (auto it = cache.find(path); it != cache.end()) { - if (auto file = it->second.lock(); file) { - return file; - } - } - - if (!size && !FS::IsFile(path)) { - return nullptr; - } - - auto reference = std::make_unique(); - this->InsertReferenceIntoListLocked(*reference); - - auto file = std::shared_ptr( - new RealVfsFile(*this, std::move(reference), path, perms, size)); - cache[path] = file; - - return file; -} - -VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, Mode perms) { - return OpenFileFromEntry(path_, {}, perms); -} - -VirtualFile RealVfsFilesystem::CreateFile(std::string_view path_, Mode perms) { - const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); - { - std::scoped_lock lk{list_lock}; - cache.erase(path); - } - - // Current usages of CreateFile expect to delete the contents of an existing file. - if (FS::IsFile(path)) { - FS::IOFile temp{path, FS::FileAccessMode::Write, FS::FileType::BinaryFile}; - - if (!temp.IsOpen()) { - return nullptr; - } - - temp.Close(); - - return OpenFile(path, perms); - } - - if (!FS::NewFile(path)) { - return nullptr; - } - - return OpenFile(path, perms); -} - -VirtualFile RealVfsFilesystem::CopyFile(std::string_view old_path_, std::string_view new_path_) { - // Unused - return nullptr; -} - -VirtualFile RealVfsFilesystem::MoveFile(std::string_view old_path_, std::string_view new_path_) { - const auto old_path = FS::SanitizePath(old_path_, FS::DirectorySeparator::PlatformDefault); - const auto new_path = FS::SanitizePath(new_path_, FS::DirectorySeparator::PlatformDefault); - { - std::scoped_lock lk{list_lock}; - cache.erase(old_path); - cache.erase(new_path); - } - if (!FS::RenameFile(old_path, new_path)) { - return nullptr; - } - return OpenFile(new_path, Mode::ReadWrite); -} - -bool RealVfsFilesystem::DeleteFile(std::string_view path_) { - const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); - { - std::scoped_lock lk{list_lock}; - cache.erase(path); - } - return FS::RemoveFile(path); -} - -VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, Mode perms) { - const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); - return std::shared_ptr(new RealVfsDirectory(*this, path, perms)); -} - -VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, Mode perms) { - const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); - if (!FS::CreateDirs(path)) { - return nullptr; - } - return std::shared_ptr(new RealVfsDirectory(*this, path, perms)); -} - -VirtualDir RealVfsFilesystem::CopyDirectory(std::string_view old_path_, - std::string_view new_path_) { - // Unused - return nullptr; -} - -VirtualDir RealVfsFilesystem::MoveDirectory(std::string_view old_path_, - std::string_view new_path_) { - const auto old_path = FS::SanitizePath(old_path_, FS::DirectorySeparator::PlatformDefault); - const auto new_path = FS::SanitizePath(new_path_, FS::DirectorySeparator::PlatformDefault); - - if (!FS::RenameDir(old_path, new_path)) { - return nullptr; - } - return OpenDirectory(new_path, Mode::ReadWrite); -} - -bool RealVfsFilesystem::DeleteDirectory(std::string_view path_) { - const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); - return FS::RemoveDirRecursively(path); -} - -std::unique_lock RealVfsFilesystem::RefreshReference(const std::string& path, - Mode perms, - FileReference& reference) { - std::unique_lock lk{list_lock}; - - // Temporarily remove from list. - this->RemoveReferenceFromListLocked(reference); - - // Restore file if needed. - if (!reference.file) { - this->EvictSingleReferenceLocked(); - - reference.file = - FS::FileOpen(path, ModeFlagsToFileAccessMode(perms), FS::FileType::BinaryFile); - if (reference.file) { - num_open_files++; - } - } - - // Reinsert into list. - this->InsertReferenceIntoListLocked(reference); - - return lk; -} - -void RealVfsFilesystem::DropReference(std::unique_ptr&& reference) { - std::scoped_lock lk{list_lock}; - - // Remove from list. - this->RemoveReferenceFromListLocked(*reference); - - // Close the file. - if (reference->file) { - reference->file.reset(); - num_open_files--; - } -} - -void RealVfsFilesystem::EvictSingleReferenceLocked() { - if (num_open_files < MaxOpenFiles || open_references.empty()) { - return; - } - - // Get and remove from list. - auto& reference = open_references.back(); - this->RemoveReferenceFromListLocked(reference); - - // Close the file. - if (reference.file) { - reference.file.reset(); - num_open_files--; - } - - // Reinsert into closed list. - this->InsertReferenceIntoListLocked(reference); -} - -void RealVfsFilesystem::InsertReferenceIntoListLocked(FileReference& reference) { - if (reference.file) { - open_references.push_front(reference); - } else { - closed_references.push_front(reference); - } -} - -void RealVfsFilesystem::RemoveReferenceFromListLocked(FileReference& reference) { - if (reference.file) { - open_references.erase(open_references.iterator_to(reference)); - } else { - closed_references.erase(closed_references.iterator_to(reference)); - } -} - -RealVfsFile::RealVfsFile(RealVfsFilesystem& base_, std::unique_ptr reference_, - const std::string& path_, Mode perms_, std::optional size_) - : base(base_), reference(std::move(reference_)), path(path_), - parent_path(FS::GetParentPath(path_)), path_components(FS::SplitPathComponentsCopy(path_)), - size(size_), perms(perms_) {} - -RealVfsFile::~RealVfsFile() { - base.DropReference(std::move(reference)); -} - -std::string RealVfsFile::GetName() const { - return path_components.empty() ? "" : std::string(path_components.back()); -} - -std::size_t RealVfsFile::GetSize() const { - if (size) { - return *size; - } - auto lk = base.RefreshReference(path, perms, *reference); - return reference->file ? reference->file->GetSize() : 0; -} - -bool RealVfsFile::Resize(std::size_t new_size) { - size.reset(); - auto lk = base.RefreshReference(path, perms, *reference); - return reference->file ? reference->file->SetSize(new_size) : false; -} - -VirtualDir RealVfsFile::GetContainingDirectory() const { - return base.OpenDirectory(parent_path, perms); -} - -bool RealVfsFile::IsWritable() const { - return True(perms & Mode::Write); -} - -bool RealVfsFile::IsReadable() const { - return True(perms & Mode::Read); -} - -std::size_t RealVfsFile::Read(u8* data, std::size_t length, std::size_t offset) const { - auto lk = base.RefreshReference(path, perms, *reference); - if (!reference->file || !reference->file->Seek(static_cast(offset))) { - return 0; - } - return reference->file->ReadSpan(std::span{data, length}); -} - -std::size_t RealVfsFile::Write(const u8* data, std::size_t length, std::size_t offset) { - size.reset(); - auto lk = base.RefreshReference(path, perms, *reference); - if (!reference->file || !reference->file->Seek(static_cast(offset))) { - return 0; - } - return reference->file->WriteSpan(std::span{data, length}); -} - -bool RealVfsFile::Rename(std::string_view name) { - return base.MoveFile(path, parent_path + '/' + std::string(name)) != nullptr; -} - -// TODO(DarkLordZach): MSVC would not let me combine the following two functions using 'if -// constexpr' because there is a compile error in the branch not used. - -template <> -std::vector RealVfsDirectory::IterateEntries() const { - if (perms == Mode::Append) { - return {}; - } - - std::vector out; - - const FS::DirEntryCallable callback = [this, - &out](const std::filesystem::directory_entry& entry) { - const auto full_path_string = FS::PathToUTF8String(entry.path()); - - out.emplace_back(base.OpenFileFromEntry(full_path_string, entry.file_size(), perms)); - - return true; - }; - - FS::IterateDirEntries(path, callback, FS::DirEntryFilter::File); - - return out; -} - -template <> -std::vector RealVfsDirectory::IterateEntries() const { - if (perms == Mode::Append) { - return {}; - } - - std::vector out; - - const FS::DirEntryCallable callback = [this, - &out](const std::filesystem::directory_entry& entry) { - const auto full_path_string = FS::PathToUTF8String(entry.path()); - - out.emplace_back(base.OpenDirectory(full_path_string, perms)); - - return true; - }; - - FS::IterateDirEntries(path, callback, FS::DirEntryFilter::Directory); - - return out; -} - -RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string& path_, Mode perms_) - : base(base_), path(FS::RemoveTrailingSlash(path_)), parent_path(FS::GetParentPath(path)), - path_components(FS::SplitPathComponentsCopy(path)), perms(perms_) { - if (!FS::Exists(path) && True(perms & Mode::Write)) { - void(FS::CreateDirs(path)); - } -} - -RealVfsDirectory::~RealVfsDirectory() = default; - -VirtualFile RealVfsDirectory::GetFileRelative(std::string_view relative_path) const { - const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path)); - if (!FS::Exists(full_path) || FS::IsDir(full_path)) { - return nullptr; - } - return base.OpenFile(full_path, perms); -} - -VirtualDir RealVfsDirectory::GetDirectoryRelative(std::string_view relative_path) const { - const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path)); - if (!FS::Exists(full_path) || !FS::IsDir(full_path)) { - return nullptr; - } - return base.OpenDirectory(full_path, perms); -} - -VirtualFile RealVfsDirectory::GetFile(std::string_view name) const { - return GetFileRelative(name); -} - -VirtualDir RealVfsDirectory::GetSubdirectory(std::string_view name) const { - return GetDirectoryRelative(name); -} - -VirtualFile RealVfsDirectory::CreateFileRelative(std::string_view relative_path) { - const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path)); - if (!FS::CreateParentDirs(full_path)) { - return nullptr; - } - return base.CreateFile(full_path, perms); -} - -VirtualDir RealVfsDirectory::CreateDirectoryRelative(std::string_view relative_path) { - const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path)); - return base.CreateDirectory(full_path, perms); -} - -bool RealVfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) { - const auto full_path = FS::SanitizePath(this->path + '/' + std::string(name)); - return base.DeleteDirectory(full_path); -} - -std::vector RealVfsDirectory::GetFiles() const { - return IterateEntries(); -} - -FileTimeStampRaw RealVfsDirectory::GetFileTimeStamp(std::string_view path_) const { - const auto full_path = FS::SanitizePath(path + '/' + std::string(path_)); - const auto fs_path = std::filesystem::path{FS::ToU8String(full_path)}; - struct stat file_status; - -#ifdef _WIN32 - const auto stat_result = _wstat64(fs_path.c_str(), &file_status); -#else - const auto stat_result = stat(fs_path.c_str(), &file_status); -#endif - - if (stat_result != 0) { - return {}; - } - - return { - .created{static_cast(file_status.st_ctime)}, - .accessed{static_cast(file_status.st_atime)}, - .modified{static_cast(file_status.st_mtime)}, - }; -} - -std::vector RealVfsDirectory::GetSubdirectories() const { - return IterateEntries(); -} - -bool RealVfsDirectory::IsWritable() const { - return True(perms & Mode::Write); -} - -bool RealVfsDirectory::IsReadable() const { - return True(perms & Mode::Read); -} - -std::string RealVfsDirectory::GetName() const { - return path_components.empty() ? "" : std::string(path_components.back()); -} - -VirtualDir RealVfsDirectory::GetParentDirectory() const { - if (path_components.size() <= 1) { - return nullptr; - } - - return base.OpenDirectory(parent_path, perms); -} - -VirtualDir RealVfsDirectory::CreateSubdirectory(std::string_view name) { - const std::string subdir_path = (path + '/').append(name); - return base.CreateDirectory(subdir_path, perms); -} - -VirtualFile RealVfsDirectory::CreateFile(std::string_view name) { - const std::string file_path = (path + '/').append(name); - return base.CreateFile(file_path, perms); -} - -bool RealVfsDirectory::DeleteSubdirectory(std::string_view name) { - const std::string subdir_path = (path + '/').append(name); - return base.DeleteDirectory(subdir_path); -} - -bool RealVfsDirectory::DeleteFile(std::string_view name) { - const std::string file_path = (path + '/').append(name); - return base.DeleteFile(file_path); -} - -bool RealVfsDirectory::Rename(std::string_view name) { - const std::string new_name = (parent_path + '/').append(name); - return base.MoveFile(path, new_name) != nullptr; -} - -std::string RealVfsDirectory::GetFullPath() const { - auto out = path; - std::replace(out.begin(), out.end(), '\\', '/'); - return out; -} - -std::map> RealVfsDirectory::GetEntries() const { - if (perms == Mode::Append) { - return {}; - } - - std::map> out; - - const FS::DirEntryCallable callback = [&out](const std::filesystem::directory_entry& entry) { - const auto filename = FS::PathToUTF8String(entry.path().filename()); - out.insert_or_assign(filename, - entry.is_directory() ? VfsEntryType::Directory : VfsEntryType::File); - return true; - }; - - FS::IterateDirEntries(path, callback); - - return out; -} - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_real.h b/src/core/file_sys/vfs_real.h deleted file mode 100644 index 26ea7df62..000000000 --- a/src/core/file_sys/vfs_real.h +++ /dev/null @@ -1,145 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include -#include -#include -#include -#include "common/intrusive_list.h" -#include "core/file_sys/mode.h" -#include "core/file_sys/vfs.h" - -namespace Common::FS { -class IOFile; -} - -namespace FileSys { - -struct FileReference : public Common::IntrusiveListBaseNode { - std::shared_ptr file{}; -}; - -class RealVfsFile; -class RealVfsDirectory; - -class RealVfsFilesystem : public VfsFilesystem { -public: - RealVfsFilesystem(); - ~RealVfsFilesystem() override; - - std::string GetName() const override; - bool IsReadable() const override; - bool IsWritable() const override; - VfsEntryType GetEntryType(std::string_view path) const override; - VirtualFile OpenFile(std::string_view path, Mode perms = Mode::Read) override; - VirtualFile CreateFile(std::string_view path, Mode perms = Mode::ReadWrite) override; - VirtualFile CopyFile(std::string_view old_path, std::string_view new_path) override; - VirtualFile MoveFile(std::string_view old_path, std::string_view new_path) override; - bool DeleteFile(std::string_view path) override; - VirtualDir OpenDirectory(std::string_view path, Mode perms = Mode::Read) override; - VirtualDir CreateDirectory(std::string_view path, Mode perms = Mode::ReadWrite) override; - VirtualDir CopyDirectory(std::string_view old_path, std::string_view new_path) override; - VirtualDir MoveDirectory(std::string_view old_path, std::string_view new_path) override; - bool DeleteDirectory(std::string_view path) override; - -private: - using ReferenceListType = Common::IntrusiveListBaseTraits::ListType; - std::map, std::less<>> cache; - ReferenceListType open_references; - ReferenceListType closed_references; - std::mutex list_lock; - size_t num_open_files{}; - -private: - friend class RealVfsFile; - std::unique_lock RefreshReference(const std::string& path, Mode perms, - FileReference& reference); - void DropReference(std::unique_ptr&& reference); - -private: - friend class RealVfsDirectory; - VirtualFile OpenFileFromEntry(std::string_view path, std::optional size, - Mode perms = Mode::Read); - -private: - void EvictSingleReferenceLocked(); - void InsertReferenceIntoListLocked(FileReference& reference); - void RemoveReferenceFromListLocked(FileReference& reference); -}; - -// An implementation of VfsFile that represents a file on the user's computer. -class RealVfsFile : public VfsFile { - friend class RealVfsDirectory; - friend class RealVfsFilesystem; - -public: - ~RealVfsFile() override; - - std::string GetName() const override; - std::size_t GetSize() const override; - bool Resize(std::size_t new_size) override; - VirtualDir GetContainingDirectory() const override; - bool IsWritable() const override; - bool IsReadable() const override; - std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override; - std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override; - bool Rename(std::string_view name) override; - -private: - RealVfsFile(RealVfsFilesystem& base, std::unique_ptr reference, - const std::string& path, Mode perms = Mode::Read, std::optional size = {}); - - RealVfsFilesystem& base; - std::unique_ptr reference; - std::string path; - std::string parent_path; - std::vector path_components; - std::optional size; - Mode perms; -}; - -// An implementation of VfsDirectory that represents a directory on the user's computer. -class RealVfsDirectory : public VfsDirectory { - friend class RealVfsFilesystem; - -public: - ~RealVfsDirectory() override; - - VirtualFile GetFileRelative(std::string_view relative_path) const override; - VirtualDir GetDirectoryRelative(std::string_view relative_path) const override; - VirtualFile GetFile(std::string_view name) const override; - VirtualDir GetSubdirectory(std::string_view name) const override; - VirtualFile CreateFileRelative(std::string_view relative_path) override; - VirtualDir CreateDirectoryRelative(std::string_view relative_path) override; - bool DeleteSubdirectoryRecursive(std::string_view name) override; - std::vector GetFiles() const override; - FileTimeStampRaw GetFileTimeStamp(std::string_view path) const override; - std::vector GetSubdirectories() const override; - bool IsWritable() const override; - bool IsReadable() const override; - std::string GetName() const override; - VirtualDir GetParentDirectory() const override; - VirtualDir CreateSubdirectory(std::string_view name) override; - VirtualFile CreateFile(std::string_view name) override; - bool DeleteSubdirectory(std::string_view name) override; - bool DeleteFile(std::string_view name) override; - bool Rename(std::string_view name) override; - std::string GetFullPath() const override; - std::map> GetEntries() const override; - -private: - RealVfsDirectory(RealVfsFilesystem& base, const std::string& path, Mode perms = Mode::Read); - - template - std::vector> IterateEntries() const; - - RealVfsFilesystem& base; - std::string path; - std::string parent_path; - std::vector path_components; - Mode perms; -}; - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_static.h b/src/core/file_sys/vfs_static.h deleted file mode 100644 index ca3f989ef..000000000 --- a/src/core/file_sys/vfs_static.h +++ /dev/null @@ -1,80 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include -#include -#include - -#include "core/file_sys/vfs.h" - -namespace FileSys { - -class StaticVfsFile : public VfsFile { -public: - explicit StaticVfsFile(u8 value_, std::size_t size_ = 0, std::string name_ = "", - VirtualDir parent_ = nullptr) - : value{value_}, size{size_}, name{std::move(name_)}, parent{std::move(parent_)} {} - - std::string GetName() const override { - return name; - } - - std::size_t GetSize() const override { - return size; - } - - bool Resize(std::size_t new_size) override { - size = new_size; - return true; - } - - VirtualDir GetContainingDirectory() const override { - return parent; - } - - bool IsWritable() const override { - return false; - } - - bool IsReadable() const override { - return true; - } - - std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override { - const auto read = std::min(length, size - offset); - std::fill(data, data + read, value); - return read; - } - - std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override { - return 0; - } - - std::optional ReadByte(std::size_t offset) const override { - if (offset >= size) { - return std::nullopt; - } - - return value; - } - - std::vector ReadBytes(std::size_t length, std::size_t offset) const override { - const auto read = std::min(length, size - offset); - return std::vector(read, value); - } - - bool Rename(std::string_view new_name) override { - name = new_name; - return true; - } - -private: - u8 value; - std::size_t size; - std::string name; - VirtualDir parent; -}; - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_types.h b/src/core/file_sys/vfs_types.h deleted file mode 100644 index 4a583ed64..000000000 --- a/src/core/file_sys/vfs_types.h +++ /dev/null @@ -1,29 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include - -#include "common/common_types.h" - -namespace FileSys { - -class VfsDirectory; -class VfsFile; -class VfsFilesystem; - -// Declarations for Vfs* pointer types - -using VirtualDir = std::shared_ptr; -using VirtualFile = std::shared_ptr; -using VirtualFilesystem = std::shared_ptr; - -struct FileTimeStampRaw { - u64 created{}; - u64 accessed{}; - u64 modified{}; - u64 padding{}; -}; - -} // namespace FileSys diff --git a/src/core/file_sys/vfs_vector.cpp b/src/core/file_sys/vfs_vector.cpp deleted file mode 100644 index 251d9d7c9..000000000 --- a/src/core/file_sys/vfs_vector.cpp +++ /dev/null @@ -1,133 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include -#include -#include "core/file_sys/vfs_vector.h" - -namespace FileSys { -VectorVfsFile::VectorVfsFile(std::vector initial_data, std::string name_, VirtualDir parent_) - : data(std::move(initial_data)), parent(std::move(parent_)), name(std::move(name_)) {} - -VectorVfsFile::~VectorVfsFile() = default; - -std::string VectorVfsFile::GetName() const { - return name; -} - -size_t VectorVfsFile::GetSize() const { - return data.size(); -} - -bool VectorVfsFile::Resize(size_t new_size) { - data.resize(new_size); - return true; -} - -VirtualDir VectorVfsFile::GetContainingDirectory() const { - return parent; -} - -bool VectorVfsFile::IsWritable() const { - return true; -} - -bool VectorVfsFile::IsReadable() const { - return true; -} - -std::size_t VectorVfsFile::Read(u8* data_, std::size_t length, std::size_t offset) const { - const auto read = std::min(length, data.size() - offset); - std::memcpy(data_, data.data() + offset, read); - return read; -} - -std::size_t VectorVfsFile::Write(const u8* data_, std::size_t length, std::size_t offset) { - if (offset + length > data.size()) - data.resize(offset + length); - const auto write = std::min(length, data.size() - offset); - std::memcpy(data.data() + offset, data_, write); - return write; -} - -bool VectorVfsFile::Rename(std::string_view name_) { - name = name_; - return true; -} - -void VectorVfsFile::Assign(std::vector new_data) { - data = std::move(new_data); -} - -VectorVfsDirectory::VectorVfsDirectory(std::vector files_, - std::vector dirs_, std::string name_, - VirtualDir parent_) - : files(std::move(files_)), dirs(std::move(dirs_)), parent(std::move(parent_)), - name(std::move(name_)) {} - -VectorVfsDirectory::~VectorVfsDirectory() = default; - -std::vector VectorVfsDirectory::GetFiles() const { - return files; -} - -std::vector VectorVfsDirectory::GetSubdirectories() const { - return dirs; -} - -bool VectorVfsDirectory::IsWritable() const { - return false; -} - -bool VectorVfsDirectory::IsReadable() const { - return true; -} - -std::string VectorVfsDirectory::GetName() const { - return name; -} - -VirtualDir VectorVfsDirectory::GetParentDirectory() const { - return parent; -} - -template -static bool FindAndRemoveVectorElement(std::vector& vec, std::string_view name) { - const auto iter = - std::find_if(vec.begin(), vec.end(), [name](const T& e) { return e->GetName() == name; }); - if (iter == vec.end()) - return false; - - vec.erase(iter); - return true; -} - -bool VectorVfsDirectory::DeleteSubdirectory(std::string_view subdir_name) { - return FindAndRemoveVectorElement(dirs, subdir_name); -} - -bool VectorVfsDirectory::DeleteFile(std::string_view file_name) { - return FindAndRemoveVectorElement(files, file_name); -} - -bool VectorVfsDirectory::Rename(std::string_view name_) { - name = name_; - return true; -} - -VirtualDir VectorVfsDirectory::CreateSubdirectory(std::string_view subdir_name) { - return nullptr; -} - -VirtualFile VectorVfsDirectory::CreateFile(std::string_view file_name) { - return nullptr; -} - -void VectorVfsDirectory::AddFile(VirtualFile file) { - files.push_back(std::move(file)); -} - -void VectorVfsDirectory::AddDirectory(VirtualDir dir) { - dirs.push_back(std::move(dir)); -} -} // namespace FileSys diff --git a/src/core/file_sys/vfs_vector.h b/src/core/file_sys/vfs_vector.h deleted file mode 100644 index bfedb6e42..000000000 --- a/src/core/file_sys/vfs_vector.h +++ /dev/null @@ -1,131 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include -#include -#include -#include -#include -#include "core/file_sys/vfs.h" - -namespace FileSys { - -// An implementation of VfsFile that is backed by a statically-sized array -template -class ArrayVfsFile : public VfsFile { -public: - explicit ArrayVfsFile(const std::array& data_, std::string name_ = "", - VirtualDir parent_ = nullptr) - : data(data_), name(std::move(name_)), parent(std::move(parent_)) {} - - std::string GetName() const override { - return name; - } - - std::size_t GetSize() const override { - return size; - } - - bool Resize(std::size_t new_size) override { - return false; - } - - VirtualDir GetContainingDirectory() const override { - return parent; - } - - bool IsWritable() const override { - return false; - } - - bool IsReadable() const override { - return true; - } - - std::size_t Read(u8* data_, std::size_t length, std::size_t offset) const override { - const auto read = std::min(length, size - offset); - std::memcpy(data_, data.data() + offset, read); - return read; - } - - std::size_t Write(const u8* data_, std::size_t length, std::size_t offset) override { - return 0; - } - - bool Rename(std::string_view new_name) override { - name = new_name; - return true; - } - -private: - std::array data; - std::string name; - VirtualDir parent; -}; - -template -std::shared_ptr> MakeArrayFile(const std::array& data, - Args&&... args) { - return std::make_shared>(data, std::forward(args)...); -} - -// An implementation of VfsFile that is backed by a vector optionally supplied upon construction -class VectorVfsFile : public VfsFile { -public: - explicit VectorVfsFile(std::vector initial_data = {}, std::string name_ = "", - VirtualDir parent_ = nullptr); - ~VectorVfsFile() override; - - std::string GetName() const override; - std::size_t GetSize() const override; - bool Resize(std::size_t new_size) override; - VirtualDir GetContainingDirectory() const override; - bool IsWritable() const override; - bool IsReadable() const override; - std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override; - std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override; - bool Rename(std::string_view name) override; - - virtual void Assign(std::vector new_data); - -private: - std::vector data; - VirtualDir parent; - std::string name; -}; - -// An implementation of VfsDirectory that maintains two vectors for subdirectories and files. -// Vector data is supplied upon construction. -class VectorVfsDirectory : public VfsDirectory { -public: - explicit VectorVfsDirectory(std::vector files = {}, - std::vector dirs = {}, std::string name = "", - VirtualDir parent = nullptr); - ~VectorVfsDirectory() override; - - std::vector GetFiles() const override; - std::vector GetSubdirectories() const override; - bool IsWritable() const override; - bool IsReadable() const override; - std::string GetName() const override; - VirtualDir GetParentDirectory() const override; - bool DeleteSubdirectory(std::string_view subdir_name) override; - bool DeleteFile(std::string_view file_name) override; - bool Rename(std::string_view name) override; - VirtualDir CreateSubdirectory(std::string_view subdir_name) override; - VirtualFile CreateFile(std::string_view file_name) override; - - virtual void AddFile(VirtualFile file); - virtual void AddDirectory(VirtualDir dir); - -private: - std::vector files; - std::vector dirs; - - VirtualDir parent; - std::string name; -}; - -} // namespace FileSys diff --git a/src/core/file_sys/xts_archive.cpp b/src/core/file_sys/xts_archive.cpp index ede0aa11a..6692211e1 100644 --- a/src/core/file_sys/xts_archive.cpp +++ b/src/core/file_sys/xts_archive.cpp @@ -17,7 +17,7 @@ #include "core/crypto/key_manager.h" #include "core/crypto/xts_encryption_layer.h" #include "core/file_sys/content_archive.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs_offset.h" #include "core/file_sys/xts_archive.h" #include "core/loader/loader.h" diff --git a/src/core/file_sys/xts_archive.h b/src/core/file_sys/xts_archive.h index abbe5f716..7589b7c38 100644 --- a/src/core/file_sys/xts_archive.h +++ b/src/core/file_sys/xts_archive.h @@ -8,7 +8,7 @@ #include "common/common_types.h" #include "common/swap.h" #include "core/crypto/key_manager.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace Loader { enum class ResultStatus : u16; diff --git a/src/core/hle/service/am/applets/applet_web_browser.cpp b/src/core/hle/service/am/applets/applet_web_browser.cpp index b0ea2b381..0c826ded7 100644 --- a/src/core/hle/service/am/applets/applet_web_browser.cpp +++ b/src/core/hle/service/am/applets/applet_web_browser.cpp @@ -15,7 +15,7 @@ #include "core/file_sys/registered_cache.h" #include "core/file_sys/romfs.h" #include "core/file_sys/system_archive/system_archive.h" -#include "core/file_sys/vfs_vector.h" +#include "core/file_sys/vfs/vfs_vector.h" #include "core/frontend/applets/web_browser.h" #include "core/hle/result.h" #include "core/hle/service/am/am.h" diff --git a/src/core/hle/service/am/applets/applet_web_browser.h b/src/core/hle/service/am/applets/applet_web_browser.h index 99fe18659..36adb2510 100644 --- a/src/core/hle/service/am/applets/applet_web_browser.h +++ b/src/core/hle/service/am/applets/applet_web_browser.h @@ -7,7 +7,7 @@ #include #include "common/common_types.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" #include "core/hle/result.h" #include "core/hle/service/am/applets/applet_web_browser_types.h" #include "core/hle/service/am/applets/applets.h" diff --git a/src/core/hle/service/bcat/backend/backend.h b/src/core/hle/service/bcat/backend/backend.h index 205ed0702..aa36d29d5 100644 --- a/src/core/hle/service/bcat/backend/backend.h +++ b/src/core/hle/service/bcat/backend/backend.h @@ -8,7 +8,7 @@ #include #include "common/common_types.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" #include "core/hle/result.h" #include "core/hle/service/kernel_helpers.h" diff --git a/src/core/hle/service/bcat/bcat_module.cpp b/src/core/hle/service/bcat/bcat_module.cpp index a6281913a..76d7bb139 100644 --- a/src/core/hle/service/bcat/bcat_module.cpp +++ b/src/core/hle/service/bcat/bcat_module.cpp @@ -8,7 +8,7 @@ #include "common/settings.h" #include "common/string_util.h" #include "core/core.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/hle/kernel/k_readable_event.h" #include "core/hle/service/bcat/backend/backend.h" #include "core/hle/service/bcat/bcat.h" diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp index ab4974ac5..4ae6ef0bd 100644 --- a/src/core/hle/service/filesystem/filesystem.cpp +++ b/src/core/hle/service/filesystem/filesystem.cpp @@ -18,8 +18,8 @@ #include "core/file_sys/romfs_factory.h" #include "core/file_sys/savedata_factory.h" #include "core/file_sys/sdmc_factory.h" -#include "core/file_sys/vfs.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs.h" +#include "core/file_sys/vfs/vfs_offset.h" #include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/filesystem/fsp/fsp_ldr.h" #include "core/hle/service/filesystem/fsp/fsp_pr.h" diff --git a/src/core/hle/service/filesystem/filesystem.h b/src/core/hle/service/filesystem/filesystem.h index 48f37d289..65dcdb514 100644 --- a/src/core/hle/service/filesystem/filesystem.h +++ b/src/core/hle/service/filesystem/filesystem.h @@ -6,7 +6,7 @@ #include #include "common/common_types.h" #include "core/file_sys/directory.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/hle/result.h" namespace Core { diff --git a/src/core/hle/service/filesystem/fsp/fs_i_directory.h b/src/core/hle/service/filesystem/fsp/fs_i_directory.h index 2a28ee496..ecc4ecada 100644 --- a/src/core/hle/service/filesystem/fsp/fs_i_directory.h +++ b/src/core/hle/service/filesystem/fsp/fs_i_directory.h @@ -3,7 +3,7 @@ #pragma once -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/filesystem/fsp_util.h" #include "core/hle/service/service.h" diff --git a/src/core/hle/service/filesystem/fsp/fs_i_filesystem.h b/src/core/hle/service/filesystem/fsp/fs_i_filesystem.h index c9e94c911..b06b3ef0e 100644 --- a/src/core/hle/service/filesystem/fsp/fs_i_filesystem.h +++ b/src/core/hle/service/filesystem/fsp/fs_i_filesystem.h @@ -3,7 +3,7 @@ #pragma once -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/filesystem/fsp/fsp_util.h" #include "core/hle/service/service.h" diff --git a/src/core/hle/service/filesystem/fsp/fs_i_storage.h b/src/core/hle/service/filesystem/fsp/fs_i_storage.h index 48d059874..cb5bebcc9 100644 --- a/src/core/hle/service/filesystem/fsp/fs_i_storage.h +++ b/src/core/hle/service/filesystem/fsp/fs_i_storage.h @@ -3,7 +3,7 @@ #pragma once -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/service.h" diff --git a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp index 85ab75517..d04fb079f 100644 --- a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp +++ b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp @@ -23,7 +23,7 @@ #include "core/file_sys/romfs_factory.h" #include "core/file_sys/savedata_factory.h" #include "core/file_sys/system_archive/system_archive.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/hle/result.h" #include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/filesystem/fsp/fs_i_filesystem.h" diff --git a/src/core/hle/service/filesystem/romfs_controller.h b/src/core/hle/service/filesystem/romfs_controller.h index 9a478f71d..3c3ead344 100644 --- a/src/core/hle/service/filesystem/romfs_controller.h +++ b/src/core/hle/service/filesystem/romfs_controller.h @@ -5,7 +5,7 @@ #include "core/file_sys/nca_metadata.h" #include "core/file_sys/romfs_factory.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace Service::FileSystem { diff --git a/src/core/hle/service/filesystem/save_data_controller.h b/src/core/hle/service/filesystem/save_data_controller.h index 863188e4c..dc9d713df 100644 --- a/src/core/hle/service/filesystem/save_data_controller.h +++ b/src/core/hle/service/filesystem/save_data_controller.h @@ -5,7 +5,7 @@ #include "core/file_sys/nca_metadata.h" #include "core/file_sys/savedata_factory.h" -#include "core/file_sys/vfs_types.h" +#include "core/file_sys/vfs/vfs_types.h" namespace Service::FileSystem { diff --git a/src/core/hle/service/ns/ns.cpp b/src/core/hle/service/ns/ns.cpp index a25b79513..2258ee609 100644 --- a/src/core/hle/service/ns/ns.cpp +++ b/src/core/hle/service/ns/ns.cpp @@ -6,7 +6,7 @@ #include "core/core.h" #include "core/file_sys/control_metadata.h" #include "core/file_sys/patch_manager.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" #include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/glue/glue_manager.h" #include "core/hle/service/ipc_helpers.h" diff --git a/src/core/loader/loader.h b/src/core/loader/loader.h index b4828f7cd..f4e932cec 100644 --- a/src/core/loader/loader.h +++ b/src/core/loader/loader.h @@ -14,7 +14,7 @@ #include "common/common_funcs.h" #include "common/common_types.h" #include "core/file_sys/control_metadata.h" -#include "core/file_sys/vfs.h" +#include "core/file_sys/vfs/vfs.h" namespace Core { class System; diff --git a/src/core/loader/nro.cpp b/src/core/loader/nro.cpp index f8225d697..1d96dc4c8 100644 --- a/src/core/loader/nro.cpp +++ b/src/core/loader/nro.cpp @@ -12,7 +12,7 @@ #include "core/core.h" #include "core/file_sys/control_metadata.h" #include "core/file_sys/romfs_factory.h" -#include "core/file_sys/vfs_offset.h" +#include "core/file_sys/vfs/vfs_offset.h" #include "core/hle/kernel/code_set.h" #include "core/hle/kernel/k_page_table.h" #include "core/hle/kernel/k_process.h" -- cgit v1.2.3