yuzu-emu
/
yuzu-mainline
Archived
1
0
Fork 0
Code

fs: Refactor to use cmif serialization

This commit is contained in:
FearlessTobi 2024-02-10 20:58:43 +01:00
parent d5e4617ab5
commit 934e420e36
7 changed files with 240 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/core/file_sys/fssrv/fssrv_sf_path.h Normal file
View File

@ -0,0 +1,36 @@
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "core/file_sys/fs_directory.h"
namespace FileSys::Sf {
struct Path {
char str[EntryNameLengthMax + 1];
static constexpr Path Encode(const char* p) {
Path path = {};
for (size_t i = 0; i < sizeof(path) - 1; i++) {
path.str[i] = p[i];
if (p[i] == '\x00') {
break;
}
}
return path;
}
static constexpr size_t GetPathLength(const Path& path) {
size_t len = 0;
for (size_t i = 0; i < sizeof(path) - 1 && path.str[i] != '\x00'; i++) {
len++;
}
return len;
}
};
static_assert(std::is_trivially_copyable_v<Path>, "Path must be trivially copyable.");
using FspPath = Path;
} // namespace FileSys::Sf

32
src/core/hle/service/filesystem/fsp/fs_i_directory.cpp
View File

@ -3,8 +3,8 @@
#include "core/file_sys/fs_filesystem.h" #include "core/file_sys/fs_filesystem.h"
#include "core/file_sys/savedata_factory.h" #include "core/file_sys/savedata_factory.h"
#include "core/hle/service/cmif_serialization.h"
#include "core/hle/service/filesystem/fsp/fs_i_directory.h" #include "core/hle/service/filesystem/fsp/fs_i_directory.h"
#include "core/hle/service/ipc_helpers.h"
namespace Service::FileSystem { namespace Service::FileSystem {
@ -13,38 +13,24 @@ IDirectory::IDirectory(Core::System& system_, FileSys::VirtualDir directory_,
: ServiceFramework{system_, "IDirectory"}, : ServiceFramework{system_, "IDirectory"},
backend(std::make_unique<FileSys::Fsa::IDirectory>(directory_, mode)) { backend(std::make_unique<FileSys::Fsa::IDirectory>(directory_, mode)) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &IDirectory::Read, "Read"}, {0, D<&IDirectory::Read>, "Read"},
{1, &IDirectory::GetEntryCount, "GetEntryCount"}, {1, D<&IDirectory::GetEntryCount>, "GetEntryCount"},
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }
void IDirectory::Read(HLERequestContext& ctx) { Result IDirectory::Read(
Out<s64> out_count,
const OutArray<FileSys::DirectoryEntry, BufferAttr_HipcMapAlias> out_entries) {
LOG_DEBUG(Service_FS, "called."); LOG_DEBUG(Service_FS, "called.");
// Calculate how many entries we can fit in the output buffer R_RETURN(backend->Read(out_count, out_entries.data(), out_entries.size()));
const u64 count_entries = ctx.GetWriteBufferNumElements<FileSys::DirectoryEntry>();
s64 out_count{};
FileSys::DirectoryEntry* out_entries = nullptr;
const auto result = backend->Read(&out_count, out_entries, count_entries);
// Write the data to memory
ctx.WriteBuffer(out_entries, out_count);
IPC::ResponseBuilder rb{ctx, 4};
rb.Push(result);
rb.Push(out_count);
} }
void IDirectory::GetEntryCount(HLERequestContext& ctx) { Result IDirectory::GetEntryCount(Out<s64> out_count) {
LOG_DEBUG(Service_FS, "called"); LOG_DEBUG(Service_FS, "called");
s64 out_count{}; R_RETURN(backend->GetEntryCount(out_count));
IPC::ResponseBuilder rb{ctx, 4};
rb.Push(backend->GetEntryCount(&out_count));
rb.Push(out_count);
} }
} // namespace Service::FileSystem } // namespace Service::FileSystem

6
src/core/hle/service/filesystem/fsp/fs_i_directory.h
View File

@ -5,6 +5,7 @@
#include "core/file_sys/fsa/fs_i_directory.h" #include "core/file_sys/fsa/fs_i_directory.h"
#include "core/file_sys/vfs/vfs.h" #include "core/file_sys/vfs/vfs.h"
#include "core/hle/service/cmif_types.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"
@ -22,8 +23,9 @@ public:
private: private:
std::unique_ptr<FileSys::Fsa::IDirectory> backend; std::unique_ptr<FileSys::Fsa::IDirectory> backend;
void Read(HLERequestContext& ctx); Result Read(Out<s64> out_count,
void GetEntryCount(HLERequestContext& ctx); const OutArray<FileSys::DirectoryEntry, BufferAttr_HipcMapAlias> out_entries);
Result GetEntryCount(Out<s64> out_count);
}; };
} // namespace Service::FileSystem } // namespace Service::FileSystem

