mirror of
https://github.com/Atmosphere-NX/Atmosphere
synced 2024-11-10 15:16:34 +00:00
314 lines
11 KiB
C++
314 lines
11 KiB
C++
/*
|
|
* Copyright (c) Atmosphère-NX
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <stratosphere.hpp>
|
|
#include "fs_file_accessor.hpp"
|
|
#include "fs_directory_accessor.hpp"
|
|
#include "fs_filesystem_accessor.hpp"
|
|
|
|
namespace ams::fs::impl {
|
|
|
|
namespace {
|
|
|
|
template<typename List, typename Iter>
|
|
void Remove(List &list, Iter *desired) {
|
|
for (auto it = list.cbegin(); it != list.cend(); ++it) {
|
|
if (it.operator->() == desired) {
|
|
list.erase(it);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* This should never happen. */
|
|
AMS_ABORT();
|
|
}
|
|
|
|
Result SetMountName(char *dst, const char *name) {
|
|
R_UNLESS(name[0] != 0, fs::ResultInvalidMountName());
|
|
|
|
const size_t n_len = util::Strlcpy<char>(dst, name, MountNameLengthMax + 1);
|
|
R_UNLESS(n_len <= MountNameLengthMax, fs::ResultInvalidMountName());
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
template<typename List>
|
|
Result ValidateNoOpenWriteModeFiles(List &list) {
|
|
for (auto it = list.cbegin(); it != list.cend(); it++) {
|
|
R_UNLESS((it->GetOpenMode() & OpenMode_Write) == 0, fs::ResultWriteModeFileNotClosed());
|
|
}
|
|
R_SUCCEED();
|
|
}
|
|
|
|
}
|
|
|
|
FileSystemAccessor::FileSystemAccessor(const char *n, std::unique_ptr<fsa::IFileSystem> &&fs, std::unique_ptr<fsa::ICommonMountNameGenerator> &&generator)
|
|
: m_impl(std::move(fs)), m_open_list_lock(), m_mount_name_generator(std::move(generator)),
|
|
m_access_log_enabled(false), m_data_cache_attachable(false), m_path_cache_attachable(false), m_path_cache_attached(false), m_multi_commit_supported(false),
|
|
m_path_flags()
|
|
{
|
|
R_ABORT_UNLESS(SetMountName(m_name.str, n));
|
|
|
|
if (std::strcmp(m_name.str, AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME) == 0) {
|
|
m_path_flags.AllowWindowsPath();
|
|
}
|
|
}
|
|
|
|
FileSystemAccessor::~FileSystemAccessor() {
|
|
std::scoped_lock lk(m_open_list_lock);
|
|
|
|
/* TODO: Iterate over list entries. */
|
|
|
|
if (!m_open_file_list.empty()) { R_ABORT_UNLESS(fs::ResultFileNotClosed()); }
|
|
if (!m_open_dir_list.empty()) { R_ABORT_UNLESS(fs::ResultDirectoryNotClosed()); }
|
|
|
|
if (m_path_cache_attached) {
|
|
/* TODO: Invalidate path cache */
|
|
}
|
|
}
|
|
|
|
Result FileSystemAccessor::GetCommonMountName(char *dst, size_t dst_size) const {
|
|
R_UNLESS(m_mount_name_generator != nullptr, fs::ResultPreconditionViolation());
|
|
R_RETURN(m_mount_name_generator->GenerateCommonMountName(dst, dst_size));
|
|
}
|
|
|
|
std::shared_ptr<fssrv::impl::FileSystemInterfaceAdapter> FileSystemAccessor::GetMultiCommitTarget() {
|
|
if (m_multi_commit_supported) {
|
|
AMS_ABORT("TODO: Support multi commit");
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void FileSystemAccessor::NotifyCloseFile(FileAccessor *f) {
|
|
std::scoped_lock lk(m_open_list_lock);
|
|
Remove(m_open_file_list, f);
|
|
}
|
|
|
|
void FileSystemAccessor::NotifyCloseDirectory(DirectoryAccessor *d) {
|
|
std::scoped_lock lk(m_open_list_lock);
|
|
Remove(m_open_dir_list, d);
|
|
}
|
|
|
|
Result FileSystemAccessor::SetUpPath(fs::Path *out, const char *p) {
|
|
/* Initialize the path appropriately. */
|
|
bool normalized;
|
|
size_t len;
|
|
if (R_SUCCEEDED(PathFormatter::IsNormalized(std::addressof(normalized), std::addressof(len), p, m_path_flags)) && normalized) {
|
|
/* We can use the input buffer directly. */
|
|
out->SetShallowBuffer(p);
|
|
} else {
|
|
/* Initialize with appropriate slash replacement. */
|
|
if (m_path_flags.IsWindowsPathAllowed()) {
|
|
R_TRY(out->InitializeWithReplaceForwardSlashes(p));
|
|
} else {
|
|
R_TRY(out->InitializeWithReplaceBackslash(p));
|
|
}
|
|
|
|
/* Ensure we're normalized. */
|
|
R_TRY(out->Normalize(m_path_flags));
|
|
}
|
|
|
|
/* Check the path isn't too long. */
|
|
R_UNLESS(out->GetLength() <= fs::EntryNameLengthMax, fs::ResultTooLongPath());
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result FileSystemAccessor::CreateFile(const char *path, s64 size, int option) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
if (m_path_cache_attached) {
|
|
/* TODO: Path cache */
|
|
R_TRY(m_impl->CreateFile(normalized_path, size, option));
|
|
} else {
|
|
R_TRY(m_impl->CreateFile(normalized_path, size, option));
|
|
}
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result FileSystemAccessor::DeleteFile(const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->DeleteFile(normalized_path));
|
|
}
|
|
|
|
Result FileSystemAccessor::CreateDirectory(const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->CreateDirectory(normalized_path));
|
|
}
|
|
|
|
Result FileSystemAccessor::DeleteDirectory(const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->DeleteDirectory(normalized_path));
|
|
}
|
|
|
|
Result FileSystemAccessor::DeleteDirectoryRecursively(const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->DeleteDirectoryRecursively(normalized_path));
|
|
}
|
|
|
|
Result FileSystemAccessor::RenameFile(const char *old_path, const char *new_path) {
|
|
/* Create path. */
|
|
fs::Path normalized_old_path;
|
|
fs::Path normalized_new_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_old_path), old_path));
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_new_path), new_path));
|
|
|
|
if (m_path_cache_attached) {
|
|
/* TODO: Path cache */
|
|
R_TRY(m_impl->RenameFile(normalized_old_path, normalized_new_path));
|
|
} else {
|
|
R_TRY(m_impl->RenameFile(normalized_old_path, normalized_new_path));
|
|
}
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result FileSystemAccessor::RenameDirectory(const char *old_path, const char *new_path) {
|
|
/* Create path. */
|
|
fs::Path normalized_old_path;
|
|
fs::Path normalized_new_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_old_path), old_path));
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_new_path), new_path));
|
|
|
|
if (m_path_cache_attached) {
|
|
/* TODO: Path cache */
|
|
R_TRY(m_impl->RenameDirectory(normalized_old_path, normalized_new_path));
|
|
} else {
|
|
R_TRY(m_impl->RenameDirectory(normalized_old_path, normalized_new_path));
|
|
}
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result FileSystemAccessor::GetEntryType(DirectoryEntryType *out, const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->GetEntryType(out, normalized_path));
|
|
}
|
|
|
|
Result FileSystemAccessor::OpenFile(std::unique_ptr<FileAccessor> *out_file, const char *path, OpenMode mode) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
std::unique_ptr<fsa::IFile> file;
|
|
R_TRY(m_impl->OpenFile(std::addressof(file), normalized_path, mode));
|
|
|
|
auto accessor = new FileAccessor(std::move(file), this, mode);
|
|
R_UNLESS(accessor != nullptr, fs::ResultAllocationFailureInFileSystemAccessorA());
|
|
|
|
{
|
|
std::scoped_lock lk(m_open_list_lock);
|
|
m_open_file_list.push_back(*accessor);
|
|
}
|
|
|
|
if (m_path_cache_attached) {
|
|
if (mode & OpenMode_AllowAppend) {
|
|
/* TODO: Append Path cache */
|
|
} else {
|
|
/* TODO: Non-append path cache */
|
|
}
|
|
}
|
|
|
|
out_file->reset(accessor);
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result FileSystemAccessor::OpenDirectory(std::unique_ptr<DirectoryAccessor> *out_dir, const char *path, OpenDirectoryMode mode) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
std::unique_ptr<fsa::IDirectory> dir;
|
|
R_TRY(m_impl->OpenDirectory(std::addressof(dir), normalized_path, mode));
|
|
|
|
auto accessor = new DirectoryAccessor(std::move(dir), *this);
|
|
R_UNLESS(accessor != nullptr, fs::ResultAllocationFailureInFileSystemAccessorB());
|
|
|
|
{
|
|
std::scoped_lock lk(m_open_list_lock);
|
|
m_open_dir_list.push_back(*accessor);
|
|
}
|
|
|
|
out_dir->reset(accessor);
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result FileSystemAccessor::Commit() {
|
|
{
|
|
std::scoped_lock lk(m_open_list_lock);
|
|
R_ABORT_UNLESS(ValidateNoOpenWriteModeFiles(m_open_file_list));
|
|
}
|
|
R_RETURN(m_impl->Commit());
|
|
}
|
|
|
|
Result FileSystemAccessor::GetFreeSpaceSize(s64 *out, const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->GetFreeSpaceSize(out, normalized_path));
|
|
}
|
|
|
|
Result FileSystemAccessor::GetTotalSpaceSize(s64 *out, const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->GetTotalSpaceSize(out, normalized_path));
|
|
}
|
|
|
|
Result FileSystemAccessor::CleanDirectoryRecursively(const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->CleanDirectoryRecursively(normalized_path));
|
|
}
|
|
|
|
Result FileSystemAccessor::GetFileTimeStampRaw(FileTimeStampRaw *out, const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->GetFileTimeStampRaw(out, normalized_path));
|
|
}
|
|
|
|
Result FileSystemAccessor::QueryEntry(char *dst, size_t dst_size, const char *src, size_t src_size, fsa::QueryId query, const char *path) {
|
|
/* Create path. */
|
|
fs::Path normalized_path;
|
|
R_TRY(this->SetUpPath(std::addressof(normalized_path), path));
|
|
|
|
R_RETURN(m_impl->QueryEntry(dst, dst_size, src, src_size, query, normalized_path));
|
|
}
|
|
|
|
|
|
}
|