fs: Replace Mode enum by OpenMode enum

This commit is contained in:
FearlessTobi 2024-01-18 21:31:41 +01:00 committed by Liam
parent 0f9288e38d
commit cc09c265e1
21 changed files with 195 additions and 188 deletions

View file

@ -21,7 +21,7 @@
#include "core/debugger/debugger.h" #include "core/debugger/debugger.h"
#include "core/device_memory.h" #include "core/device_memory.h"
#include "core/file_sys/bis_factory.h" #include "core/file_sys/bis_factory.h"
#include "core/file_sys/mode.h" #include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/patch_manager.h" #include "core/file_sys/patch_manager.h"
#include "core/file_sys/registered_cache.h" #include "core/file_sys/registered_cache.h"
#include "core/file_sys/romfs_factory.h" #include "core/file_sys/romfs_factory.h"
@ -102,7 +102,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
Common::SplitPath(path, &dir_name, &filename, nullptr); Common::SplitPath(path, &dir_name, &filename, nullptr);
if (filename == "00") { if (filename == "00") {
const auto dir = vfs->OpenDirectory(dir_name, FileSys::Mode::Read); const auto dir = vfs->OpenDirectory(dir_name, FileSys::OpenMode::Read);
std::vector<FileSys::VirtualFile> concat; std::vector<FileSys::VirtualFile> concat;
for (u32 i = 0; i < 0x10; ++i) { for (u32 i = 0; i < 0x10; ++i) {
@ -127,10 +127,10 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
} }
if (Common::FS::IsDir(path)) { if (Common::FS::IsDir(path)) {
return vfs->OpenFile(path + "/main", FileSys::Mode::Read); return vfs->OpenFile(path + "/main", FileSys::OpenMode::Read);
} }
return vfs->OpenFile(path, FileSys::Mode::Read); return vfs->OpenFile(path, FileSys::OpenMode::Read);
} }
struct System::Impl { struct System::Impl {

View file

@ -4,7 +4,6 @@
#include <fmt/format.h> #include <fmt/format.h>
#include "common/fs/path_util.h" #include "common/fs/path_util.h"
#include "core/file_sys/bis_factory.h" #include "core/file_sys/bis_factory.h"
#include "core/file_sys/mode.h"
#include "core/file_sys/registered_cache.h" #include "core/file_sys/registered_cache.h"
#include "core/file_sys/vfs/vfs.h" #include "core/file_sys/vfs/vfs.h"
@ -84,7 +83,7 @@ VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id,
VirtualFilesystem file_system) const { VirtualFilesystem file_system) const {
auto& keys = Core::Crypto::KeyManager::Instance(); auto& keys = Core::Crypto::KeyManager::Instance();
Core::Crypto::PartitionDataManager pdm{file_system->OpenDirectory( Core::Crypto::PartitionDataManager pdm{file_system->OpenDirectory(
Common::FS::GetYuzuPathString(Common::FS::YuzuPath::NANDDir), Mode::Read)}; Common::FS::GetYuzuPathString(Common::FS::YuzuPath::NANDDir), OpenMode::Read)};
keys.PopulateFromPartitionData(pdm); keys.PopulateFromPartitionData(pdm);
switch (id) { switch (id) {

View file

@ -1,39 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <cstddef>
#include "common/common_funcs.h"
#include "common/common_types.h"
////////////////////////////////////////////////////////////////////////////////////////////////////
// FileSys namespace
namespace FileSys {
enum class EntryType : u8 {
Directory = 0,
File = 1,
};
// Structure of a directory entry, from
// http://switchbrew.org/index.php?title=Filesystem_services#DirectoryEntry
struct Entry {
Entry(std::string_view view, EntryType entry_type, u64 entry_size)
: type{entry_type}, file_size{entry_size} {
const std::size_t copy_size = view.copy(filename, std::size(filename) - 1);
filename[copy_size] = '\0';
}
char filename[0x301];
INSERT_PADDING_BYTES(3);
EntryType type;
INSERT_PADDING_BYTES(3);
u64 file_size;
};
static_assert(sizeof(Entry) == 0x310, "Directory Entry struct isn't exactly 0x310 bytes long!");
static_assert(offsetof(Entry, type) == 0x304, "Wrong offset for type in Entry.");
static_assert(offsetof(Entry, file_size) == 0x308, "Wrong offset for file_size in Entry.");
} // namespace FileSys

View file

@ -0,0 +1,33 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
namespace FileSys {
constexpr inline size_t EntryNameLengthMax = 0x300;
struct DirectoryEntry {
DirectoryEntry(std::string_view view, s8 entry_type, u64 entry_size)
: type{entry_type}, file_size{static_cast<s64>(entry_size)} {
const std::size_t copy_size = view.copy(name, std::size(name) - 1);
name[copy_size] = '\0';
}
char name[EntryNameLengthMax + 1];
INSERT_PADDING_BYTES(3);
s8 type;
INSERT_PADDING_BYTES(3);
s64 file_size;
};
static_assert(sizeof(DirectoryEntry) == 0x310,
"Directory Entry struct isn't exactly 0x310 bytes long!");
static_assert(offsetof(DirectoryEntry, type) == 0x304, "Wrong offset for type in Entry.");
static_assert(offsetof(DirectoryEntry, file_size) == 0x308, "Wrong offset for file_size in Entry.");
struct DirectoryHandle {
void* handle;
};
} // namespace FileSys

View file

@ -0,0 +1,39 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
namespace FileSys {
enum class OpenMode : u32 {
Read = (1 << 0),
Write = (1 << 1),
AllowAppend = (1 << 2),
ReadWrite = (Read | Write),
All = (ReadWrite | AllowAppend),
};
DECLARE_ENUM_FLAG_OPERATORS(OpenMode)
enum class OpenDirectoryMode : u64 {
Directory = (1 << 0),
File = (1 << 1),
All = (Directory | File),
/* TODO: Separate enum, like N? */
_NotRequireFileSize = (1 << 31),
};
DECLARE_ENUM_FLAG_OPERATORS(OpenDirectoryMode)
enum class DirectoryEntryType : u8 {
Directory = 0,
File = 1,
};
enum class CreateOption : u8 {
None = (0 << 0),
BigFile = (1 << 0),
};
} // namespace FileSys

View file

@ -1,23 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/common_funcs.h"
#include "common/common_types.h"
namespace FileSys {
enum class Mode : u32 {
Read = 1 << 0,
Write = 1 << 1,
ReadWrite = Read | Write,
Append = 1 << 2,
ReadAppend = Read | Append,
WriteAppend = Write | Append,
All = ReadWrite | Append,
};
DECLARE_ENUM_FLAG_OPERATORS(Mode)
} // namespace FileSys

View file

@ -5,7 +5,6 @@
#include <numeric> #include <numeric>
#include <string> #include <string>
#include "common/fs/path_util.h" #include "common/fs/path_util.h"
#include "core/file_sys/mode.h"
#include "core/file_sys/vfs/vfs.h" #include "core/file_sys/vfs/vfs.h"
namespace FileSys { namespace FileSys {
@ -36,12 +35,12 @@ VfsEntryType VfsFilesystem::GetEntryType(std::string_view path_) const {
return VfsEntryType::None; return VfsEntryType::None;
} }
VirtualFile VfsFilesystem::OpenFile(std::string_view path_, Mode perms) { VirtualFile VfsFilesystem::OpenFile(std::string_view path_, OpenMode perms) {
const auto path = Common::FS::SanitizePath(path_); const auto path = Common::FS::SanitizePath(path_);
return root->GetFileRelative(path); return root->GetFileRelative(path);
} }
VirtualFile VfsFilesystem::CreateFile(std::string_view path_, Mode perms) { VirtualFile VfsFilesystem::CreateFile(std::string_view path_, OpenMode perms) {
const auto path = Common::FS::SanitizePath(path_); const auto path = Common::FS::SanitizePath(path_);
return root->CreateFileRelative(path); return root->CreateFileRelative(path);
} }
@ -54,17 +53,17 @@ VirtualFile VfsFilesystem::CopyFile(std::string_view old_path_, std::string_view
if (Common::FS::GetParentPath(old_path) == Common::FS::GetParentPath(new_path)) { if (Common::FS::GetParentPath(old_path) == Common::FS::GetParentPath(new_path)) {
if (!root->Copy(Common::FS::GetFilename(old_path), Common::FS::GetFilename(new_path))) if (!root->Copy(Common::FS::GetFilename(old_path), Common::FS::GetFilename(new_path)))
return nullptr; return nullptr;
return OpenFile(new_path, Mode::ReadWrite); return OpenFile(new_path, OpenMode::ReadWrite);
} }
// Do it using RawCopy. Non-default impls are encouraged to optimize this. // Do it using RawCopy. Non-default impls are encouraged to optimize this.
const auto old_file = OpenFile(old_path, Mode::Read); const auto old_file = OpenFile(old_path, OpenMode::Read);
if (old_file == nullptr) if (old_file == nullptr)
return nullptr; return nullptr;
auto new_file = OpenFile(new_path, Mode::Read); auto new_file = OpenFile(new_path, OpenMode::Read);
if (new_file != nullptr) if (new_file != nullptr)
return nullptr; return nullptr;
new_file = CreateFile(new_path, Mode::Write); new_file = CreateFile(new_path, OpenMode::Write);
if (new_file == nullptr) if (new_file == nullptr)
return nullptr; return nullptr;
if (!VfsRawCopy(old_file, new_file)) if (!VfsRawCopy(old_file, new_file))
@ -87,18 +86,18 @@ VirtualFile VfsFilesystem::MoveFile(std::string_view old_path, std::string_view
bool VfsFilesystem::DeleteFile(std::string_view path_) { bool VfsFilesystem::DeleteFile(std::string_view path_) {
const auto path = Common::FS::SanitizePath(path_); const auto path = Common::FS::SanitizePath(path_);
auto parent = OpenDirectory(Common::FS::GetParentPath(path), Mode::Write); auto parent = OpenDirectory(Common::FS::GetParentPath(path), OpenMode::Write);
if (parent == nullptr) if (parent == nullptr)
return false; return false;
return parent->DeleteFile(Common::FS::GetFilename(path)); return parent->DeleteFile(Common::FS::GetFilename(path));
} }
VirtualDir VfsFilesystem::OpenDirectory(std::string_view path_, Mode perms) { VirtualDir VfsFilesystem::OpenDirectory(std::string_view path_, OpenMode perms) {
const auto path = Common::FS::SanitizePath(path_); const auto path = Common::FS::SanitizePath(path_);
return root->GetDirectoryRelative(path); return root->GetDirectoryRelative(path);
} }
VirtualDir VfsFilesystem::CreateDirectory(std::string_view path_, Mode perms) { VirtualDir VfsFilesystem::CreateDirectory(std::string_view path_, OpenMode perms) {
const auto path = Common::FS::SanitizePath(path_); const auto path = Common::FS::SanitizePath(path_);
return root->CreateDirectoryRelative(path); return root->CreateDirectoryRelative(path);
} }
@ -108,13 +107,13 @@ VirtualDir VfsFilesystem::CopyDirectory(std::string_view old_path_, std::string_
const auto new_path = Common::FS::SanitizePath(new_path_); const auto new_path = Common::FS::SanitizePath(new_path_);
// Non-default impls are highly encouraged to provide a more optimized version of this. // Non-default impls are highly encouraged to provide a more optimized version of this.
auto old_dir = OpenDirectory(old_path, Mode::Read); auto old_dir = OpenDirectory(old_path, OpenMode::Read);
if (old_dir == nullptr) if (old_dir == nullptr)
return nullptr; return nullptr;
auto new_dir = OpenDirectory(new_path, Mode::Read); auto new_dir = OpenDirectory(new_path, OpenMode::Read);
if (new_dir != nullptr) if (new_dir != nullptr)
return nullptr; return nullptr;
new_dir = CreateDirectory(new_path, Mode::Write); new_dir = CreateDirectory(new_path, OpenMode::Write);
if (new_dir == nullptr) if (new_dir == nullptr)
return nullptr; return nullptr;
@ -149,7 +148,7 @@ VirtualDir VfsFilesystem::MoveDirectory(std::string_view old_path, std::string_v
bool VfsFilesystem::DeleteDirectory(std::string_view path_) { bool VfsFilesystem::DeleteDirectory(std::string_view path_) {
const auto path = Common::FS::SanitizePath(path_); const auto path = Common::FS::SanitizePath(path_);
auto parent = OpenDirectory(Common::FS::GetParentPath(path), Mode::Write); auto parent = OpenDirectory(Common::FS::GetParentPath(path), OpenMode::Write);
if (parent == nullptr) if (parent == nullptr)
return false; return false;
return parent->DeleteSubdirectoryRecursive(Common::FS::GetFilename(path)); return parent->DeleteSubdirectoryRecursive(Common::FS::GetFilename(path));

View file

@ -13,12 +13,11 @@
#include "common/common_funcs.h" #include "common/common_funcs.h"
#include "common/common_types.h" #include "common/common_types.h"
#include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/vfs/vfs_types.h" #include "core/file_sys/vfs/vfs_types.h"
namespace FileSys { namespace FileSys {
enum class Mode : u32;
// An enumeration representing what can be at the end of a path in a VfsFilesystem // An enumeration representing what can be at the end of a path in a VfsFilesystem
enum class VfsEntryType { enum class VfsEntryType {
None, None,
@ -49,9 +48,9 @@ public:
virtual VfsEntryType GetEntryType(std::string_view path) const; virtual VfsEntryType GetEntryType(std::string_view path) const;
// Opens the file with path relative to root. If it doesn't exist, returns nullptr. // Opens the file with path relative to root. If it doesn't exist, returns nullptr.
virtual VirtualFile OpenFile(std::string_view path, Mode perms); virtual VirtualFile OpenFile(std::string_view path, OpenMode perms);
// Creates a new, empty file at path // Creates a new, empty file at path
virtual VirtualFile CreateFile(std::string_view path, Mode perms); virtual VirtualFile CreateFile(std::string_view path, OpenMode perms);
// Copies the file from old_path to new_path, returning the new file on success and nullptr on // Copies the file from old_path to new_path, returning the new file on success and nullptr on
// failure. // failure.
virtual VirtualFile CopyFile(std::string_view old_path, std::string_view new_path); virtual VirtualFile CopyFile(std::string_view old_path, std::string_view new_path);
@ -62,9 +61,9 @@ public:
virtual bool DeleteFile(std::string_view path); virtual bool DeleteFile(std::string_view path);
// Opens the directory with path relative to root. If it doesn't exist, returns nullptr. // Opens the directory with path relative to root. If it doesn't exist, returns nullptr.
virtual VirtualDir OpenDirectory(std::string_view path, Mode perms); virtual VirtualDir OpenDirectory(std::string_view path, OpenMode perms);
// Creates a new, empty directory at path // Creates a new, empty directory at path
virtual VirtualDir CreateDirectory(std::string_view path, Mode perms); virtual VirtualDir CreateDirectory(std::string_view path, OpenMode perms);
// Copies the directory from old_path to new_path, returning the new directory on success and // Copies the directory from old_path to new_path, returning the new directory on success and
// nullptr on failure. // nullptr on failure.
virtual VirtualDir CopyDirectory(std::string_view old_path, std::string_view new_path); virtual VirtualDir CopyDirectory(std::string_view old_path, std::string_view new_path);

View file

@ -28,16 +28,14 @@ namespace {
constexpr size_t MaxOpenFiles = 512; constexpr size_t MaxOpenFiles = 512;
constexpr FS::FileAccessMode ModeFlagsToFileAccessMode(Mode mode) { constexpr FS::FileAccessMode ModeFlagsToFileAccessMode(OpenMode mode) {
switch (mode) { switch (mode) {
case Mode::Read: case OpenMode::Read:
return FS::FileAccessMode::Read; return FS::FileAccessMode::Read;
case Mode::Write: case OpenMode::Write:
case Mode::ReadWrite: case OpenMode::ReadWrite:
case Mode::Append: case OpenMode::AllowAppend:
case Mode::ReadAppend: case OpenMode::All:
case Mode::WriteAppend:
case Mode::All:
return FS::FileAccessMode::ReadWrite; return FS::FileAccessMode::ReadWrite;
default: default:
return {}; return {};
@ -74,7 +72,7 @@ VfsEntryType RealVfsFilesystem::GetEntryType(std::string_view path_) const {
} }
VirtualFile RealVfsFilesystem::OpenFileFromEntry(std::string_view path_, std::optional<u64> size, VirtualFile RealVfsFilesystem::OpenFileFromEntry(std::string_view path_, std::optional<u64> size,
Mode perms) { OpenMode perms) {
const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
std::scoped_lock lk{list_lock}; std::scoped_lock lk{list_lock};
@ -98,11 +96,11 @@ VirtualFile RealVfsFilesystem::OpenFileFromEntry(std::string_view path_, std::op
return file; return file;
} }
VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, Mode perms) { VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, OpenMode perms) {
return OpenFileFromEntry(path_, {}, perms); return OpenFileFromEntry(path_, {}, perms);
} }
VirtualFile RealVfsFilesystem::CreateFile(std::string_view path_, Mode perms) { VirtualFile RealVfsFilesystem::CreateFile(std::string_view path_, OpenMode perms) {
const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
{ {
std::scoped_lock lk{list_lock}; std::scoped_lock lk{list_lock};
@ -145,7 +143,7 @@ VirtualFile RealVfsFilesystem::MoveFile(std::string_view old_path_, std::string_
if (!FS::RenameFile(old_path, new_path)) { if (!FS::RenameFile(old_path, new_path)) {
return nullptr; return nullptr;
} }
return OpenFile(new_path, Mode::ReadWrite); return OpenFile(new_path, OpenMode::ReadWrite);
} }
bool RealVfsFilesystem::DeleteFile(std::string_view path_) { bool RealVfsFilesystem::DeleteFile(std::string_view path_) {
@ -157,12 +155,12 @@ bool RealVfsFilesystem::DeleteFile(std::string_view path_) {
return FS::RemoveFile(path); return FS::RemoveFile(path);
} }
VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, Mode perms) { VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, OpenMode perms) {
const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms)); return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
} }
VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, Mode perms) { VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, OpenMode perms) {
const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault); const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
if (!FS::CreateDirs(path)) { if (!FS::CreateDirs(path)) {
return nullptr; return nullptr;
@ -184,7 +182,7 @@ VirtualDir RealVfsFilesystem::MoveDirectory(std::string_view old_path_,
if (!FS::RenameDir(old_path, new_path)) { if (!FS::RenameDir(old_path, new_path)) {
return nullptr; return nullptr;
} }
return OpenDirectory(new_path, Mode::ReadWrite); return OpenDirectory(new_path, OpenMode::ReadWrite);
} }
bool RealVfsFilesystem::DeleteDirectory(std::string_view path_) { bool RealVfsFilesystem::DeleteDirectory(std::string_view path_) {
@ -193,7 +191,7 @@ bool RealVfsFilesystem::DeleteDirectory(std::string_view path_) {
} }
std::unique_lock<std::mutex> RealVfsFilesystem::RefreshReference(const std::string& path, std::unique_lock<std::mutex> RealVfsFilesystem::RefreshReference(const std::string& path,
Mode perms, OpenMode perms,
FileReference& reference) { FileReference& reference) {
std::unique_lock lk{list_lock}; std::unique_lock lk{list_lock};
@ -266,7 +264,7 @@ void RealVfsFilesystem::RemoveReferenceFromListLocked(FileReference& reference)
} }
RealVfsFile::RealVfsFile(RealVfsFilesystem& base_, std::unique_ptr<FileReference> reference_, RealVfsFile::RealVfsFile(RealVfsFilesystem& base_, std::unique_ptr<FileReference> reference_,
const std::string& path_, Mode perms_, std::optional<u64> size_) const std::string& path_, OpenMode perms_, std::optional<u64> size_)
: base(base_), reference(std::move(reference_)), path(path_), : base(base_), reference(std::move(reference_)), path(path_),
parent_path(FS::GetParentPath(path_)), path_components(FS::SplitPathComponentsCopy(path_)), parent_path(FS::GetParentPath(path_)), path_components(FS::SplitPathComponentsCopy(path_)),
size(size_), perms(perms_) {} size(size_), perms(perms_) {}
@ -298,11 +296,11 @@ VirtualDir RealVfsFile::GetContainingDirectory() const {
} }
bool RealVfsFile::IsWritable() const { bool RealVfsFile::IsWritable() const {
return True(perms & Mode::Write); return True(perms & OpenMode::Write);
} }
bool RealVfsFile::IsReadable() const { bool RealVfsFile::IsReadable() const {
return True(perms & Mode::Read); return True(perms & OpenMode::Read);
} }
std::size_t RealVfsFile::Read(u8* data, std::size_t length, std::size_t offset) const { std::size_t RealVfsFile::Read(u8* data, std::size_t length, std::size_t offset) const {
@ -331,7 +329,7 @@ bool RealVfsFile::Rename(std::string_view name) {
template <> template <>
std::vector<VirtualFile> RealVfsDirectory::IterateEntries<RealVfsFile, VfsFile>() const { std::vector<VirtualFile> RealVfsDirectory::IterateEntries<RealVfsFile, VfsFile>() const {
if (perms == Mode::Append) { if (perms == OpenMode::AllowAppend) {
return {}; return {};
} }
@ -353,7 +351,7 @@ std::vector<VirtualFile> RealVfsDirectory::IterateEntries<RealVfsFile, VfsFile>(
template <> template <>
std::vector<VirtualDir> RealVfsDirectory::IterateEntries<RealVfsDirectory, VfsDirectory>() const { std::vector<VirtualDir> RealVfsDirectory::IterateEntries<RealVfsDirectory, VfsDirectory>() const {
if (perms == Mode::Append) { if (perms == OpenMode::AllowAppend) {
return {}; return {};
} }
@ -373,10 +371,11 @@ std::vector<VirtualDir> RealVfsDirectory::IterateEntries<RealVfsDirectory, VfsDi
return out; return out;
} }
RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string& path_, Mode perms_) RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string& path_,
OpenMode perms_)
: base(base_), path(FS::RemoveTrailingSlash(path_)), parent_path(FS::GetParentPath(path)), : base(base_), path(FS::RemoveTrailingSlash(path_)), parent_path(FS::GetParentPath(path)),
path_components(FS::SplitPathComponentsCopy(path)), perms(perms_) { path_components(FS::SplitPathComponentsCopy(path)), perms(perms_) {
if (!FS::Exists(path) && True(perms & Mode::Write)) { if (!FS::Exists(path) && True(perms & OpenMode::Write)) {
void(FS::CreateDirs(path)); void(FS::CreateDirs(path));
} }
} }
@ -456,11 +455,11 @@ std::vector<VirtualDir> RealVfsDirectory::GetSubdirectories() const {
} }
bool RealVfsDirectory::IsWritable() const { bool RealVfsDirectory::IsWritable() const {
return True(perms & Mode::Write); return True(perms & OpenMode::Write);
} }
bool RealVfsDirectory::IsReadable() const { bool RealVfsDirectory::IsReadable() const {
return True(perms & Mode::Read); return True(perms & OpenMode::Read);
} }
std::string RealVfsDirectory::GetName() const { std::string RealVfsDirectory::GetName() const {
@ -507,7 +506,7 @@ std::string RealVfsDirectory::GetFullPath() const {
} }
std::map<std::string, VfsEntryType, std::less<>> RealVfsDirectory::GetEntries() const { std::map<std::string, VfsEntryType, std::less<>> RealVfsDirectory::GetEntries() const {
if (perms == Mode::Append) { if (perms == OpenMode::AllowAppend) {
return {}; return {};
} }

View file

@ -8,7 +8,7 @@
#include <optional> #include <optional>
#include <string_view> #include <string_view>
#include "common/intrusive_list.h" #include "common/intrusive_list.h"
#include "core/file_sys/mode.h" #include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/vfs/vfs.h" #include "core/file_sys/vfs/vfs.h"
namespace Common::FS { namespace Common::FS {
@ -33,13 +33,14 @@ public:
bool IsReadable() const override; bool IsReadable() const override;
bool IsWritable() const override; bool IsWritable() const override;
VfsEntryType GetEntryType(std::string_view path) const override; VfsEntryType GetEntryType(std::string_view path) const override;
VirtualFile OpenFile(std::string_view path, Mode perms = Mode::Read) override; VirtualFile OpenFile(std::string_view path, OpenMode perms = OpenMode::Read) override;
VirtualFile CreateFile(std::string_view path, Mode perms = Mode::ReadWrite) override; VirtualFile CreateFile(std::string_view path, OpenMode perms = OpenMode::ReadWrite) override;
VirtualFile CopyFile(std::string_view old_path, std::string_view new_path) 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; VirtualFile MoveFile(std::string_view old_path, std::string_view new_path) override;
bool DeleteFile(std::string_view path) override; bool DeleteFile(std::string_view path) override;
VirtualDir OpenDirectory(std::string_view path, Mode perms = Mode::Read) override; VirtualDir OpenDirectory(std::string_view path, OpenMode perms = OpenMode::Read) override;
VirtualDir CreateDirectory(std::string_view path, Mode perms = Mode::ReadWrite) override; VirtualDir CreateDirectory(std::string_view path,
OpenMode perms = OpenMode::ReadWrite) override;
VirtualDir CopyDirectory(std::string_view old_path, std::string_view new_path) 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; VirtualDir MoveDirectory(std::string_view old_path, std::string_view new_path) override;
bool DeleteDirectory(std::string_view path) override; bool DeleteDirectory(std::string_view path) override;
@ -54,14 +55,14 @@ private:
private: private:
friend class RealVfsFile; friend class RealVfsFile;
std::unique_lock<std::mutex> RefreshReference(const std::string& path, Mode perms, std::unique_lock<std::mutex> RefreshReference(const std::string& path, OpenMode perms,
FileReference& reference); FileReference& reference);
void DropReference(std::unique_ptr<FileReference>&& reference); void DropReference(std::unique_ptr<FileReference>&& reference);
private: private:
friend class RealVfsDirectory; friend class RealVfsDirectory;
VirtualFile OpenFileFromEntry(std::string_view path, std::optional<u64> size, VirtualFile OpenFileFromEntry(std::string_view path, std::optional<u64> size,
Mode perms = Mode::Read); OpenMode perms = OpenMode::Read);
private: private:
void EvictSingleReferenceLocked(); void EvictSingleReferenceLocked();
@ -89,7 +90,8 @@ public:
private: private:
RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference, RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference,
const std::string& path, Mode perms = Mode::Read, std::optional<u64> size = {}); const std::string& path, OpenMode perms = OpenMode::Read,
std::optional<u64> size = {});
RealVfsFilesystem& base; RealVfsFilesystem& base;
std::unique_ptr<FileReference> reference; std::unique_ptr<FileReference> reference;
@ -97,7 +99,7 @@ private:
std::string parent_path; std::string parent_path;
std::vector<std::string> path_components; std::vector<std::string> path_components;
std::optional<u64> size; std::optional<u64> size;
Mode perms; OpenMode perms;
}; };
// An implementation of VfsDirectory that represents a directory on the user's computer. // An implementation of VfsDirectory that represents a directory on the user's computer.
@ -130,7 +132,8 @@ public:
std::map<std::string, VfsEntryType, std::less<>> GetEntries() const override; std::map<std::string, VfsEntryType, std::less<>> GetEntries() const override;
private: private:
RealVfsDirectory(RealVfsFilesystem& base, const std::string& path, Mode perms = Mode::Read); RealVfsDirectory(RealVfsFilesystem& base, const std::string& path,
OpenMode perms = OpenMode::Read);
template <typename T, typename R> template <typename T, typename R>
std::vector<std::shared_ptr<R>> IterateEntries() const; std::vector<std::shared_ptr<R>> IterateEntries() const;
@ -139,7 +142,7 @@ private:
std::string path; std::string path;
std::string parent_path; std::string parent_path;
std::vector<std::string> path_components; std::vector<std::string> path_components;
Mode perms; OpenMode perms;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -9,7 +9,7 @@
#include "common/string_util.h" #include "common/string_util.h"
#include "core/core.h" #include "core/core.h"
#include "core/file_sys/content_archive.h" #include "core/file_sys/content_archive.h"
#include "core/file_sys/mode.h" #include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/nca_metadata.h" #include "core/file_sys/nca_metadata.h"
#include "core/file_sys/patch_manager.h" #include "core/file_sys/patch_manager.h"
#include "core/file_sys/registered_cache.h" #include "core/file_sys/registered_cache.h"
@ -213,7 +213,7 @@ void ExtractSharedFonts(Core::System& system) {
std::move(decrypted_data), DECRYPTED_SHARED_FONTS[i]); std::move(decrypted_data), DECRYPTED_SHARED_FONTS[i]);
const auto temp_dir = system.GetFilesystem()->CreateDirectory( const auto temp_dir = system.GetFilesystem()->CreateDirectory(
Common::FS::PathToUTF8String(fonts_dir), FileSys::Mode::ReadWrite); Common::FS::PathToUTF8String(fonts_dir), FileSys::OpenMode::ReadWrite);
const auto out_file = temp_dir->CreateFile(DECRYPTED_SHARED_FONTS[i]); const auto out_file = temp_dir->CreateFile(DECRYPTED_SHARED_FONTS[i]);
@ -333,7 +333,7 @@ void WebBrowser::ExtractOfflineRomFS() {
const auto extracted_romfs_dir = FileSys::ExtractRomFS(offline_romfs); const auto extracted_romfs_dir = FileSys::ExtractRomFS(offline_romfs);
const auto temp_dir = system.GetFilesystem()->CreateDirectory( const auto temp_dir = system.GetFilesystem()->CreateDirectory(
Common::FS::PathToUTF8String(offline_cache_dir), FileSys::Mode::ReadWrite); Common::FS::PathToUTF8String(offline_cache_dir), FileSys::OpenMode::ReadWrite);
FileSys::VfsRawCopyD(extracted_romfs_dir, temp_dir); FileSys::VfsRawCopyD(extracted_romfs_dir, temp_dir);
} }

View file

@ -12,7 +12,6 @@
#include "core/file_sys/card_image.h" #include "core/file_sys/card_image.h"
#include "core/file_sys/control_metadata.h" #include "core/file_sys/control_metadata.h"
#include "core/file_sys/errors.h" #include "core/file_sys/errors.h"
#include "core/file_sys/mode.h"
#include "core/file_sys/patch_manager.h" #include "core/file_sys/patch_manager.h"
#include "core/file_sys/registered_cache.h" #include "core/file_sys/registered_cache.h"
#include "core/file_sys/romfs_factory.h" #include "core/file_sys/romfs_factory.h"
@ -56,7 +55,7 @@ Result VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size
return FileSys::ERROR_PATH_NOT_FOUND; return FileSys::ERROR_PATH_NOT_FOUND;
} }
FileSys::EntryType entry_type{}; FileSys::DirectoryEntryType entry_type{};
if (GetEntryType(&entry_type, path) == ResultSuccess) { if (GetEntryType(&entry_type, path) == ResultSuccess) {
return FileSys::ERROR_PATH_ALREADY_EXISTS; return FileSys::ERROR_PATH_ALREADY_EXISTS;
} }
@ -214,7 +213,8 @@ Result VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path_,
} }
Result VfsDirectoryServiceWrapper::OpenFile(FileSys::VirtualFile* out_file, Result VfsDirectoryServiceWrapper::OpenFile(FileSys::VirtualFile* out_file,
const std::string& path_, FileSys::Mode mode) const { const std::string& path_,
FileSys::OpenMode mode) const {
const std::string path(Common::FS::SanitizePath(path_)); const std::string path(Common::FS::SanitizePath(path_));
std::string_view npath = path; std::string_view npath = path;
while (!npath.empty() && (npath[0] == '/' || npath[0] == '\\')) { while (!npath.empty() && (npath[0] == '/' || npath[0] == '\\')) {
@ -226,7 +226,7 @@ Result VfsDirectoryServiceWrapper::OpenFile(FileSys::VirtualFile* out_file,
return FileSys::ERROR_PATH_NOT_FOUND; return FileSys::ERROR_PATH_NOT_FOUND;
} }
if (mode == FileSys::Mode::Append) { if (mode == FileSys::OpenMode::AllowAppend) {
*out_file = std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize()); *out_file = std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize());
} else { } else {
*out_file = file; *out_file = file;
@ -247,7 +247,7 @@ Result VfsDirectoryServiceWrapper::OpenDirectory(FileSys::VirtualDir* out_direct
return ResultSuccess; return ResultSuccess;
} }
Result VfsDirectoryServiceWrapper::GetEntryType(FileSys::EntryType* out_entry_type, Result VfsDirectoryServiceWrapper::GetEntryType(FileSys::DirectoryEntryType* out_entry_type,
const std::string& path_) const { const std::string& path_) const {
std::string path(Common::FS::SanitizePath(path_)); std::string path(Common::FS::SanitizePath(path_));
auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path)); auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
@ -258,17 +258,17 @@ Result VfsDirectoryServiceWrapper::GetEntryType(FileSys::EntryType* out_entry_ty
auto filename = Common::FS::GetFilename(path); auto filename = Common::FS::GetFilename(path);
// TODO(Subv): Some games use the '/' path, find out what this means. // TODO(Subv): Some games use the '/' path, find out what this means.
if (filename.empty()) { if (filename.empty()) {
*out_entry_type = FileSys::EntryType::Directory; *out_entry_type = FileSys::DirectoryEntryType::Directory;
return ResultSuccess; return ResultSuccess;
} }
if (dir->GetFile(filename) != nullptr) { if (dir->GetFile(filename) != nullptr) {
*out_entry_type = FileSys::EntryType::File; *out_entry_type = FileSys::DirectoryEntryType::File;
return ResultSuccess; return ResultSuccess;
} }
if (dir->GetSubdirectory(filename) != nullptr) { if (dir->GetSubdirectory(filename) != nullptr) {
*out_entry_type = FileSys::EntryType::Directory; *out_entry_type = FileSys::DirectoryEntryType::Directory;
return ResultSuccess; return ResultSuccess;
} }
@ -282,7 +282,7 @@ Result VfsDirectoryServiceWrapper::GetFileTimeStampRaw(
return FileSys::ERROR_PATH_NOT_FOUND; return FileSys::ERROR_PATH_NOT_FOUND;
} }
FileSys::EntryType entry_type; FileSys::DirectoryEntryType entry_type;
if (GetEntryType(&entry_type, path) != ResultSuccess) { if (GetEntryType(&entry_type, path) != ResultSuccess) {
return FileSys::ERROR_PATH_NOT_FOUND; return FileSys::ERROR_PATH_NOT_FOUND;
} }
@ -347,7 +347,7 @@ std::shared_ptr<SaveDataController> FileSystemController::OpenSaveDataController
std::shared_ptr<FileSys::SaveDataFactory> FileSystemController::CreateSaveDataFactory( std::shared_ptr<FileSys::SaveDataFactory> FileSystemController::CreateSaveDataFactory(
ProgramId program_id) { ProgramId program_id) {
using YuzuPath = Common::FS::YuzuPath; using YuzuPath = Common::FS::YuzuPath;
const auto rw_mode = FileSys::Mode::ReadWrite; const auto rw_mode = FileSys::OpenMode::ReadWrite;
auto vfs = system.GetFilesystem(); auto vfs = system.GetFilesystem();
const auto nand_directory = const auto nand_directory =
@ -686,15 +686,15 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
using YuzuPath = Common::FS::YuzuPath; using YuzuPath = Common::FS::YuzuPath;
const auto sdmc_dir_path = Common::FS::GetYuzuPath(YuzuPath::SDMCDir); const auto sdmc_dir_path = Common::FS::GetYuzuPath(YuzuPath::SDMCDir);
const auto sdmc_load_dir_path = sdmc_dir_path / "atmosphere/contents"; const auto sdmc_load_dir_path = sdmc_dir_path / "atmosphere/contents";
const auto rw_mode = FileSys::Mode::ReadWrite; const auto rw_mode = FileSys::OpenMode::ReadWrite;
auto nand_directory = auto nand_directory =
vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::NANDDir), rw_mode); vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::NANDDir), rw_mode);
auto sd_directory = vfs.OpenDirectory(Common::FS::PathToUTF8String(sdmc_dir_path), rw_mode); auto sd_directory = vfs.OpenDirectory(Common::FS::PathToUTF8String(sdmc_dir_path), rw_mode);
auto load_directory = auto load_directory = vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::LoadDir),
vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::LoadDir), FileSys::Mode::Read); FileSys::OpenMode::Read);
auto sd_load_directory = auto sd_load_directory = vfs.OpenDirectory(Common::FS::PathToUTF8String(sdmc_load_dir_path),
vfs.OpenDirectory(Common::FS::PathToUTF8String(sdmc_load_dir_path), FileSys::Mode::Read); FileSys::OpenMode::Read);
auto dump_directory = auto dump_directory =
vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::DumpDir), rw_mode); vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::DumpDir), rw_mode);

View file

@ -5,7 +5,8 @@
#include <memory> #include <memory>
#include "common/common_types.h" #include "common/common_types.h"
#include "core/file_sys/directory.h" #include "core/file_sys/fs_directory.h"
#include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/vfs/vfs.h" #include "core/file_sys/vfs/vfs.h"
#include "core/hle/result.h" #include "core/hle/result.h"
@ -26,7 +27,6 @@ class XCI;
enum class BisPartitionId : u32; enum class BisPartitionId : u32;
enum class ContentRecordType : u8; enum class ContentRecordType : u8;
enum class Mode : u32;
enum class SaveDataSpaceId : u8; enum class SaveDataSpaceId : u8;
enum class SaveDataType : u8; enum class SaveDataType : u8;
enum class StorageId : u8; enum class StorageId : u8;
@ -57,13 +57,6 @@ enum class ImageDirectoryId : u32 {
SdCard, SdCard,
}; };
enum class OpenDirectoryMode : u64 {
Directory = (1 << 0),
File = (1 << 1),
All = Directory | File
};
DECLARE_ENUM_FLAG_OPERATORS(OpenDirectoryMode);
using ProcessId = u64; using ProcessId = u64;
using ProgramId = u64; using ProgramId = u64;
@ -237,7 +230,7 @@ public:
* @return Opened file, or error code * @return Opened file, or error code
*/ */
Result OpenFile(FileSys::VirtualFile* out_file, const std::string& path, Result OpenFile(FileSys::VirtualFile* out_file, const std::string& path,
FileSys::Mode mode) const; FileSys::OpenMode mode) const;
/** /**
* Open a directory specified by its path * Open a directory specified by its path
@ -250,7 +243,7 @@ public:
* Get the type of the specified path * Get the type of the specified path
* @return The type of the specified path or error code * @return The type of the specified path or error code
*/ */
Result GetEntryType(FileSys::EntryType* out_entry_type, const std::string& path) const; Result GetEntryType(FileSys::DirectoryEntryType* out_entry_type, const std::string& path) const;
/** /**
* Get the timestamp of the specified path * Get the timestamp of the specified path

View file

@ -8,23 +8,26 @@
namespace Service::FileSystem { namespace Service::FileSystem {
template <typename T> template <typename T>
static void BuildEntryIndex(std::vector<FileSys::Entry>& entries, const std::vector<T>& new_data, static void BuildEntryIndex(std::vector<FileSys::DirectoryEntry>& entries,
FileSys::EntryType type) { const std::vector<T>& new_data, FileSys::DirectoryEntryType type) {
entries.reserve(entries.size() + new_data.size()); entries.reserve(entries.size() + new_data.size());
for (const auto& new_entry : new_data) { for (const auto& new_entry : new_data) {
auto name = new_entry->GetName(); auto name = new_entry->GetName();
if (type == FileSys::EntryType::File && name == FileSys::GetSaveDataSizeFileName()) { if (type == FileSys::DirectoryEntryType::File &&
name == FileSys::GetSaveDataSizeFileName()) {
continue; continue;
} }
entries.emplace_back(name, type, entries.emplace_back(name, static_cast<s8>(type),
type == FileSys::EntryType::Directory ? 0 : new_entry->GetSize()); type == FileSys::DirectoryEntryType::Directory ? 0
: new_entry->GetSize());
} }
} }
IDirectory::IDirectory(Core::System& system_, FileSys::VirtualDir backend_, OpenDirectoryMode mode) IDirectory::IDirectory(Core::System& system_, FileSys::VirtualDir backend_,
FileSys::OpenDirectoryMode mode)
: ServiceFramework{system_, "IDirectory"}, backend(std::move(backend_)) { : ServiceFramework{system_, "IDirectory"}, backend(std::move(backend_)) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &IDirectory::Read, "Read"}, {0, &IDirectory::Read, "Read"},
@ -34,11 +37,12 @@ IDirectory::IDirectory(Core::System& system_, FileSys::VirtualDir backend_, Open
// TODO(DarkLordZach): Verify that this is the correct behavior. // TODO(DarkLordZach): Verify that this is the correct behavior.
// Build entry index now to save time later. // Build entry index now to save time later.
if (True(mode & OpenDirectoryMode::Directory)) { if (True(mode & FileSys::OpenDirectoryMode::Directory)) {
BuildEntryIndex(entries, backend->GetSubdirectories(), FileSys::EntryType::Directory); BuildEntryIndex(entries, backend->GetSubdirectories(),
FileSys::DirectoryEntryType::Directory);
} }
if (True(mode & OpenDirectoryMode::File)) { if (True(mode & FileSys::OpenDirectoryMode::File)) {
BuildEntryIndex(entries, backend->GetFiles(), FileSys::EntryType::File); BuildEntryIndex(entries, backend->GetFiles(), FileSys::DirectoryEntryType::File);
} }
} }
@ -46,7 +50,7 @@ void IDirectory::Read(HLERequestContext& ctx) {
LOG_DEBUG(Service_FS, "called."); LOG_DEBUG(Service_FS, "called.");
// Calculate how many entries we can fit in the output buffer // Calculate how many entries we can fit in the output buffer
const u64 count_entries = ctx.GetWriteBufferNumElements<FileSys::Entry>(); const u64 count_entries = ctx.GetWriteBufferNumElements<FileSys::DirectoryEntry>();
// Cap at total number of entries. // Cap at total number of entries.
const u64 actual_entries = std::min(count_entries, entries.size() - next_entry_index); const u64 actual_entries = std::min(count_entries, entries.size() - next_entry_index);

View file

@ -3,9 +3,10 @@
#pragma once #pragma once
#include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/vfs/vfs.h" #include "core/file_sys/vfs/vfs.h"
#include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/filesystem/filesystem.h"
#include "core/hle/service/filesystem/fsp_util.h" #include "core/hle/service/filesystem/fsp/fsp_util.h"
#include "core/hle/service/service.h" #include "core/hle/service/service.h"
namespace Service::FileSystem { namespace Service::FileSystem {
@ -13,11 +14,11 @@ namespace Service::FileSystem {
class IDirectory final : public ServiceFramework<IDirectory> { class IDirectory final : public ServiceFramework<IDirectory> {
public: public:
explicit IDirectory(Core::System& system_, FileSys::VirtualDir backend_, explicit IDirectory(Core::System& system_, FileSys::VirtualDir backend_,
OpenDirectoryMode mode); FileSys::OpenDirectoryMode mode);
private: private:
FileSys::VirtualDir backend; FileSys::VirtualDir backend;
std::vector<FileSys::Entry> entries; std::vector<FileSys::DirectoryEntry> entries;
u64 next_entry_index = 0; u64 next_entry_index = 0;
void Read(HLERequestContext& ctx); void Read(HLERequestContext& ctx);

View file

@ -3,7 +3,6 @@
#pragma once #pragma once
#include "core/file_sys/vfs.h"
#include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/filesystem/filesystem.h"
#include "core/hle/service/service.h" #include "core/hle/service/service.h"

View file

@ -10,8 +10,8 @@
namespace Service::FileSystem { namespace Service::FileSystem {
IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir backend_, SizeGetter size_) IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir backend_, SizeGetter size_)
: ServiceFramework{system_, "IFileSystem"}, backend{std::move(backend_)}, : ServiceFramework{system_, "IFileSystem"}, backend{std::move(backend_)}, size{std::move(
size{std::move(size_)} { size_)} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &IFileSystem::CreateFile, "CreateFile"}, {0, &IFileSystem::CreateFile, "CreateFile"},
{1, &IFileSystem::DeleteFile, "DeleteFile"}, {1, &IFileSystem::DeleteFile, "DeleteFile"},
@ -116,7 +116,7 @@ void IFileSystem::OpenFile(HLERequestContext& ctx) {
const auto file_buffer = ctx.ReadBuffer(); const auto file_buffer = ctx.ReadBuffer();
const std::string name = Common::StringFromBuffer(file_buffer); const std::string name = Common::StringFromBuffer(file_buffer);
const auto mode = static_cast<FileSys::Mode>(rp.Pop<u32>()); const auto mode = static_cast<FileSys::OpenMode>(rp.Pop<u32>());
LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode); LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode);
@ -140,7 +140,7 @@ void IFileSystem::OpenDirectory(HLERequestContext& ctx) {
const auto file_buffer = ctx.ReadBuffer(); const auto file_buffer = ctx.ReadBuffer();
const std::string name = Common::StringFromBuffer(file_buffer); const std::string name = Common::StringFromBuffer(file_buffer);
const auto mode = rp.PopRaw<OpenDirectoryMode>(); const auto mode = rp.PopRaw<FileSys::OpenDirectoryMode>();
LOG_DEBUG(Service_FS, "called. directory={}, mode={}", name, mode); LOG_DEBUG(Service_FS, "called. directory={}, mode={}", name, mode);
@ -165,7 +165,7 @@ void IFileSystem::GetEntryType(HLERequestContext& ctx) {
LOG_DEBUG(Service_FS, "called. file={}", name); LOG_DEBUG(Service_FS, "called. file={}", name);
FileSys::EntryType vfs_entry_type{}; FileSys::DirectoryEntryType vfs_entry_type{};
auto result = backend.GetEntryType(&vfs_entry_type, name); auto result = backend.GetEntryType(&vfs_entry_type, name);
if (result != ResultSuccess) { if (result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};

View file

@ -15,9 +15,9 @@
#include "common/settings.h" #include "common/settings.h"
#include "common/string_util.h" #include "common/string_util.h"
#include "core/core.h" #include "core/core.h"
#include "core/file_sys/directory.h"
#include "core/file_sys/errors.h" #include "core/file_sys/errors.h"
#include "core/file_sys/mode.h" #include "core/file_sys/fs_directory.h"
#include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/nca_metadata.h" #include "core/file_sys/nca_metadata.h"
#include "core/file_sys/patch_manager.h" #include "core/file_sys/patch_manager.h"
#include "core/file_sys/romfs_factory.h" #include "core/file_sys/romfs_factory.h"
@ -52,8 +52,8 @@ public:
explicit ISaveDataInfoReader(Core::System& system_, explicit ISaveDataInfoReader(Core::System& system_,
std::shared_ptr<SaveDataController> save_data_controller_, std::shared_ptr<SaveDataController> save_data_controller_,
FileSys::SaveDataSpaceId space) FileSys::SaveDataSpaceId space)
: ServiceFramework{system_, "ISaveDataInfoReader"}, : ServiceFramework{system_, "ISaveDataInfoReader"}, save_data_controller{
save_data_controller{save_data_controller_} { save_data_controller_} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &ISaveDataInfoReader::ReadSaveDataInfo, "ReadSaveDataInfo"}, {0, &ISaveDataInfoReader::ReadSaveDataInfo, "ReadSaveDataInfo"},
}; };

View file

@ -9,7 +9,7 @@
#include "core/core.h" #include "core/core.h"
#include "core/file_sys/common_funcs.h" #include "core/file_sys/common_funcs.h"
#include "core/file_sys/content_archive.h" #include "core/file_sys/content_archive.h"
#include "core/file_sys/mode.h" #include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/nca_metadata.h" #include "core/file_sys/nca_metadata.h"
#include "core/file_sys/patch_manager.h" #include "core/file_sys/patch_manager.h"
#include "core/file_sys/registered_cache.h" #include "core/file_sys/registered_cache.h"

View file

@ -17,7 +17,7 @@
#include "core/file_sys/card_image.h" #include "core/file_sys/card_image.h"
#include "core/file_sys/content_archive.h" #include "core/file_sys/content_archive.h"
#include "core/file_sys/control_metadata.h" #include "core/file_sys/control_metadata.h"
#include "core/file_sys/mode.h" #include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/nca_metadata.h" #include "core/file_sys/nca_metadata.h"
#include "core/file_sys/patch_manager.h" #include "core/file_sys/patch_manager.h"
#include "core/file_sys/registered_cache.h" #include "core/file_sys/registered_cache.h"
@ -347,7 +347,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
if (!is_dir && if (!is_dir &&
(HasSupportedFileExtension(physical_name) || IsExtractedNCAMain(physical_name))) { (HasSupportedFileExtension(physical_name) || IsExtractedNCAMain(physical_name))) {
const auto file = vfs->OpenFile(physical_name, FileSys::Mode::Read); const auto file = vfs->OpenFile(physical_name, FileSys::OpenMode::Read);
if (!file) { if (!file) {
return true; return true;
} }

View file

@ -56,7 +56,7 @@
// These are wrappers to avoid the calls to CreateDirectory and CreateFile because of the Windows // These are wrappers to avoid the calls to CreateDirectory and CreateFile because of the Windows
// defines. // defines.
static FileSys::VirtualDir VfsFilesystemCreateDirectoryWrapper( static FileSys::VirtualDir VfsFilesystemCreateDirectoryWrapper(
const FileSys::VirtualFilesystem& vfs, const std::string& path, FileSys::Mode mode) { const FileSys::VirtualFilesystem& vfs, const std::string& path, FileSys::OpenMode mode) {
return vfs->CreateDirectory(path, mode); return vfs->CreateDirectory(path, mode);
} }
@ -1880,7 +1880,7 @@ bool GMainWindow::SelectAndSetCurrentUser(
void GMainWindow::ConfigureFilesystemProvider(const std::string& filepath) { void GMainWindow::ConfigureFilesystemProvider(const std::string& filepath) {
// Ensure all NCAs are registered before launching the game // Ensure all NCAs are registered before launching the game
const auto file = vfs->OpenFile(filepath, FileSys::Mode::Read); const auto file = vfs->OpenFile(filepath, FileSys::OpenMode::Read);
if (!file) { if (!file) {
return; return;
} }
@ -2274,7 +2274,7 @@ void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target
open_target = tr("Save Data"); open_target = tr("Save Data");
const auto nand_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir); const auto nand_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir);
auto vfs_nand_dir = auto vfs_nand_dir =
vfs->OpenDirectory(Common::FS::PathToUTF8String(nand_dir), FileSys::Mode::Read); vfs->OpenDirectory(Common::FS::PathToUTF8String(nand_dir), FileSys::OpenMode::Read);
if (has_user_save) { if (has_user_save) {
// User save data // User save data
@ -2653,7 +2653,7 @@ void GMainWindow::RemoveCustomConfiguration(u64 program_id, const std::string& g
void GMainWindow::RemoveCacheStorage(u64 program_id) { void GMainWindow::RemoveCacheStorage(u64 program_id) {
const auto nand_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir); const auto nand_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir);
auto vfs_nand_dir = auto vfs_nand_dir =
vfs->OpenDirectory(Common::FS::PathToUTF8String(nand_dir), FileSys::Mode::Read); vfs->OpenDirectory(Common::FS::PathToUTF8String(nand_dir), FileSys::OpenMode::Read);
const auto cache_storage_path = FileSys::SaveDataFactory::GetFullPath( const auto cache_storage_path = FileSys::SaveDataFactory::GetFullPath(
{}, vfs_nand_dir, FileSys::SaveDataSpaceId::NandUser, FileSys::SaveDataType::CacheStorage, {}, vfs_nand_dir, FileSys::SaveDataSpaceId::NandUser, FileSys::SaveDataType::CacheStorage,
@ -2673,7 +2673,8 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
"cancelled the operation.")); "cancelled the operation."));
}; };
const auto loader = Loader::GetLoader(*system, vfs->OpenFile(game_path, FileSys::Mode::Read)); const auto loader =
Loader::GetLoader(*system, vfs->OpenFile(game_path, FileSys::OpenMode::Read));
if (loader == nullptr) { if (loader == nullptr) {
failed(); failed();
return; return;
@ -2717,7 +2718,7 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
const FileSys::PatchManager pm{title_id, system->GetFileSystemController(), installed}; const FileSys::PatchManager pm{title_id, system->GetFileSystemController(), installed};
auto romfs = pm.PatchRomFS(base_nca.get(), base_romfs, type, packed_update_raw, false); auto romfs = pm.PatchRomFS(base_nca.get(), base_romfs, type, packed_update_raw, false);
const auto out = VfsFilesystemCreateDirectoryWrapper(vfs, path, FileSys::Mode::ReadWrite); const auto out = VfsFilesystemCreateDirectoryWrapper(vfs, path, FileSys::OpenMode::ReadWrite);
if (out == nullptr) { if (out == nullptr) {
failed(); failed();
@ -3015,7 +3016,7 @@ void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& ga
system->GetContentProvider()}; system->GetContentProvider()};
const auto control = pm.GetControlMetadata(); const auto control = pm.GetControlMetadata();
const auto loader = const auto loader =
Loader::GetLoader(*system, vfs->OpenFile(game_path, FileSys::Mode::Read)); Loader::GetLoader(*system, vfs->OpenFile(game_path, FileSys::OpenMode::Read));
game_title = fmt::format("{:016X}", program_id); game_title = fmt::format("{:016X}", program_id);
if (control.first != nullptr) { if (control.first != nullptr) {
game_title = control.first->GetApplicationName(); game_title = control.first->GetApplicationName();