78
src/core/hle/service/filesystem/fsp/fs_i_file.cpp
View File

@ -2,86 +2,64 @@
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include "core/file_sys/errors.h" #include "core/file_sys/errors.h"
#include "core/hle/service/cmif_serialization.h"
#include "core/hle/service/filesystem/fsp/fs_i_file.h" #include "core/hle/service/filesystem/fsp/fs_i_file.h"
#include "core/hle/service/ipc_helpers.h"
namespace Service::FileSystem { namespace Service::FileSystem {
IFile::IFile(Core::System& system_, FileSys::VirtualFile file_) IFile::IFile(Core::System& system_, FileSys::VirtualFile file_)
: ServiceFramework{system_, "IFile"}, backend{std::make_unique<FileSys::Fsa::IFile>(file_)} { : ServiceFramework{system_, "IFile"}, backend{std::make_unique<FileSys::Fsa::IFile>(file_)} {
// clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &IFile::Read, "Read"}, {0, D<&IFile::Read>, "Read"},
{1, &IFile::Write, "Write"}, {1, D<&IFile::Write>, "Write"},
{2, &IFile::Flush, "Flush"}, {2, D<&IFile::Flush>, "Flush"},
{3, &IFile::SetSize, "SetSize"}, {3, D<&IFile::SetSize>, "SetSize"},
{4, &IFile::GetSize, "GetSize"}, {4, D<&IFile::GetSize>, "GetSize"},
{5, nullptr, "OperateRange"}, {5, nullptr, "OperateRange"},
{6, nullptr, "OperateRangeWithBuffer"}, {6, nullptr, "OperateRangeWithBuffer"},
}; };
// clang-format on
RegisterHandlers(functions); RegisterHandlers(functions);
} }
void IFile::Read(HLERequestContext& ctx) { Result IFile::Read(
IPC::RequestParser rp{ctx}; FileSys::ReadOption option, Out<s64> out_size, s64 offset,
const u64 option = rp.Pop<u64>(); const OutBuffer<BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_buffer,
const s64 offset = rp.Pop<s64>(); s64 size) {
const s64 length = rp.Pop<s64>(); LOG_DEBUG(Service_FS, "called, option={}, offset=0x{:X}, length={}", option.value, offset,
size);
LOG_DEBUG(Service_FS, "called, option={}, offset=0x{:X}, length={}", option, offset, length);
// Read the data from the Storage backend // Read the data from the Storage backend
std::vector<u8> output(length); R_RETURN(
std::size_t bytes_read; backend->Read(reinterpret_cast<size_t*>(out_size.Get()), offset, out_buffer.data(), size));
const auto result = backend->Read(&bytes_read, offset, output.data(), length);
// Write the data to memory
ctx.WriteBuffer(output);
IPC::ResponseBuilder rb{ctx, 4};
rb.Push(result);
rb.Push(static_cast<u64>(bytes_read));
} }
void IFile::Write(HLERequestContext& ctx) { Result IFile::Write(
IPC::RequestParser rp{ctx}; const InBuffer<BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> buffer,
const auto option = rp.PopRaw<FileSys::WriteOption>(); FileSys::WriteOption option, s64 offset, s64 size) {
[[maybe_unused]] const u32 unused = rp.Pop<u32>();
const s64 offset = rp.Pop<s64>();
const s64 length = rp.Pop<s64>();
LOG_DEBUG(Service_FS, "called, option={}, offset=0x{:X}, length={}", option.value, offset, LOG_DEBUG(Service_FS, "called, option={}, offset=0x{:X}, length={}", option.value, offset,
length); size);
const auto data = ctx.ReadBuffer(); R_RETURN(backend->Write(offset, buffer.data(), size, option));
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(backend->Write(offset, data.data(), length, option));
} }
void IFile::Flush(HLERequestContext& ctx) { Result IFile::Flush() {
LOG_DEBUG(Service_FS, "called"); LOG_DEBUG(Service_FS, "called");
IPC::ResponseBuilder rb{ctx, 2}; R_RETURN(backend->Flush());
rb.Push(backend->Flush());
} }
void IFile::SetSize(HLERequestContext& ctx) { Result IFile::SetSize(s64 size) {
IPC::RequestParser rp{ctx};
const u64 size = rp.Pop<u64>();
LOG_DEBUG(Service_FS, "called, size={}", size); LOG_DEBUG(Service_FS, "called, size={}", size);
IPC::ResponseBuilder rb{ctx, 2}; R_RETURN(backend->SetSize(size));
rb.Push(backend->SetSize(size));
} }
void IFile::GetSize(HLERequestContext& ctx) { Result IFile::GetSize(Out<s64> out_size) {
s64 size; LOG_DEBUG(Service_FS, "called");
const auto result = backend->GetSize(&size);
LOG_DEBUG(Service_FS, "called, size={}", size);
IPC::ResponseBuilder rb{ctx, 4}; R_RETURN(backend->GetSize(out_size));
rb.Push(result);
rb.Push<u64>(size);
} }
} // namespace Service::FileSystem } // namespace Service::FileSystem

16
src/core/hle/service/filesystem/fsp/fs_i_file.h
View File

@ -4,6 +4,7 @@
#pragma once #pragma once
#include "core/file_sys/fsa/fs_i_file.h" #include "core/file_sys/fsa/fs_i_file.h"
#include "core/hle/service/cmif_types.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"
@ -16,11 +17,16 @@ public:
private: private:
std::unique_ptr<FileSys::Fsa::IFile> backend; std::unique_ptr<FileSys::Fsa::IFile> backend;
void Read(HLERequestContext& ctx); Result Read(FileSys::ReadOption option, Out<s64> out_size, s64 offset,
void Write(HLERequestContext& ctx); const OutBuffer<BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure>
void Flush(HLERequestContext& ctx); out_buffer,
void SetSize(HLERequestContext& ctx); s64 size);
void GetSize(HLERequestContext& ctx); Result Write(
const InBuffer<BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> buffer,
FileSys::WriteOption option, s64 offset, s64 size);
Result Flush();
Result SetSize(s64 size);
Result GetSize(Out<s64> out_size);
}; };
} // namespace Service::FileSystem } // namespace Service::FileSystem

292
src/core/hle/service/filesystem/fsp/fs_i_filesystem.cpp
View File

@ -2,274 +2,172 @@
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include "common/string_util.h" #include "common/string_util.h"
#include "core/file_sys/fssrv/fssrv_sf_path.h"
#include "core/hle/service/cmif_serialization.h"
#include "core/hle/service/filesystem/fsp/fs_i_directory.h" #include "core/hle/service/filesystem/fsp/fs_i_directory.h"
#include "core/hle/service/filesystem/fsp/fs_i_file.h" #include "core/hle/service/filesystem/fsp/fs_i_file.h"
#include "core/hle/service/filesystem/fsp/fs_i_filesystem.h" #include "core/hle/service/filesystem/fsp/fs_i_filesystem.h"
#include "core/hle/service/ipc_helpers.h"
namespace Service::FileSystem { namespace Service::FileSystem {
IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGetter size_) IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGetter size_getter_)
: ServiceFramework{system_, "IFileSystem"}, : ServiceFramework{system_, "IFileSystem"},
backend{std::make_unique<FileSys::Fsa::IFileSystem>(dir_)}, size{std::move(size_)} { backend{std::make_unique<FileSys::Fsa::IFileSystem>(dir_)},
size_getter{std::move(size_getter_)} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &IFileSystem::CreateFile, "CreateFile"}, {0, D<&IFileSystem::CreateFile>, "CreateFile"},
{1, &IFileSystem::DeleteFile, "DeleteFile"}, {1, D<&IFileSystem::DeleteFile>, "DeleteFile"},
{2, &IFileSystem::CreateDirectory, "CreateDirectory"}, {2, D<&IFileSystem::CreateDirectory>, "CreateDirectory"},
{3, &IFileSystem::DeleteDirectory, "DeleteDirectory"}, {3, D<&IFileSystem::DeleteDirectory>, "DeleteDirectory"},
{4, &IFileSystem::DeleteDirectoryRecursively, "DeleteDirectoryRecursively"}, {4, D<&IFileSystem::DeleteDirectoryRecursively>, "DeleteDirectoryRecursively"},
{5, &IFileSystem::RenameFile, "RenameFile"}, {5, D<&IFileSystem::RenameFile>, "RenameFile"},
{6, nullptr, "RenameDirectory"}, {6, nullptr, "RenameDirectory"},
{7, &IFileSystem::GetEntryType, "GetEntryType"}, {7, D<&IFileSystem::GetEntryType>, "GetEntryType"},
{8, &IFileSystem::OpenFile, "OpenFile"}, {8, D<&IFileSystem::OpenFile>, "OpenFile"},
{9, &IFileSystem::OpenDirectory, "OpenDirectory"}, {9, D<&IFileSystem::OpenDirectory>, "OpenDirectory"},
{10, &IFileSystem::Commit, "Commit"}, {10, D<&IFileSystem::Commit>, "Commit"},
{11, &IFileSystem::GetFreeSpaceSize, "GetFreeSpaceSize"}, {11, D<&IFileSystem::GetFreeSpaceSize>, "GetFreeSpaceSize"},
{12, &IFileSystem::GetTotalSpaceSize, "GetTotalSpaceSize"}, {12, D<&IFileSystem::GetTotalSpaceSize>, "GetTotalSpaceSize"},
{13, &IFileSystem::CleanDirectoryRecursively, "CleanDirectoryRecursively"}, {13, D<&IFileSystem::CleanDirectoryRecursively>, "CleanDirectoryRecursively"},
{14, &IFileSystem::GetFileTimeStampRaw, "GetFileTimeStampRaw"}, {14, D<&IFileSystem::GetFileTimeStampRaw>, "GetFileTimeStampRaw"},
{15, nullptr, "QueryEntry"}, {15, nullptr, "QueryEntry"},
{16, &IFileSystem::GetFileSystemAttribute, "GetFileSystemAttribute"}, {16, D<&IFileSystem::GetFileSystemAttribute>, "GetFileSystemAttribute"},
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }
void IFileSystem::CreateFile(HLERequestContext& ctx) { Result IFileSystem::CreateFile(const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path,
IPC::RequestParser rp{ctx}; s32 option, s64 size) {
LOG_DEBUG(Service_FS, "called. file={}, option=0x{:X}, size=0x{:08X}", path->str, option, size);
const auto file_buffer = ctx.ReadBuffer(); R_RETURN(backend->CreateFile(FileSys::Path(path->str), size));
const std::string name = Common::StringFromBuffer(file_buffer);
const auto path = FileSys::Path(name.c_str());
const u64 file_mode = rp.Pop<u64>();
const u32 file_size = rp.Pop<u32>();
LOG_DEBUG(Service_FS, "called. file={}, mode=0x{:X}, size=0x{:08X}", name, file_mode,
file_size);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(backend->CreateFile(path, file_size));
} }
void IFileSystem::DeleteFile(HLERequestContext& ctx) { Result IFileSystem::DeleteFile(const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path) {
const auto file_buffer = ctx.ReadBuffer(); LOG_DEBUG(Service_FS, "called. file={}", path->str);
const std::string name = Common::StringFromBuffer(file_buffer);
const auto path = FileSys::Path(name.c_str());
LOG_DEBUG(Service_FS, "called. file={}", name); R_RETURN(backend->DeleteFile(FileSys::Path(path->str)));
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(backend->DeleteFile(path));
} }
void IFileSystem::CreateDirectory(HLERequestContext& ctx) { Result IFileSystem::CreateDirectory(
const auto file_buffer = ctx.ReadBuffer(); const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path) {
const std::string name = Common::StringFromBuffer(file_buffer); LOG_DEBUG(Service_FS, "called. directory={}", path->str);
const auto path = FileSys::Path(name.c_str());
LOG_DEBUG(Service_FS, "called. directory={}", name); R_RETURN(backend->CreateDirectory(FileSys::Path(path->str)));
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(backend->CreateDirectory(path));
} }
void IFileSystem::DeleteDirectory(HLERequestContext& ctx) { Result IFileSystem::DeleteDirectory(
const auto file_buffer = ctx.ReadBuffer(); const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path) {
const std::string name = Common::StringFromBuffer(file_buffer); LOG_DEBUG(Service_FS, "called. directory={}", path->str);
const auto path = FileSys::Path(name.c_str());
LOG_DEBUG(Service_FS, "called. directory={}", name); R_RETURN(backend->DeleteDirectory(FileSys::Path(path->str)));
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(backend->DeleteDirectory(path));
} }
void IFileSystem::DeleteDirectoryRecursively(HLERequestContext& ctx) { Result IFileSystem::DeleteDirectoryRecursively(
const auto file_buffer = ctx.ReadBuffer(); const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path) {
const std::string name = Common::StringFromBuffer(file_buffer); LOG_DEBUG(Service_FS, "called. directory={}", path->str);
const auto path = FileSys::Path(name.c_str());
LOG_DEBUG(Service_FS, "called. directory={}", name); R_RETURN(backend->DeleteDirectoryRecursively(FileSys::Path(path->str)));
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(backend->DeleteDirectoryRecursively(path));
} }
void IFileSystem::CleanDirectoryRecursively(HLERequestContext& ctx) { Result IFileSystem::CleanDirectoryRecursively(
const auto file_buffer = ctx.ReadBuffer(); const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path) {
const std::string name = Common::StringFromBuffer(file_buffer); LOG_DEBUG(Service_FS, "called. Directory: {}", path->str);
const auto path = FileSys::Path(name.c_str());
LOG_DEBUG(Service_FS, "called. Directory: {}", name); R_RETURN(backend->CleanDirectoryRecursively(FileSys::Path(path->str)));
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(backend->CleanDirectoryRecursively(path));
} }
void IFileSystem::RenameFile(HLERequestContext& ctx) { Result IFileSystem::RenameFile(
const std::string src_name = Common::StringFromBuffer(ctx.ReadBuffer(0)); const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> old_path,
const std::string dst_name = Common::StringFromBuffer(ctx.ReadBuffer(1)); const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> new_path) {
LOG_DEBUG(Service_FS, "called. file '{}' to file '{}'", old_path->str, new_path->str);
const auto src_path = FileSys::Path(src_name.c_str()); R_RETURN(backend->RenameFile(FileSys::Path(old_path->str), FileSys::Path(new_path->str)));
const auto dst_path = FileSys::Path(dst_name.c_str());
LOG_DEBUG(Service_FS, "called. file '{}' to file '{}'", src_name, dst_name);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(backend->RenameFile(src_path, dst_path));
} }
void IFileSystem::OpenFile(HLERequestContext& ctx) { Result IFileSystem::OpenFile(OutInterface<IFile> out_interface,
IPC::RequestParser rp{ctx}; const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path,
u32 mode) {
const auto file_buffer = ctx.ReadBuffer(); LOG_DEBUG(Service_FS, "called. file={}, mode={}", path->str, mode);
const std::string name = Common::StringFromBuffer(file_buffer);
const auto path = FileSys::Path(name.c_str());
const auto mode = static_cast<FileSys::OpenMode>(rp.Pop<u32>());
LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode);
FileSys::VirtualFile vfs_file{}; FileSys::VirtualFile vfs_file{};
auto result = backend->OpenFile(&vfs_file, path, mode); R_TRY(backend->OpenFile(&vfs_file, FileSys::Path(path->str),
if (result != ResultSuccess) { static_cast<FileSys::OpenMode>(mode)));
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result); *out_interface = std::make_shared<IFile>(system, vfs_file);
return; R_SUCCEED();
} }
auto file = std::make_shared<IFile>(system, vfs_file); Result IFileSystem::OpenDirectory(OutInterface<IDirectory> out_interface,
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path,
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; u32 mode) {
rb.Push(ResultSuccess); LOG_DEBUG(Service_FS, "called. directory={}, mode={}", path->str, mode);
rb.PushIpcInterface<IFile>(std::move(file));
}
void IFileSystem::OpenDirectory(HLERequestContext& ctx) {
IPC::RequestParser rp{ctx};
const auto file_buffer = ctx.ReadBuffer();
const std::string name = Common::StringFromBuffer(file_buffer);
const auto path = FileSys::Path(name.c_str());
const auto mode = rp.PopRaw<FileSys::OpenDirectoryMode>();
LOG_DEBUG(Service_FS, "called. directory={}, mode={}", name, mode);
FileSys::VirtualDir vfs_dir{}; FileSys::VirtualDir vfs_dir{};
auto result = backend->OpenDirectory(&vfs_dir, path, mode); R_TRY(backend->OpenDirectory(&vfs_dir, FileSys::Path(path->str),
if (result != ResultSuccess) { static_cast<FileSys::OpenDirectoryMode>(mode)));
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result); *out_interface = std::make_shared<IDirectory>(system, vfs_dir,
return; static_cast<FileSys::OpenDirectoryMode>(mode));
R_SUCCEED();
} }
auto directory = std::make_shared<IDirectory>(system, vfs_dir, mode); Result IFileSystem::GetEntryType(
Out<u32> out_type, const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path) {
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; LOG_DEBUG(Service_FS, "called. file={}", path->str);
rb.Push(ResultSuccess);
rb.PushIpcInterface<IDirectory>(std::move(directory));
}
void IFileSystem::GetEntryType(HLERequestContext& ctx) {
const auto file_buffer = ctx.ReadBuffer();
const std::string name = Common::StringFromBuffer(file_buffer);
const auto path = FileSys::Path(name.c_str());
LOG_DEBUG(Service_FS, "called. file={}", name);
FileSys::DirectoryEntryType vfs_entry_type{}; FileSys::DirectoryEntryType vfs_entry_type{};
auto result = backend->GetEntryType(&vfs_entry_type, path); R_TRY(backend->GetEntryType(&vfs_entry_type, FileSys::Path(path->str)));
if (result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; *out_type = static_cast<u32>(vfs_entry_type);
rb.Push(result); R_SUCCEED();
return;
} }
IPC::ResponseBuilder rb{ctx, 3}; Result IFileSystem::Commit() {
rb.Push(ResultSuccess);
rb.Push<u32>(static_cast<u32>(vfs_entry_type));
}
void IFileSystem::Commit(HLERequestContext& ctx) {
LOG_WARNING(Service_FS, "(STUBBED) called"); LOG_WARNING(Service_FS, "(STUBBED) called");
IPC::ResponseBuilder rb{ctx, 2}; R_SUCCEED();
rb.Push(ResultSuccess);
} }
void IFileSystem::GetFreeSpaceSize(HLERequestContext& ctx) { Result IFileSystem::GetFreeSpaceSize(
Out<s64> out_size, const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path) {
LOG_DEBUG(Service_FS, "called"); LOG_DEBUG(Service_FS, "called");
IPC::ResponseBuilder rb{ctx, 4}; *out_size = size_getter.get_free_size();
rb.Push(ResultSuccess); R_SUCCEED();
rb.Push(size.get_free_size());
} }
void IFileSystem::GetTotalSpaceSize(HLERequestContext& ctx) { Result IFileSystem::GetTotalSpaceSize(
Out<s64> out_size, const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path) {
LOG_DEBUG(Service_FS, "called"); LOG_DEBUG(Service_FS, "called");
IPC::ResponseBuilder rb{ctx, 4}; *out_size = size_getter.get_total_size();
rb.Push(ResultSuccess); R_SUCCEED();
rb.Push(size.get_total_size());
} }
void IFileSystem::GetFileTimeStampRaw(HLERequestContext& ctx) { Result IFileSystem::GetFileTimeStampRaw(
const auto file_buffer = ctx.ReadBuffer(); Out<FileSys::FileTimeStampRaw> out_timestamp,
const std::string name = Common::StringFromBuffer(file_buffer); const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path) {
const auto path = FileSys::Path(name.c_str()); LOG_WARNING(Service_FS, "(Partial Implementation) called. file={}", path->str);
LOG_WARNING(Service_FS, "(Partial Implementation) called. file={}", name);
FileSys::FileTimeStampRaw vfs_timestamp{}; FileSys::FileTimeStampRaw vfs_timestamp{};
auto result = backend->GetFileTimeStampRaw(&vfs_timestamp, path); R_TRY(backend->GetFileTimeStampRaw(&vfs_timestamp, FileSys::Path(path->str)));
if (result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; *out_timestamp = vfs_timestamp;
rb.Push(result); R_SUCCEED();
return;
} }
IPC::ResponseBuilder rb{ctx, 10}; Result IFileSystem::GetFileSystemAttribute(Out<FileSystemAttribute> out_attribute) {
rb.Push(ResultSuccess);
rb.PushRaw(vfs_timestamp);
}
void IFileSystem::GetFileSystemAttribute(HLERequestContext& ctx) {
LOG_WARNING(Service_FS, "(STUBBED) called"); LOG_WARNING(Service_FS, "(STUBBED) called");
struct FileSystemAttribute {
u8 dir_entry_name_length_max_defined;
u8 file_entry_name_length_max_defined;
u8 dir_path_name_length_max_defined;
u8 file_path_name_length_max_defined;
INSERT_PADDING_BYTES_NOINIT(0x5);
u8 utf16_dir_entry_name_length_max_defined;
u8 utf16_file_entry_name_length_max_defined;
u8 utf16_dir_path_name_length_max_defined;
u8 utf16_file_path_name_length_max_defined;
INSERT_PADDING_BYTES_NOINIT(0x18);
s32 dir_entry_name_length_max;
s32 file_entry_name_length_max;
s32 dir_path_name_length_max;
s32 file_path_name_length_max;
INSERT_PADDING_WORDS_NOINIT(0x5);
s32 utf16_dir_entry_name_length_max;
s32 utf16_file_entry_name_length_max;
s32 utf16_dir_path_name_length_max;
s32 utf16_file_path_name_length_max;
INSERT_PADDING_WORDS_NOINIT(0x18);
INSERT_PADDING_WORDS_NOINIT(0x1);
};
static_assert(sizeof(FileSystemAttribute) == 0xc0, "FileSystemAttribute has incorrect size");
FileSystemAttribute savedata_attribute{}; FileSystemAttribute savedata_attribute{};
savedata_attribute.dir_entry_name_length_max_defined = true; savedata_attribute.dir_entry_name_length_max_defined = true;
savedata_attribute.file_entry_name_length_max_defined = true; savedata_attribute.file_entry_name_length_max_defined = true;
savedata_attribute.dir_entry_name_length_max = 0x40; savedata_attribute.dir_entry_name_length_max = 0x40;
savedata_attribute.file_entry_name_length_max = 0x40; savedata_attribute.file_entry_name_length_max = 0x40;
IPC::ResponseBuilder rb{ctx, 50}; *out_attribute = savedata_attribute;
rb.Push(ResultSuccess); R_SUCCEED();
rb.PushRaw(savedata_attribute);
} }
} // namespace Service::FileSystem } // namespace Service::FileSystem

78
src/core/hle/service/filesystem/fsp/fs_i_filesystem.h
View File

@ -5,35 +5,79 @@
#include "core/file_sys/fsa/fs_i_filesystem.h" #include "core/file_sys/fsa/fs_i_filesystem.h"
#include "core/file_sys/vfs/vfs.h" #include "core/file_sys/vfs/vfs.h"
#include "core/hle/service/cmif_types.h"
#include "core/hle/service/filesystem/filesystem.h" #include "core/hle/service/filesystem/filesystem.h"
#include "core/hle/service/filesystem/fsp/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 FileSys::Sf {
struct Path;
}
namespace Service::FileSystem { namespace Service::FileSystem {
class IFile;
class IDirectory;
class IFileSystem final : public ServiceFramework<IFileSystem> { class IFileSystem final : public ServiceFramework<IFileSystem> {
public: public:
explicit IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGetter size_); explicit IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGetter size_getter_);
void CreateFile(HLERequestContext& ctx); struct FileSystemAttribute {
void DeleteFile(HLERequestContext& ctx); u8 dir_entry_name_length_max_defined;
void CreateDirectory(HLERequestContext& ctx); u8 file_entry_name_length_max_defined;
void DeleteDirectory(HLERequestContext& ctx); u8 dir_path_name_length_max_defined;
void DeleteDirectoryRecursively(HLERequestContext& ctx); u8 file_path_name_length_max_defined;
void CleanDirectoryRecursively(HLERequestContext& ctx); INSERT_PADDING_BYTES_NOINIT(0x5);
void RenameFile(HLERequestContext& ctx); u8 utf16_dir_entry_name_length_max_defined;
void OpenFile(HLERequestContext& ctx); u8 utf16_file_entry_name_length_max_defined;
void OpenDirectory(HLERequestContext& ctx); u8 utf16_dir_path_name_length_max_defined;
void GetEntryType(HLERequestContext& ctx); u8 utf16_file_path_name_length_max_defined;
void Commit(HLERequestContext& ctx); INSERT_PADDING_BYTES_NOINIT(0x18);
void GetFreeSpaceSize(HLERequestContext& ctx); s32 dir_entry_name_length_max;
void GetTotalSpaceSize(HLERequestContext& ctx); s32 file_entry_name_length_max;
void GetFileTimeStampRaw(HLERequestContext& ctx); s32 dir_path_name_length_max;
void GetFileSystemAttribute(HLERequestContext& ctx); s32 file_path_name_length_max;
INSERT_PADDING_WORDS_NOINIT(0x5);
s32 utf16_dir_entry_name_length_max;
s32 utf16_file_entry_name_length_max;
s32 utf16_dir_path_name_length_max;
s32 utf16_file_path_name_length_max;
INSERT_PADDING_WORDS_NOINIT(0x18);
INSERT_PADDING_WORDS_NOINIT(0x1);
};
static_assert(sizeof(FileSystemAttribute) == 0xC0, "FileSystemAttribute has incorrect size");
Result CreateFile(const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path,
s32 option, s64 size);
Result DeleteFile(const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
Result CreateDirectory(const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
Result DeleteDirectory(const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
Result DeleteDirectoryRecursively(
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
Result CleanDirectoryRecursively(
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
Result RenameFile(const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> old_path,
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> new_path);
Result OpenFile(OutInterface<IFile> out_interface,
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path, u32 mode);
Result OpenDirectory(OutInterface<IDirectory> out_interface,
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path,
u32 mode);
Result GetEntryType(Out<u32> out_type,
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
Result Commit();
Result GetFreeSpaceSize(Out<s64> out_size,
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
Result GetTotalSpaceSize(Out<s64> out_size,
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
Result GetFileTimeStampRaw(Out<FileSys::FileTimeStampRaw> out_timestamp,
const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
Result GetFileSystemAttribute(Out<FileSystemAttribute> out_attribute);
private: private:
std::unique_ptr<FileSys::Fsa::IFileSystem> backend; std::unique_ptr<FileSys::Fsa::IFileSystem> backend;
SizeGetter size; SizeGetter size_getter;
}; };
} // namespace Service::FileSystem } // namespace Service::FileSystem