diff --git a/libraries/libstratosphere/include/stratosphere/fs/fs_dbm_hierarchical_rom_file_table.hpp b/libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_hierarchical_rom_file_table.hpp similarity index 85% rename from libraries/libstratosphere/include/stratosphere/fs/fs_dbm_hierarchical_rom_file_table.hpp rename to libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_hierarchical_rom_file_table.hpp index 25651f7e3..c8cb144b0 100644 --- a/libraries/libstratosphere/include/stratosphere/fs/fs_dbm_hierarchical_rom_file_table.hpp +++ b/libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_hierarchical_rom_file_table.hpp @@ -14,9 +14,9 @@ * along with this program. If not, see . */ #pragma once -#include "fs_dbm_rom_types.hpp" -#include "fs_dbm_rom_path_tool.hpp" -#include "fs_dbm_rom_key_value_storage.hpp" +#include +#include +#include namespace ams::fs { @@ -33,19 +33,23 @@ namespace ams::fs { using DirectoryInfo = RomDirectoryInfo; using FileInfo = RomFileInfo; - static constexpr RomFileId ConvertToFileId(Position pos) { + static constexpr RomFileId PositionToFileId(Position pos) { return static_cast(pos); } + + static constexpr Position FileIdToPosition(RomFileId id) { + return static_cast(id); + } private: static constexpr inline Position InvalidPosition = ~Position(); static constexpr inline Position RootPosition = 0; static constexpr inline size_t ReservedDirectoryCount = 1; - static constexpr RomDirectoryId ConvertToDirectoryId(Position pos) { + static constexpr RomDirectoryId PositionToDirectoryId(Position pos) { return static_cast(pos); } - static constexpr Position ConvertToPosition(RomDirectoryId id) { + static constexpr Position DirectoryIdToPosition(RomDirectoryId id) { return static_cast(id); } @@ -67,20 +71,20 @@ namespace ams::fs { static constexpr inline u32 MaxKeyLength = RomPathTool::MaxPathLength; template - class EntryMapTable : public RomKeyValueStorage { + class EntryMapTable : public KeyValueRomStorageTemplate { public: using ImplKey = ImplKeyType; using ClientKey = ClientKeyType; using Value = ValueType; using Position = HierarchicalRomFileTable::Position; - using Base = RomKeyValueStorage; + using Base = KeyValueRomStorageTemplate; public: Result Add(Position *out, const ClientKeyType &key, const Value &value) { - return Base::AddImpl(out, key.key, key.Hash(), key.name.path, key.name.length * sizeof(RomPathChar), value); + return Base::AddInternal(out, key.key, key.Hash(), key.name.path, key.name.length * sizeof(RomPathChar), value); } Result Get(Position *out_pos, Value *out_val, const ClientKeyType &key) { - return Base::GetImpl(out_pos, out_val, key.key, key.Hash(), key.name.path, key.name.length * sizeof(RomPathChar)); + return Base::GetInternal(out_pos, out_val, key.key, key.Hash(), key.name.path, key.name.length * sizeof(RomPathChar)); } Result GetByPosition(ImplKey *out_key, Value *out_val, Position pos) { @@ -117,8 +121,8 @@ namespace ams::fs { constexpr u32 Hash() const { u32 hash = this->key.parent ^ 123456789; - const RomPathChar *name = this->name.path; - const RomPathChar *end = name + this->name.length; + const RomPathChar * name = this->name.path; + const RomPathChar * const end = name + this->name.length; while (name < end) { const u32 cur = static_cast(static_cast::type>(*(name++))); hash = ((hash >> 5) | (hash << 27)) ^ cur; @@ -134,10 +138,10 @@ namespace ams::fs { DirectoryEntryMapTable dir_table; FileEntryMapTable file_table; public: - static s64 QueryDirectoryEntryStorageSize(u32 count); static s64 QueryDirectoryEntryBucketStorageSize(s64 count); - static s64 QueryFileEntryStorageSize(u32 count); + static size_t QueryDirectoryEntrySize(size_t aux_size); static s64 QueryFileEntryBucketStorageSize(s64 count); + static size_t QueryFileEntrySize(size_t aux_size); static Result Format(SubStorage dir_bucket, SubStorage file_bucket); public: diff --git a/libraries/libstratosphere/include/stratosphere/fs/fs_dbm_rom_key_value_storage.hpp b/libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_rom_key_value_storage.hpp similarity index 73% rename from libraries/libstratosphere/include/stratosphere/fs/fs_dbm_rom_key_value_storage.hpp rename to libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_rom_key_value_storage.hpp index 455f1cdff..4acc152d7 100644 --- a/libraries/libstratosphere/include/stratosphere/fs/fs_dbm_rom_key_value_storage.hpp +++ b/libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_rom_key_value_storage.hpp @@ -14,13 +14,13 @@ * along with this program. If not, see . */ #pragma once -#include "fs_dbm_rom_types.hpp" -#include "fs_substorage.hpp" +#include +#include namespace ams::fs { template - class RomKeyValueStorage { + class KeyValueRomStorageTemplate { public: using Key = KeyType; using Value = ValueType; @@ -57,8 +57,8 @@ namespace ams::fs { return size / sizeof(Position); } - static constexpr s64 QueryKeyValueStorageSize(u32 num) { - return num * sizeof(Element); + static constexpr size_t QueryEntrySize(size_t aux_size) { + return util::AlignUp(sizeof(Element) + aux_size, alignof(Element)); } static Result Format(SubStorage bucket, s64 count) { @@ -69,13 +69,13 @@ namespace ams::fs { return ResultSuccess(); } public: - RomKeyValueStorage() : bucket_count(), bucket_storage(), kv_storage(), total_entry_size(), entry_count() { /* ... */ } + KeyValueRomStorageTemplate() : bucket_count(), bucket_storage(), kv_storage(), total_entry_size(), entry_count() { /* ... */ } Result Initialize(const SubStorage &bucket, s64 count, const SubStorage &kv) { AMS_ASSERT(count > 0); this->bucket_storage = bucket; - this->kv_storage = kv; this->bucket_count = count; + this->kv_storage = kv; return ResultSuccess(); } @@ -100,82 +100,17 @@ namespace ams::fs { constexpr u32 GetEntryCount() const { return this->entry_count; } - - Result Add(const Key &key, u32 hash_key, const void *aux, size_t aux_size, const Value &value) { - AMS_ASSERT(aux != nullptr); - AMS_ASSERT(aux_size <= MaxAuxiliarySize); - Position pos; - return this->AddImpl(std::addressof(pos), key, hash_key, aux, aux_size, value); - } - - Result Get(Value *out, const Key &key, u32 hash_key, const void *aux, size_t aux_size) { - AMS_ASSERT(aux != nullptr); - AMS_ASSERT(aux_size <= MaxAuxiliarySize); - Position pos; - return this->GetImpl(std::addressof(pos), out, key, hash_key, aux, aux_size); - } - - void FindOpen(FindIndex *out) const { - AMS_ASSERT(out != nullptr); - - out->ind = static_cast(-1); - out->pos = InvalidPosition; - } - - Result FindNext(Key *out_key, Value *out_val, FindIndex *find) { - AMS_ASSERT(out_key != nullptr); - AMS_ASSERT(out_val != nullptr); - AMS_ASSERT(find != nullptr); - - BucketIndex ind = find->ind; - R_UNLESS((ind < this->bucket_count) || ind == static_cast(-1), fs::ResultDbmFindKeyFinished()); - - s64 kv_size; - R_TRY(this->kv_storage.GetSize(std::addressof(kv_size))); - - while (true) { - if (find->pos != InvalidPosition) { - Element elem; - R_TRY(this->ReadKeyValue(std::addressof(elem), find->pos)); - - AMS_ASSERT(elem.next == InvalidPosition || elem.next < kv_size); - find->pos = elem.next; - *out_key = elem.key; - *out_val = elem.val; - return ResultSuccess(); - } - - while (true) { - ind++; - if (ind == this->bucket_count) { - find->ind = ind; - find->pos = InvalidPosition; - return fs::ResultDbmFindKeyFinished(); - } - - Position pos; - R_TRY(this->ReadBucket(std::addressof(pos), ind)); - AMS_ASSERT(pos == InvalidPosition || pos < kv_size); - - if (pos != InvalidPosition) { - find->ind = ind; - find->pos = pos; - break; - } - } - } - } protected: - Result AddImpl(Position *out, const Key &key, u32 hash_key, const void *aux, size_t aux_size, const Value &value) { + Result AddInternal(Position *out, const Key &key, u32 hash_key, const void *aux, size_t aux_size, const Value &value) { AMS_ASSERT(out != nullptr); - AMS_ASSERT(aux != nullptr); + AMS_ASSERT(aux != nullptr || aux_size == 0); AMS_ASSERT(this->bucket_count > 0); { Position pos, prev_pos; Element elem; - const Result find_res = this->FindImpl(std::addressof(pos), std::addressof(prev_pos), std::addressof(elem), key, hash_key, aux, aux_size); + const Result find_res = this->FindInternal(std::addressof(pos), std::addressof(prev_pos), std::addressof(elem), key, hash_key, aux, aux_size); R_UNLESS(R_FAILED(find_res), fs::ResultDbmAlreadyExists()); R_UNLESS(fs::ResultDbmKeyNotFound::Includes(find_res), find_res); } @@ -195,14 +130,14 @@ namespace ams::fs { return ResultSuccess(); } - Result GetImpl(Position *out_pos, Value *out_val, const Key &key, u32 hash_key, const void *aux, size_t aux_size) { + Result GetInternal(Position *out_pos, Value *out_val, const Key &key, u32 hash_key, const void *aux, size_t aux_size) { AMS_ASSERT(out_pos != nullptr); AMS_ASSERT(out_val != nullptr); AMS_ASSERT(aux != nullptr); Position pos, prev_pos; Element elem; - R_TRY(this->FindImpl(std::addressof(pos), std::addressof(prev_pos), std::addressof(elem), key, hash_key, aux, aux_size)); + R_TRY(this->FindInternal(std::addressof(pos), std::addressof(prev_pos), std::addressof(elem), key, hash_key, aux, aux_size)); *out_pos = pos; *out_val = elem.value; @@ -246,11 +181,11 @@ namespace ams::fs { return hash_key % this->bucket_count; } - Result FindImpl(Position *out_pos, Position *out_prev, Element *out_elem, const Key &key, u32 hash_key, const void *aux, size_t aux_size) { + Result FindInternal(Position *out_pos, Position *out_prev, Element *out_elem, const Key &key, u32 hash_key, const void *aux, size_t aux_size) { AMS_ASSERT(out_pos != nullptr); AMS_ASSERT(out_prev != nullptr); AMS_ASSERT(out_elem != nullptr); - AMS_ASSERT(aux != nullptr); + AMS_ASSERT(aux != nullptr || aux_size == 0); AMS_ASSERT(this->bucket_count > 0); *out_pos = 0; @@ -296,7 +231,7 @@ namespace ams::fs { *out = static_cast(this->total_entry_size); - this->total_entry_size = util::AlignUp(static_cast(end_pos), s64(4)); + this->total_entry_size = util::AlignUp(static_cast(end_pos), alignof(Position)); return ResultSuccess(); } diff --git a/libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_rom_path_tool.hpp b/libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_rom_path_tool.hpp new file mode 100644 index 000000000..774feda17 --- /dev/null +++ b/libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_rom_path_tool.hpp @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2018-2020 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 . + */ +#pragma once +#include + +namespace ams::fs::RomPathTool { + + constexpr inline u32 MaxPathLength = 0x300; + + struct RomEntryName { + size_t length; + const RomPathChar *path; + }; + static_assert(util::is_pod::value); + + constexpr void InitEntryName(RomEntryName *entry) { + AMS_ASSERT(entry != nullptr); + entry->length = 0; + } + + constexpr inline bool IsSeparator(RomPathChar c) { + return c == RomStringTraits::DirectorySeparator; + } + + constexpr inline bool IsNullTerminator(RomPathChar c) { + return c == RomStringTraits::NullTerminator; + } + + constexpr inline bool IsDot(RomPathChar c) { + return c == RomStringTraits::Dot; + } + + constexpr inline bool IsCurrentDirectory(const RomEntryName &name) { + return name.length == 1 && IsDot(name.path[0]); + } + + constexpr inline bool IsCurrentDirectory(const RomPathChar *p, size_t length) { + AMS_ASSERT(p != nullptr); + return length == 1 && IsDot(p[0]); + } + + constexpr inline bool IsCurrentDirectory(const RomPathChar *p) { + AMS_ASSERT(p != nullptr); + return IsDot(p[0]) && IsNullTerminator(p[1]); + } + + constexpr inline bool IsParentDirectory(const RomEntryName &name) { + return name.length == 2 && IsDot(name.path[0]) && IsDot(name.path[1]); + } + + constexpr inline bool IsParentDirectory(const RomPathChar *p) { + AMS_ASSERT(p != nullptr); + return IsDot(p[0]) && IsDot(p[1]) && IsNullTerminator(p[2]); + } + + constexpr inline bool IsParentDirectory(const RomPathChar *p, size_t length) { + AMS_ASSERT(p != nullptr); + return length == 2 && IsDot(p[0]) && IsDot(p[1]); + } + + constexpr inline bool IsEqualPath(const RomPathChar *lhs, const RomPathChar *rhs, size_t length) { + AMS_ASSERT(lhs != nullptr); + AMS_ASSERT(rhs != nullptr); + return std::strncmp(lhs, rhs, length) == 0; + } + + Result GetParentDirectoryName(RomEntryName *out, const RomEntryName &cur, const RomPathChar *p); + + class PathParser { + private: + const RomPathChar *prev_path_start; + const RomPathChar *prev_path_end; + const RomPathChar *next_path; + bool finished; + public: + constexpr PathParser() : prev_path_start(), prev_path_end(), next_path(), finished() { /* ... */ } + + Result Initialize(const RomPathChar *path); + void Finalize(); + + bool IsParseFinished() const; + bool IsDirectoryPath() const; + + Result GetAsDirectoryName(RomEntryName *out) const; + Result GetAsFileName(RomEntryName *out) const; + + Result GetNextDirectoryName(RomEntryName *out); + }; + +} diff --git a/libraries/libstratosphere/include/stratosphere/fs/fs_dbm_rom_types.hpp b/libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_rom_types.hpp similarity index 97% rename from libraries/libstratosphere/include/stratosphere/fs/fs_dbm_rom_types.hpp rename to libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_rom_types.hpp index f746af65e..c4ab66d32 100644 --- a/libraries/libstratosphere/include/stratosphere/fs/fs_dbm_rom_types.hpp +++ b/libraries/libstratosphere/include/stratosphere/fs/common/fs_dbm_rom_types.hpp @@ -14,7 +14,7 @@ * along with this program. If not, see . */ #pragma once -#include "fs_common.hpp" +#include namespace ams::fs { diff --git a/libraries/libstratosphere/include/stratosphere/fs/fs_dbm_rom_path_tool.hpp b/libraries/libstratosphere/include/stratosphere/fs/fs_dbm_rom_path_tool.hpp deleted file mode 100644 index 7fc957c92..000000000 --- a/libraries/libstratosphere/include/stratosphere/fs/fs_dbm_rom_path_tool.hpp +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Copyright (c) 2018-2020 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 . - */ -#pragma once -#include "fs_dbm_rom_types.hpp" - -namespace ams::fs { - - namespace RomPathTool { - - constexpr inline u32 MaxPathLength = 0x300; - - struct RomEntryName { - size_t length; - const RomPathChar *path; - }; - static_assert(util::is_pod::value); - - constexpr void InitializeRomEntryName(RomEntryName *entry) { - AMS_ABORT_UNLESS(entry != nullptr); - entry->length = 0; - } - - constexpr inline bool IsSeparator(RomPathChar c) { - return c == RomStringTraits::DirectorySeparator; - } - - constexpr inline bool IsNullTerminator(RomPathChar c) { - return c == RomStringTraits::NullTerminator; - } - - constexpr inline bool IsDot(RomPathChar c) { - return c == RomStringTraits::Dot; - } - - constexpr inline bool IsCurrentDirectory(const RomEntryName &name) { - return name.length == 1 && IsDot(name.path[0]); - } - - constexpr inline bool IsCurrentDirectory(const RomPathChar *p, size_t length) { - AMS_ABORT_UNLESS(p != nullptr); - return length == 1 && IsDot(p[0]); - } - - constexpr inline bool IsCurrentDirectory(const RomPathChar *p) { - AMS_ABORT_UNLESS(p != nullptr); - return IsDot(p[0]) && IsNullTerminator(p[1]); - } - - constexpr inline bool IsParentDirectory(const RomEntryName &name) { - return name.length == 2 && IsDot(name.path[0]) && IsDot(name.path[1]); - } - - constexpr inline bool IsParentDirectory(const RomPathChar *p) { - AMS_ABORT_UNLESS(p != nullptr); - return IsDot(p[0]) && IsDot(p[1]) && IsNullTerminator(p[2]); - } - - constexpr inline bool IsParentDirectory(const RomPathChar *p, size_t length) { - AMS_ABORT_UNLESS(p != nullptr); - return length == 2 && IsDot(p[0]) && IsDot(p[1]); - } - - constexpr inline bool IsEqualPath(const RomPathChar *lhs, const RomPathChar *rhs, size_t length) { - AMS_ABORT_UNLESS(lhs != nullptr); - AMS_ABORT_UNLESS(rhs != nullptr); - return std::strncmp(lhs, rhs, length) == 0; - } - - constexpr inline bool IsEqualName(const RomEntryName &lhs, const RomPathChar *rhs) { - AMS_ABORT_UNLESS(rhs != nullptr); - if (strnlen(rhs, MaxPathLength) != lhs.length) { - return false; - } - return IsEqualPath(lhs.path, rhs, lhs.length); - } - - constexpr inline bool IsEqualName(const RomEntryName &lhs, const RomEntryName &rhs) { - if (lhs.length != rhs.length) { - return false; - } - return IsEqualPath(lhs.path, rhs.path, lhs.length); - } - - Result GetParentDirectoryName(RomEntryName *out, const RomEntryName &cur, const RomPathChar *p); - - class PathParser { - private: - const RomPathChar *prev_path_start; - const RomPathChar *prev_path_end; - const RomPathChar *next_path; - bool finished; - public: - constexpr PathParser() : prev_path_start(), prev_path_end(), next_path(), finished() { /* ... */ } - - Result Initialize(const RomPathChar *path); - void Finalize(); - - bool IsFinished() const; - bool IsDirectoryPath() const; - - Result GetAsDirectoryName(RomEntryName *out) const; - Result GetAsFileName(RomEntryName *out) const; - - Result GetNextDirectoryName(RomEntryName *out); - }; - - } - -} diff --git a/libraries/libstratosphere/include/stratosphere/fs/fs_romfs_filesystem.hpp b/libraries/libstratosphere/include/stratosphere/fs/fs_romfs_filesystem.hpp index 36ae47186..b986d2a76 100644 --- a/libraries/libstratosphere/include/stratosphere/fs/fs_romfs_filesystem.hpp +++ b/libraries/libstratosphere/include/stratosphere/fs/fs_romfs_filesystem.hpp @@ -14,12 +14,12 @@ * along with this program. If not, see . */ #pragma once -#include "fs_common.hpp" -#include "impl/fs_newable.hpp" -#include "fsa/fs_ifile.hpp" -#include "fsa/fs_idirectory.hpp" -#include "fsa/fs_ifilesystem.hpp" -#include "fs_dbm_hierarchical_rom_file_table.hpp" +#include +#include +#include +#include +#include +#include namespace ams::fs { diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_hierarchical_rom_file_table.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_hierarchical_rom_file_table.hpp deleted file mode 100644 index 390aad10e..000000000 --- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_hierarchical_rom_file_table.hpp +++ /dev/null @@ -1,684 +0,0 @@ -/* - * Copyright (c) 2018-2020 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 . - */ -#pragma once -#include -#include -#include -#include - -namespace ams::fssystem { - - template - class HierarchicalRomFileTable { - private: - using DirectoryBucketStorage = DBS; - using DirectoryEntryStorage = DES; - using FileBucketStorage = FBS; - using FileEntryStorage = FES; - public: - using Position = u32; - - struct FindPosition { - Position next_dir; - Position next_file; - }; - static_assert(util::is_pod::value); - - using DirectoryInfo = RomDirectoryInfo; - using FileInfo = RomFileInfo; - - static constexpr RomFileId ConvertToFileId(Position pos) { - return static_cast(pos); - } - private: - static constexpr inline Position InvalidPosition = ~Position(); - static constexpr inline Position RootPosition = 0; - static constexpr inline size_t ReservedDirectoryCount = 1; - - static constexpr RomDirectoryId ConvertToDirectoryId(Position pos) { - return static_cast(pos); - } - - static constexpr Position ConvertToPosition(RomDirectoryId id) { - return static_cast(id); - } - - static_assert(std::is_same::value); - - struct RomDirectoryEntry { - Position next; - Position dir; - Position file; - }; - static_assert(util::is_pod::value); - - struct RomFileEntry { - Position next; - FileInfo info; - }; - static_assert(util::is_pod::value); - - static constexpr inline u32 MaxKeyLength = RomPathTool::MaxPathLength; - - template - class EntryMapTable : public RomKeyValueStorage { - private: - using BucketStorage = BucketStorageType; - using EntryStorage = EntryStorageType; - public: - using ImplKey = ImplKeyType; - using ClientKey = ClientKeyType; - using Value = ValueType; - using Position = HierarchicalRomFileTable::Position; - using Base = RomKeyValueStorage; - public: - Result Add(Position *out, const ClientKeyType &key, const Value &value) { - return Base::AddImpl(out, key.key, key.Hash(), key.name.path, key.name.length * sizeof(RomPathChar), value); - } - - Result Get(Position *out_pos, Value *out_val, const ClientKeyType &key) const { - return Base::GetImpl(out_pos, out_val, key.key, key.Hash(), key.name.path, key.name.length * sizeof(RomPathChar)); - } - - Result GetByPosition(ImplKey *out_key, Value *out_val, void *out_aux, size_t *out_aux_size, Position pos) const { - return Base::GetByPosition(out_key, out_val, out_aux, out_aux_size, pos); - } - - Result SetByPosition(Position pos, const Value &value, fs::WriteOption option) const { - return Base::SetByPosition(pos, value, option); - } - }; - - struct RomEntryKey { - Position parent; - - bool IsEqual(const RomEntryKey &rhs, const void *aux_lhs, size_t aux_lhs_size, const void *aux_rhs, size_t aux_rhs_size) const { - if (this->parent != rhs.parent) { - return false; - } - if (aux_lhs_size != aux_rhs_size) { - return false; - } - return RomPathTool::IsEqualPath(reinterpret_cast(aux_lhs), reinterpret_cast(aux_rhs), aux_lhs_size / sizeof(RomPathChar)); - } - }; - static_assert(util::is_pod::value); - - struct EntryKey { - RomEntryKey key; - RomPathTool::RomEntryName name; - - constexpr u32 Hash() const { - u32 hash = this->key.parent ^ 123456789; - const RomPathChar *name = this->name.path; - const RomPathChar *end = name + this->name.length; - while (name < end) { - const u32 cur = static_cast(static_cast::type>(*(name++))); - hash = ((hash >> 5) | (hash << 27)) ^ cur; - } - return hash; - } - }; - static_assert(util::is_pod::value); - - using DirectoryEntryMapTable = EntryMapTable; - using FileEntryMapTable = EntryMapTable; - private: - DirectoryEntryMapTable dir_table; - FileEntryMapTable file_table; - public: - static u32 QueryDirectoryEntrySize(u32 name_len) { - AMS_ABORT_UNLESS(name_len <= RomPathTool::MaxPathLength); - return DirectoryEntryMapTable::QueryEntrySize(name_len * sizeof(RomPathChar)); - } - - static u32 QueryFileEntrySize(u32 name_len) { - AMS_ABORT_UNLESS(name_len <= RomPathTool::MaxPathLength); - return FileEntryMapTable::QueryEntrySize(name_len * sizeof(RomPathChar)); - } - - static u32 QueryDirectoryEntryBucketStorageSize(u32 count) { return DirectoryEntryMapTable::QueryBucketStorageSize(count); } - static u32 QueryFileEntryBucketStorageSize(u32 count) { return FileEntryMapTable::QueryBucketStorageSize(count); } - - static Result Format(DirectoryBucketStorage *dir_bucket, s64 dir_bucket_ofs, u32 dir_bucket_size, DirectoryEntryStorage *dir_entry, s64 dir_entry_ofs, u32 dir_entry_size, FileBucketStorage *file_bucket, s64 file_bucket_ofs, u32 file_bucket_size, FileEntryStorage *file_entry, s64 file_entry_ofs, u32 file_entry_size) { - R_TRY(DirectoryEntryMapTable::Format(dir_bucket, dir_bucket_ofs, DirectoryEntryMapTable::QueryBucketCount(dir_bucket_size), dir_entry, dir_entry_ofs, dir_entry_size)); - R_TRY(FileEntryMapTable::Format(file_bucket, file_bucket_ofs, FileEntryMapTable::QueryBucketCount(file_bucket_size), file_entry, file_entry_ofs, file_entry_size)); - return ResultSuccess(); - } - public: - HierarchicalRomFileTable() { /* ... */ } - - constexpr u32 GetDirectoryEntryCount() const { - return this->dir_table.GetEntryCount(); - } - - constexpr u32 GetFileEntryCount() const { - return this->file_table.GetEntryCount(); - } - - Result Initialize(DirectoryBucketStorage *dir_bucket, s64 dir_bucket_ofs, u32 dir_bucket_size, DirectoryEntryStorage *dir_entry, s64 dir_entry_ofs, u32 dir_entry_size, FileBucketStorage *file_bucket, s64 file_bucket_ofs, u32 file_bucket_size, FileEntryStorage *file_entry, s64 file_entry_ofs, u32 file_entry_size) { - AMS_ASSERT(dir_bucket != nullptr); - AMS_ASSERT(dir_entry != nullptr); - AMS_ASSERT(file_bucket != nullptr); - AMS_ASSERT(file_entry != nullptr); - - R_TRY(this->dir_table.Initialize(dir_bucket, dir_bucket_ofs, DirectoryEntryMapTable::QueryBucketCount(dir_bucket_size), dir_entry, dir_entry_ofs, dir_entry_size)); - R_TRY(this->file_table.Initialize(file_bucket, file_bucket_ofs, FileEntryMapTable::QueryBucketCount(file_bucket_size), file_entry, file_entry_ofs, file_entry_size)); - - return ResultSuccess(); - } - - void Finalize() { - this->dir_table.Finalize(); - this->file_table.Finalize(); - } - - Result CreateRootDirectory() { - Position root_pos = RootPosition; - EntryKey root_key = {}; - root_key.key.parent = root_pos; - RomPathTool::InitializeRomEntryName(std::addressof(root_key.name)); - RomDirectoryEntry root_entry = { - .next = InvalidPosition, - .dir = InvalidPosition, - .file = InvalidPosition, - }; - return this->dir_table.Add(std::addressof(root_pos), root_key, root_entry); - } - - Result CreateDirectory(RomDirectoryId *out, const RomPathChar *path, const DirectoryInfo &info) { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(path != nullptr); - - EntryKey parent_key = {}; - RomDirectoryEntry parent_entry = {}; - EntryKey new_key = {}; - R_TRY(this->FindDirectoryRecursive(std::addressof(parent_key), std::addressof(parent_entry), std::addressof(new_key), path)); - - R_TRY(this->CheckSameEntryExists(new_key, fs::ResultDbmAlreadyExists())); - - RomDirectoryEntry new_entry = { - .next = InvalidPosition, - .dir = InvalidPosition, - .file = InvalidPosition, - }; - - Position new_pos = 0; - R_TRY_CATCH(this->dir_table.Add(std::addressof(new_pos), new_key, new_entry)) { - R_CONVERT(fs::ResultDbmKeyFull, fs::ResultDbmDirectoryEntryFull()) - } R_END_TRY_CATCH; - - *out = ConvertToDirectoryId(new_pos); - - if (parent_entry.dir == InvalidPosition) { - parent_entry.dir = new_pos; - - R_TRY(this->dir_table.SetByPosition(new_key.key.parent, parent_entry, fs::WriteOption::None)); - } else { - Position cur_pos = parent_entry.dir; - while (true) { - RomEntryKey cur_key = {}; - RomDirectoryEntry cur_entry = {}; - R_TRY(this->dir_table.GetByPosition(std::addressof(cur_key), std::addressof(cur_entry), nullptr, nullptr, cur_pos)); - - if (cur_entry.next == InvalidPosition) { - cur_entry.next = new_pos; - - R_TRY(this->dir_table.SetByPosition(cur_pos, cur_entry, fs::WriteOption::None)); - break; - } - - cur_pos = cur_entry.next; - } - } - - return ResultSuccess(); - } - - Result CreateFile(RomFileId *out, const RomPathChar *path, const FileInfo &info) { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(path != nullptr); - - EntryKey parent_key = {}; - RomDirectoryEntry parent_entry = {}; - EntryKey new_key = {}; - R_TRY(this->FindFileRecursive(std::addressof(parent_key), std::addressof(parent_entry), std::addressof(new_key), path)); - - R_TRY(this->CheckSameEntryExists(new_key, fs::ResultDbmAlreadyExists())); - - RomFileEntry new_entry = { - .next = InvalidPosition, - .info = info, - }; - - Position new_pos = 0; - R_TRY_CATCH(this->file_table.Add(std::addressof(new_pos), new_key, new_entry)) { - R_CONVERT(fs::ResultDbmKeyFull, fs::ResultDbmFileEntryFull()) - } R_END_TRY_CATCH; - - *out = ConvertToFileId(new_pos); - - if (parent_entry.file == InvalidPosition) { - parent_entry.file = new_pos; - - R_TRY(this->dir_table.SetByPosition(new_key.key.parent, parent_entry, fs::WriteOption::None)); - } else { - Position cur_pos = parent_entry.file; - while (true) { - RomEntryKey cur_key = {}; - RomFileEntry cur_entry = {}; - R_TRY(this->file_table.GetByPosition(std::addressof(cur_key), std::addressof(cur_entry), nullptr, nullptr, cur_pos)); - - if (cur_entry.next == InvalidPosition) { - cur_entry.next = new_pos; - - R_TRY(this->file_table.SetByPosition(cur_pos, cur_entry, fs::WriteOption::None)); - break; - } - - cur_pos = cur_entry.next; - } - } - - return ResultSuccess(); - } - - Result ConvertPathToDirectoryId(RomDirectoryId *out, const RomPathChar *path) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(path != nullptr); - - EntryKey parent_key = {}; - RomDirectoryEntry parent_entry = {}; - EntryKey key = {}; - R_TRY(this->FindDirectoryRecursive(std::addressof(parent_key), std::addressof(parent_entry), std::addressof(key), path)); - - Position pos = 0; - RomDirectoryEntry entry = {}; - R_TRY(this->GetDirectoryEntry(std::addressof(pos), std::addressof(entry), key)); - - *out = ConvertToDirectoryId(pos); - return ResultSuccess(); - } - - Result ConvertPathToFileId(RomFileId *out, const RomPathChar *path) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(path != nullptr); - - EntryKey parent_key = {}; - RomDirectoryEntry parent_entry = {}; - EntryKey key = {}; - R_TRY(this->FindDirectoryRecursive(std::addressof(parent_key), std::addressof(parent_entry), std::addressof(key), path)); - - Position pos = 0; - RomFileEntry entry = {}; - R_TRY(this->GetFileEntry(std::addressof(pos), std::addressof(entry), key)); - - *out = ConvertToFileId(pos); - return ResultSuccess(); - } - - Result GetDirectoryInformation(DirectoryInfo *out, const RomPathChar *path) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(path != nullptr); - - EntryKey parent_key = {}; - RomDirectoryEntry parent_entry = {}; - EntryKey key = {}; - R_TRY(this->FindDirectoryRecursive(std::addressof(parent_key), std::addressof(parent_entry), std::addressof(key), path)); - - return this->GetDirectoryInformation(out, key); - } - - Result GetDirectoryInformation(DirectoryInfo *out, RomDirectoryId id) const { - AMS_ASSERT(out != nullptr); - - RomDirectoryEntry entry = {}; - R_TRY(this->GetDirectoryEntry(std::addressof(entry), id)); - - return ResultSuccess(); - } - - Result OpenFile(FileInfo *out, const RomPathChar *path) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(path != nullptr); - - EntryKey parent_key = {}; - RomDirectoryEntry parent_entry = {}; - EntryKey key = {}; - R_TRY(this->FindFileRecursive(std::addressof(parent_key), std::addressof(parent_entry), std::addressof(key), path)); - - return this->OpenFile(out, key); - } - - Result OpenFile(FileInfo *out, RomFileId id) const { - AMS_ASSERT(out != nullptr); - - RomFileEntry entry = {}; - R_TRY(this->GetFileEntry(std::addressof(entry), id)); - - *out = entry.info; - return ResultSuccess(); - } - - Result FindOpen(FindPosition *out, const RomPathChar *path) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(path != nullptr); - - EntryKey parent_key = {}; - RomDirectoryEntry parent_entry = {}; - EntryKey key = {}; - R_TRY(this->FindDirectoryRecursive(std::addressof(parent_key), std::addressof(parent_entry), std::addressof(key), path)); - - return this->FindOpen(out, key); - } - - Result FindOpen(FindPosition *out, RomDirectoryId id) const { - AMS_ASSERT(out != nullptr); - - out->next_dir = InvalidPosition; - out->next_file = InvalidPosition; - - RomDirectoryEntry entry = {}; - R_TRY(this->GetDirectoryEntry(std::addressof(entry), id)); - - out->next_dir = entry.dir; - out->next_file = entry.file; - - return ResultSuccess(); - } - - Result FindNextDirectory(RomPathChar *out, FindPosition *find) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(find != nullptr); - - R_UNLESS(find->next_dir != InvalidPosition, fs::ResultDbmFindFinished()); - - RomEntryKey key = {}; - RomDirectoryEntry entry = {}; - size_t aux_size = 0; - R_TRY(this->dir_table.GetByPosition(std::addressof(key), std::addressof(entry), out, std::addressof(aux_size), find->next_dir)); - - out[aux_size / sizeof(RomPathChar)] = RomStringTraits::NullTerminator; - - find->next_dir = entry.next; - return ResultSuccess(); - } - - Result FindNextFile(RomPathChar *out, FindPosition *find) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(find != nullptr); - - R_UNLESS(find->next_file != InvalidPosition, fs::ResultDbmFindFinished()); - - RomEntryKey key = {}; - RomFileEntry entry = {}; - size_t aux_size = 0; - R_TRY(this->file_table.GetByPosition(std::addressof(key), std::addressof(entry), out, std::addressof(aux_size), find->next_file)); - - out[aux_size / sizeof(RomPathChar)] = RomStringTraits::NullTerminator; - - find->next_file = entry.next; - return ResultSuccess(); - } - - Result QueryRomFileSystemSize(u32 *out_dir_entry_size, u32 *out_file_entry_size) { - AMS_ASSERT(out_dir_entry_size != nullptr); - AMS_ASSERT(out_file_entry_size != nullptr); - - *out_dir_entry_size = this->dir_table.GetTotalEntrySize(); - *out_file_entry_size = this->file_table.GetTotalEntrySize(); - return ResultSuccess(); - } - private: - Result GetGrandParent(Position *out_pos, EntryKey *out_dir_key, RomDirectoryEntry *out_dir_entry, Position pos, RomPathTool::RomEntryName name, const RomPathChar *path) const { - AMS_ASSERT(out_pos != nullptr); - AMS_ASSERT(out_dir_key != nullptr); - AMS_ASSERT(out_dir_entry != nullptr); - - RomEntryKey gp_key = {}; - RomDirectoryEntry gp_entry = {}; - R_TRY(this->dir_table.GetByPosition(std::addressof(gp_key), std::addressof(gp_entry), nullptr, nullptr, pos)); - out_dir_key->key.parent = gp_key.parent; - - R_TRY(RomPathTool::GetParentDirectoryName(std::addressof(out_dir_key->name), name, path)); - - R_TRY(this->GetDirectoryEntry(out_pos, out_dir_entry, *out_dir_key)); - - return ResultSuccess(); - } - - Result FindParentDirectoryRecursive(Position *out_pos, EntryKey *out_dir_key, RomDirectoryEntry *out_dir_entry, RomPathTool::PathParser &parser, const RomPathChar *path) const { - AMS_ASSERT(out_pos != nullptr); - AMS_ASSERT(out_dir_key != nullptr); - AMS_ASSERT(out_dir_entry != nullptr); - - Position dir_pos = RootPosition; - EntryKey dir_key = {}; - RomDirectoryEntry dir_entry = {}; - dir_key.key.parent = RootPosition; - - R_TRY(parser.GetNextDirectoryName(std::addressof(dir_key.name))); - R_TRY(this->GetDirectoryEntry(std::addressof(dir_pos), std::addressof(dir_entry), dir_key)); - - Position parent_pos = dir_pos; - while (!parser.IsFinished()) { - EntryKey old_key = dir_key; - - R_TRY(parser.GetNextDirectoryName(std::addressof(dir_key.name))); - - if (RomPathTool::IsCurrentDirectory(dir_key.name)) { - dir_key = old_key; - continue; - } else if (RomPathTool::IsParentDirectory(dir_key.name)) { - R_UNLESS(parent_pos != RootPosition, fs::ResultDbmInvalidOperation()); - - R_TRY(this->GetGrandParent(std::addressof(parent_pos), std::addressof(dir_key), std::addressof(dir_entry), dir_key.key.parent, dir_key.name, path)); - } else { - dir_key.key.parent = parent_pos; - R_TRY(this->GetDirectoryEntry(std::addressof(dir_pos), std::addressof(dir_entry), dir_key)); - - parent_pos = dir_pos; - } - } - - *out_pos = parent_pos; - *out_dir_key = dir_key; - *out_dir_entry = dir_entry; - return ResultSuccess(); - } - - Result FindPathRecursive(EntryKey *out_parent_key, RomDirectoryEntry *out_parent_dir_entry, EntryKey *out_key, bool is_dir, const RomPathChar *path) const { - AMS_ASSERT(out_parent_key != nullptr); - AMS_ASSERT(out_parent_dir_entry != nullptr); - AMS_ASSERT(out_key != nullptr); - AMS_ASSERT(path != nullptr); - - RomPathTool::PathParser parser; - R_TRY(parser.Initialize(path)); - - Position parent_pos = 0; - R_TRY(this->FindParentDirectoryRecursive(std::addressof(parent_pos), out_parent_key, out_parent_dir_entry, parser, path)); - - if (is_dir) { - RomPathTool::RomEntryName name = {}; - R_TRY(parser.GetAsDirectoryName(std::addressof(name))); - - if (RomPathTool::IsCurrentDirectory(name)) { - *out_key = *out_parent_key; - if (out_key->key.parent != RootPosition) { - Position pos = 0; - R_TRY(this->GetGrandParent(std::addressof(pos), out_parent_key, out_parent_dir_entry, out_key->key.parent, out_key->name, path)); - } - } else if (RomPathTool::IsParentDirectory(name)) { - R_UNLESS(parent_pos != RootPosition, fs::ResultDbmInvalidOperation()); - - Position pos = 0; - RomDirectoryEntry cur_entry = {}; - R_TRY(this->GetGrandParent(std::addressof(pos), out_key, std::addressof(cur_entry), out_parent_key->key.parent, out_parent_key->name, path)); - - if (out_key->key.parent != RootPosition) { - R_TRY(this->GetGrandParent(std::addressof(pos), out_parent_key, out_parent_dir_entry, out_key->key.parent, out_key->name, path)); - } - } else { - out_key->name = name; - out_key->key.parent = (out_key->name.length > 0) ? parent_pos : RootPosition; - } - } else { - R_UNLESS(!parser.IsDirectoryPath(), fs::ResultDbmInvalidOperation()); - - out_key->key.parent = parent_pos; - R_TRY(parser.GetAsFileName(std::addressof(out_key->name))); - } - - return ResultSuccess(); - } - - Result FindDirectoryRecursive(EntryKey *out_parent_key, RomDirectoryEntry *out_parent_dir_entry, EntryKey *out_key, const RomPathChar *path) const { - return this->FindPathRecursive(out_parent_key, out_parent_dir_entry, out_key, true, path); - } - - Result FindFileRecursive(EntryKey *out_parent_key, RomDirectoryEntry *out_parent_dir_entry, EntryKey *out_key, const RomPathChar *path) const { - return this->FindPathRecursive(out_parent_key, out_parent_dir_entry, out_key, false, path); - } - - Result CheckSameEntryExists(const EntryKey &key, Result if_exists) const { - /* Check dir */ - { - Position pos = InvalidPosition; - RomDirectoryEntry entry = {}; - const Result get_res = this->dir_table.Get(std::addressof(pos), std::addressof(entry), key); - if (!fs::ResultDbmKeyNotFound::Includes(get_res)) { - R_TRY(get_res); - return if_exists; - } - } - - /* Check file */ - { - Position pos = InvalidPosition; - RomFileEntry entry = {}; - const Result get_res = this->file_table.Get(std::addressof(pos), std::addressof(entry), key); - if (!fs::ResultDbmKeyNotFound::Includes(get_res)) { - R_TRY(get_res); - return if_exists; - } - } - return ResultSuccess(); - } - - Result GetDirectoryEntry(Position *out_pos, RomDirectoryEntry *out_entry, const EntryKey &key) const { - AMS_ASSERT(out_pos != nullptr); - AMS_ASSERT(out_entry != nullptr); - - const Result dir_res = this->dir_table.Get(out_pos, out_entry, key); - R_UNLESS(R_FAILED(dir_res), dir_res); - R_UNLESS(fs::ResultDbmKeyNotFound::Includes(dir_res), dir_res); - - Position pos = 0; - RomFileEntry entry = {}; - const Result file_res = this->file_table.Get(std::addressof(pos), std::addressof(entry), key); - R_UNLESS(R_FAILED(file_res), fs::ResultDbmInvalidOperation()); - R_UNLESS(!fs::ResultDbmKeyNotFound::Includes(file_res), fs::ResultDbmDirectoryNotFound()); - return file_res; - } - - Result GetDirectoryEntry(RomDirectoryEntry *out_entry, RomDirectoryId id) const { - AMS_ASSERT(out_entry != nullptr); - Position pos = ConvertToPosition(id); - - RomEntryKey key = {}; - const Result dir_res = this->dir_table.GetByPosition(std::addressof(key), out_entry, nullptr, nullptr, pos); - R_UNLESS(R_FAILED(dir_res), dir_res); - R_UNLESS(fs::ResultDbmKeyNotFound::Includes(dir_res), dir_res); - - RomFileEntry entry = {}; - const Result file_res = this->file_table.GetByPosition(std::addressof(key), std::addressof(entry), nullptr, nullptr, pos); - R_UNLESS(R_FAILED(file_res), fs::ResultDbmInvalidOperation()); - R_UNLESS(!fs::ResultDbmKeyNotFound::Includes(file_res), fs::ResultDbmDirectoryNotFound()); - return file_res; - } - - Result GetFileEntry(Position *out_pos, RomFileEntry *out_entry, const EntryKey &key) const { - AMS_ASSERT(out_pos != nullptr); - AMS_ASSERT(out_entry != nullptr); - - const Result file_res = this->file_table.Get(out_pos, out_entry, key); - R_UNLESS(R_FAILED(file_res), file_res); - R_UNLESS(fs::ResultDbmKeyNotFound::Includes(file_res), file_res); - - Position pos = 0; - RomDirectoryEntry entry = {}; - const Result dir_res = this->dir_table.Get(std::addressof(pos), std::addressof(entry), key); - R_UNLESS(R_FAILED(dir_res), fs::ResultDbmInvalidOperation()); - R_UNLESS(!fs::ResultDbmKeyNotFound::Includes(dir_res), fs::ResultDbmFileNotFound()); - return dir_res; - } - - Result GetFileEntry(RomFileEntry *out_entry, RomFileId id) const { - AMS_ASSERT(out_entry != nullptr); - Position pos = ConvertToPosition(id); - - RomEntryKey key = {}; - const Result file_res = this->file_table.GetByPosition(std::addressof(key), out_entry, nullptr, nullptr, pos); - R_UNLESS(R_FAILED(file_res), file_res); - R_UNLESS(fs::ResultDbmKeyNotFound::Includes(file_res), file_res); - - RomDirectoryEntry entry = {}; - const Result dir_res = this->dir_table.GetByPosition(std::addressof(key), std::addressof(entry), nullptr, nullptr, pos); - R_UNLESS(R_FAILED(dir_res), fs::ResultDbmInvalidOperation()); - R_UNLESS(!fs::ResultDbmKeyNotFound::Includes(dir_res), fs::ResultDbmFileNotFound()); - return dir_res; - } - - Result GetDirectoryInformation(DirectoryInfo *out, const EntryKey &key) const { - AMS_ASSERT(out != nullptr); - - Position pos = 0; - RomDirectoryEntry entry = {}; - R_TRY(this->GetDirectoryEntry(std::addressof(pos), std::addressof(entry), key)); - - return ResultSuccess(); - } - - Result OpenFile(FileInfo *out, const EntryKey &key) const { - AMS_ASSERT(out != nullptr); - - Position pos = 0; - RomFileEntry entry = {}; - R_TRY(this->GetFileEntry(std::addressof(pos), std::addressof(entry), key)); - - *out = entry.info; - return ResultSuccess(); - } - - Result FindOpen(FindPosition *out, const EntryKey &key) const { - AMS_ASSERT(out != nullptr); - - out->next_dir = InvalidPosition; - out->next_file = InvalidPosition; - - Position pos = 0; - RomDirectoryEntry entry = {}; - R_TRY(this->GetDirectoryEntry(std::addressof(pos), std::addressof(entry), key)); - - out->next_dir = entry.dir; - out->next_file = entry.file; - - return ResultSuccess(); - } - }; - -} diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_rom_key_value_storage.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_rom_key_value_storage.hpp deleted file mode 100644 index 1bbea7a5c..000000000 --- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_rom_key_value_storage.hpp +++ /dev/null @@ -1,367 +0,0 @@ -/* - * Copyright (c) 2018-2020 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 . - */ -#pragma once -#include -#include - -namespace ams::fssystem { - - constexpr ALWAYS_INLINE u32 AlignRomAddress(u32 addr) { - return util::AlignUp(addr, sizeof(addr)); - } - - template - class RomKeyValueStorage { - public: - using BucketStorage = BucketStorageType; - using EntryStorage = EntryStorageType; - using Key = KeyType; - using Value = ValueType; - using Position = u32; - using BucketIndex = u32; - - struct FindIndex { - BucketIndex ind; - Position pos; - }; - static_assert(util::is_pod::value); - private: - static constexpr inline Position InvalidPosition = ~Position(); - - struct Element { - Key key; - Value value; - Position next; - u32 size; - }; - static_assert(util::is_pod::value); - private: - s64 bucket_offset; - u32 bucket_count; - BucketStorage *bucket_storage; - s64 kv_offset; - u32 kv_size; - EntryStorage *kv_storage; - u32 total_entry_size; - u32 entry_count; - public: - static constexpr u32 QueryEntrySize(u32 aux_size) { - return AlignRomAddress(sizeof(Element) + aux_size); - } - - static constexpr u32 QueryBucketStorageSize(u32 num) { - return num * sizeof(Position); - } - - static constexpr u32 QueryBucketCount(u32 size) { - return size / sizeof(Position); - } - - static constexpr u32 QueryKeyValueStorageSize(u32 num) { - return num * sizeof(Element); - } - - static Result Format(BucketStorage *bucket, s64 bucket_ofs, u32 bucket_count, EntryStorage *kv, s64 kv_ofs, u32 kv_size) { - AMS_ASSERT(bucket != nullptr); - AMS_ASSERT(kv != nullptr); - AMS_ASSERT(kv_size >= 0); - - const Position pos = InvalidPosition; - for (s64 i = 0; i < bucket_count; i++) { - R_TRY(bucket->Write(bucket_ofs + i * sizeof(pos), std::addressof(pos), sizeof(pos))); - } - return ResultSuccess(); - } - public: - RomKeyValueStorage() : bucket_offset(), bucket_count(), bucket_storage(), kv_offset(), kv_size(), kv_storage(), total_entry_size(), entry_count() { /* ... */ } - - Result Initialize(BucketStorage *bucket, s64 bucket_ofs, u32 bucket_count, EntryStorage *kv, s64 kv_ofs, u32 kv_size) { - AMS_ASSERT(bucket != nullptr); - AMS_ASSERT(kv != nullptr); - AMS_ASSERT(bucket_count > 0); - - this->bucket_storage = bucket; - this->bucket_offset = bucket_ofs; - this->bucket_count = bucket_count; - - this->kv_storage = kv; - this->kv_offset = kv_ofs; - this->kv_size = kv_size; - - return ResultSuccess(); - } - - void Finalize() { - this->bucket_storage = nullptr; - this->bucket_offset = 0; - this->bucket_count = 0; - - this->kv_storage = nullptr; - this->kv_offset = 0; - this->kv_size = 0; - } - - constexpr u32 GetTotalEntrySize() const { - return this->total_entry_size; - } - - constexpr u32 GetFreeSize() const { - return (this->kv_size - this->total_entry_size); - } - - constexpr u32 GetEntryCount() const { - return this->entry_count; - } - - Result Add(const Key &key, u32 hash_key, const void *aux, size_t aux_size, const Value &value) { - AMS_ASSERT(aux != nullptr); - AMS_ASSERT(aux_size <= MaxAuxiliarySize); - Position pos; - return this->AddImpl(std::addressof(pos), key, hash_key, aux, aux_size, value); - } - - Result Get(Value *out, const Key &key, u32 hash_key, const void *aux, size_t aux_size) { - AMS_ASSERT(aux != nullptr); - AMS_ASSERT(aux_size <= MaxAuxiliarySize); - Position pos; - return this->GetImpl(std::addressof(pos), out, key, hash_key, aux, aux_size); - } - - void FindOpen(FindIndex *out) const { - AMS_ASSERT(out != nullptr); - - out->ind = static_cast(-1); - out->pos = InvalidPosition; - } - - Result FindNext(Key *out_key, Value *out_val, FindIndex *find) { - AMS_ASSERT(out_key != nullptr); - AMS_ASSERT(out_val != nullptr); - AMS_ASSERT(find != nullptr); - - Element elem; - - BucketIndex ind = find->ind; - R_UNLESS((ind < this->bucket_count) || ind == static_cast(-1), fs::ResultDbmFindKeyFinished()); - - while (true) { - if (find->pos != InvalidPosition) { - R_TRY(this->ReadKeyValue(std::addressof(elem), nullptr, nullptr, find->pos)); - - AMS_ASSERT(elem.next == InvalidPosition || elem.next < this->kv_size); - find->pos = elem.next; - *out_key = elem.key; - *out_val = elem.val; - return ResultSuccess(); - } - - while (true) { - ind++; - if (ind == this->bucket_count) { - find->ind = ind; - find->pos = InvalidPosition; - return fs::ResultDbmFindKeyFinished(); - } - - Position pos; - R_TRY(this->ReadBucket(std::addressof(pos), ind)); - AMS_ASSERT(pos == InvalidPosition || pos < this->kv_size); - - if (pos != InvalidPosition) { - find->ind = ind; - find->pos = pos; - break; - } - } - } - } - protected: - Result AddImpl(Position *out, const Key &key, u32 hash_key, const void *aux, size_t aux_size, const Value &value) { - Position pos, prev_pos; - Element elem; - - AMS_ASSERT(out != nullptr); - AMS_ASSERT(this->bucket_count > 0); - AMS_ASSERT(this->kv_size >= 0); - - const Result find_res = this->FindImpl(std::addressof(pos), std::addressof(prev_pos), std::addressof(elem), key, hash_key, aux, aux_size); - R_UNLESS(R_FAILED(find_res), fs::ResultDbmAlreadyExists()); - R_UNLESS(fs::ResultDbmKeyNotFound::Includes(find_res), find_res); - - R_TRY(this->AllocateEntry(std::addressof(pos), aux_size)); - - Position next_pos; - R_TRY(this->LinkEntry(std::addressof(next_pos), pos, hash_key)); - - elem = { key, value, next_pos, static_cast(aux_size) }; - *out = pos; - R_TRY(this->WriteKeyValue(std::addressof(elem), pos, aux, aux_size, fs::WriteOption::None)); - - this->entry_count++; - - return ResultSuccess(); - } - - Result GetImpl(Position *out_pos, Value *out_val, const Key &key, u32 hash_key, const void *aux, size_t aux_size) const { - Position pos, prev_pos; - Element elem; - - AMS_ASSERT(out_pos != nullptr); - AMS_ASSERT(out_val != nullptr); - - R_TRY(this->FindImpl(std::addressof(pos), std::addressof(prev_pos), std::addressof(elem), key, hash_key, aux, aux_size)); - - *out_pos = pos; - *out_val = elem.value; - return ResultSuccess(); - } - - Result GetByPosition(Key *out_key, Value *out_val, void *out_aux, size_t *out_aux_size, Position pos) const { - AMS_ASSERT(out_key != nullptr); - AMS_ASSERT(out_val != nullptr); - - Element elem; - R_TRY(this->ReadKeyValue(std::addressof(elem), out_aux, out_aux_size, pos)); - - *out_key = elem.key; - *out_val = elem.value; - return ResultSuccess(); - } - - Result SetByPosition(Position pos, const Value &value, fs::WriteOption option) const { - Element elem; - R_TRY(this->ReadKeyValue(std::addressof(elem), nullptr, nullptr, pos)); - elem.value = value; - return this->WriteKeyValue(std::addressof(elem), pos, nullptr, 0, option); - } - private: - BucketIndex HashToBucket(u32 hash_key) const { - return hash_key % this->bucket_count; - } - - Result FindImpl(Position *out_pos, Position *out_prev, Element *out_elem, const Key &key, u32 hash_key, const void *aux, size_t aux_size) const { - AMS_ASSERT(out_pos != nullptr); - AMS_ASSERT(out_prev != nullptr); - AMS_ASSERT(out_elem != nullptr); - AMS_ASSERT(this->bucket_count > 0); - AMS_ASSERT(this->kv_size >= 0); - - *out_pos = 0; - *out_prev = 0; - - const BucketIndex ind = HashToBucket(hash_key); - - Position cur; - R_TRY(this->ReadBucket(std::addressof(cur), ind)); - AMS_ASSERT(cur == InvalidPosition || cur < this->kv_size); - - R_UNLESS(cur != InvalidPosition, fs::ResultDbmKeyNotFound()); - - u8 buf[MaxAuxiliarySize]; - - while (true) { - size_t cur_aux_size; - R_TRY(this->ReadKeyValue(out_elem, buf, std::addressof(cur_aux_size), cur)); - - if (key.IsEqual(out_elem->key, aux, aux_size, buf, cur_aux_size)) { - *out_pos = cur; - return ResultSuccess(); - } - - *out_prev = cur; - cur = out_elem->next; - R_UNLESS(cur != InvalidPosition, fs::ResultDbmKeyNotFound()); - } - } - - Result AllocateEntry(Position *out, size_t aux_size) { - AMS_ASSERT(out != nullptr); - - R_UNLESS(this->total_entry_size + sizeof(Element) + aux_size <= this->kv_size, fs::ResultDbmKeyFull()); - - *out = static_cast(this->total_entry_size); - - this->total_entry_size = AlignRomAddress(this->total_entry_size + sizeof(Element) + static_cast(aux_size)); - return ResultSuccess(); - } - - Result LinkEntry(Position *out, Position pos, u32 hash_key) { - AMS_ASSERT(out != nullptr); - - const BucketIndex ind = HashToBucket(hash_key); - - Position next; - R_TRY(this->ReadBucket(std::addressof(next), ind)); - AMS_ASSERT(next == InvalidPosition || next < this->kv_size); - - R_TRY(this->WriteBucket(pos, ind, fs::WriteOption::None)); - - *out = next; - return ResultSuccess(); - } - - Result ReadBucket(Position *out, BucketIndex ind) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(this->bucket_storage != nullptr); - AMS_ASSERT(ind < this->bucket_count); - - const s64 offset = this->bucket_offset + ind * sizeof(Position); - return this->bucket_storage->Read(offset, out, sizeof(*out)); - } - - Result WriteBucket(Position pos, BucketIndex ind, fs::WriteOption option) const { - AMS_ASSERT(this->bucket_storage != nullptr); - AMS_ASSERT(ind < this->bucket_count); - - const s64 offset = this->bucket_offset + ind * sizeof(Position); - return this->bucket_storage.Write(offset, std::addressof(pos), sizeof(pos)); - } - - Result ReadKeyValue(Element *out, void *out_aux, size_t *out_aux_size, Position pos) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(this->kv_storage != nullptr); - AMS_ASSERT(pos < this->kv_size); - - const s64 offset = this->kv_offset + pos; - R_TRY(this->kv_storage->Read(offset, out, sizeof(*out))); - - if (out_aux != nullptr && out_aux_size != nullptr) { - *out_aux_size = out->size; - if (out->size > 0) { - R_TRY(this->kv_storage->Read(offset + sizeof(*out), out_aux, out->size)); - } - } - - return ResultSuccess(); - } - - Result WriteKeyValue(const Element *elem, Position pos, const void *aux, size_t aux_size, fs::WriteOption option) const { - AMS_ASSERT(elem != nullptr); - AMS_ASSERT(this->kv_storage != nullptr); - AMS_ASSERT(pos < this->kv_size); - - const s64 offset = this->kv_offset + pos; - R_TRY(this->kv_storage->Write(offset, elem, sizeof(*elem))); - - if (aux != nullptr && aux_size > 0) { - R_TRY(this->kv_storage->Write(offset + sizeof(*elem), aux, aux_size)); - } - - return ResultSuccess(); - } - }; - -} diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_rom_path_tool.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_rom_path_tool.hpp deleted file mode 100644 index 6c40eac59..000000000 --- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_rom_path_tool.hpp +++ /dev/null @@ -1,114 +0,0 @@ -/* - * Copyright (c) 2018-2020 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 . - */ -#pragma once -#include - -namespace ams::fssystem { - - namespace RomPathTool { - - constexpr inline u32 MaxPathLength = 0x300; - - struct RomEntryName { - size_t length; - const RomPathChar *path; - }; - static_assert(util::is_pod::value); - - constexpr void InitializeRomEntryName(RomEntryName *entry) { - entry->length = 0; - } - - constexpr inline bool IsSeparator(RomPathChar c) { - return c == RomStringTraits::DirectorySeparator; - } - - constexpr inline bool IsNullTerminator(RomPathChar c) { - return c == RomStringTraits::NullTerminator; - } - - constexpr inline bool IsDot(RomPathChar c) { - return c == RomStringTraits::Dot; - } - - constexpr inline bool IsCurrentDirectory(const RomEntryName &name) { - return name.length == 1 && IsDot(name.path[0]); - } - - constexpr inline bool IsCurrentDirectory(const RomPathChar *p, size_t length) { - return length == 1 && IsDot(p[0]); - } - - constexpr inline bool IsCurrentDirectory(const RomPathChar *p) { - return IsDot(p[0]) && IsNullTerminator(p[1]); - } - - constexpr inline bool IsParentDirectory(const RomEntryName &name) { - return name.length == 2 && IsDot(name.path[0]) && IsDot(name.path[1]); - } - - constexpr inline bool IsParentDirectory(const RomPathChar *p) { - return IsDot(p[0]) && IsDot(p[1]) && IsNullTerminator(p[2]); - } - - constexpr inline bool IsParentDirectory(const RomPathChar *p, size_t length) { - return length == 2 && IsDot(p[0]) && IsDot(p[1]); - } - - constexpr inline bool IsEqualPath(const RomPathChar *lhs, const RomPathChar *rhs, size_t length) { - return std::strncmp(lhs, rhs, length) == 0; - } - - constexpr inline bool IsEqualName(const RomEntryName &lhs, const RomPathChar *rhs) { - if (strnlen(rhs, MaxPathLength) != lhs.length) { - return false; - } - return IsEqualPath(lhs.path, rhs, lhs.length); - } - - constexpr inline bool IsEqualName(const RomEntryName &lhs, const RomEntryName &rhs) { - if (lhs.length != rhs.length) { - return false; - } - return IsEqualPath(lhs.path, rhs.path, lhs.length); - } - - Result GetParentDirectoryName(RomEntryName *out, const RomEntryName &cur, const RomPathChar *p); - - class PathParser { - private: - const RomPathChar *prev_path_start; - const RomPathChar *prev_path_end; - const RomPathChar *next_path; - bool finished; - public: - constexpr PathParser() : prev_path_start(), prev_path_end(), next_path(), finished() { /* ... */ } - - Result Initialize(const RomPathChar *path); - void Finalize(); - - bool IsFinished() const; - bool IsDirectoryPath() const; - - Result GetAsDirectoryName(RomEntryName *out) const; - Result GetAsFileName(RomEntryName *out) const; - - Result GetNextDirectoryName(RomEntryName *out); - }; - - } - -} diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_rom_types.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_rom_types.hpp deleted file mode 100644 index 1baf32eb6..000000000 --- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_dbm_rom_types.hpp +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (c) 2018-2020 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 . - */ -#pragma once -#include - -namespace ams::fssystem { - - using RomPathChar = char; - using RomFileId = s32; - using RomDirectoryId = s32; - - struct RomFileSystemInformation { - s64 size; - s64 directory_bucket_offset; - s64 directory_bucket_size; - s64 directory_entry_offset; - s64 directory_entry_size; - s64 file_bucket_offset; - s64 file_bucket_size; - s64 file_entry_offset; - s64 file_entry_size; - s64 body_offset; - }; - static_assert(util::is_pod::value); - static_assert(sizeof(RomFileSystemInformation) == 0x50); - - struct RomDirectoryInfo { - /* ... */ - }; - static_assert(util::is_pod::value); - - struct RomFileInfo { - fs::Int64 offset; - fs::Int64 size; - }; - static_assert(util::is_pod::value); - - namespace RomStringTraits { - - constexpr inline char DirectorySeparator = '/'; - constexpr inline char NullTerminator = '\x00'; - constexpr inline char Dot = '.'; - - } - -} diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_romfs_file_system.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_romfs_file_system.hpp index 34dd76003..706775653 100644 --- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_romfs_file_system.hpp +++ b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_romfs_file_system.hpp @@ -17,7 +17,7 @@ #include #include #include -#include +#include #include namespace ams::fssystem { @@ -25,7 +25,7 @@ namespace ams::fssystem { class RomFsFileSystem : public fs::fsa::IFileSystem, public fs::impl::Newable { NON_COPYABLE(RomFsFileSystem); public: - using RomFileTable = HierarchicalRomFileTable; + using RomFileTable = fs::HierarchicalRomFileTable; private: RomFileTable rom_file_table; fs::IStorage *base_storage; diff --git a/libraries/libstratosphere/source/fs/fs_dbm_hierarchical_rom_file_table.cpp b/libraries/libstratosphere/source/fs/common/fs_dbm_hierarchical_rom_file_table.cpp similarity index 96% rename from libraries/libstratosphere/source/fs/fs_dbm_hierarchical_rom_file_table.cpp rename to libraries/libstratosphere/source/fs/common/fs_dbm_hierarchical_rom_file_table.cpp index 56d279b25..56803bcc5 100644 --- a/libraries/libstratosphere/source/fs/fs_dbm_hierarchical_rom_file_table.cpp +++ b/libraries/libstratosphere/source/fs/common/fs_dbm_hierarchical_rom_file_table.cpp @@ -17,23 +17,22 @@ namespace ams::fs { - s64 HierarchicalRomFileTable::QueryDirectoryEntryStorageSize(u32 count) { - const size_t real_count = count + ReservedDirectoryCount; - return DirectoryEntryMapTable::QueryKeyValueStorageSize(real_count) + real_count * (RomPathTool::MaxPathLength + 1) * sizeof(RomPathChar); - } - s64 HierarchicalRomFileTable::QueryDirectoryEntryBucketStorageSize(s64 count) { return DirectoryEntryMapTable::QueryBucketStorageSize(count); } - s64 HierarchicalRomFileTable::QueryFileEntryStorageSize(u32 count) { - return FileEntryMapTable::QueryKeyValueStorageSize(count) + count * (RomPathTool::MaxPathLength + 1) * sizeof(RomPathChar); + size_t HierarchicalRomFileTable::QueryDirectoryEntrySize(size_t aux_size) { + return DirectoryEntryMapTable::QueryEntrySize(aux_size); } s64 HierarchicalRomFileTable::QueryFileEntryBucketStorageSize(s64 count) { return FileEntryMapTable::QueryBucketStorageSize(count); } + size_t HierarchicalRomFileTable::QueryFileEntrySize(size_t aux_size) { + return FileEntryMapTable::QueryEntrySize(aux_size); + } + Result HierarchicalRomFileTable::Format(SubStorage dir_bucket, SubStorage file_bucket) { s64 dir_bucket_size; R_TRY(dir_bucket.GetSize(std::addressof(dir_bucket_size))); @@ -69,7 +68,7 @@ namespace ams::fs { Position root_pos = RootPosition; EntryKey root_key = {}; root_key.key.parent = root_pos; - RomPathTool::InitializeRomEntryName(std::addressof(root_key.name)); + RomPathTool::InitEntryName(std::addressof(root_key.name)); RomDirectoryEntry root_entry = { .next = InvalidPosition, .dir = InvalidPosition, @@ -99,7 +98,7 @@ namespace ams::fs { R_CONVERT(fs::ResultDbmKeyFull, fs::ResultDbmDirectoryEntryFull()) } R_END_TRY_CATCH; - *out = ConvertToDirectoryId(new_pos); + *out = PositionToDirectoryId(new_pos); if (parent_entry.dir == InvalidPosition) { parent_entry.dir = new_pos; @@ -146,7 +145,7 @@ namespace ams::fs { R_CONVERT(fs::ResultDbmKeyFull, fs::ResultDbmFileEntryFull()) } R_END_TRY_CATCH; - *out = ConvertToFileId(new_pos); + *out = PositionToFileId(new_pos); if (parent_entry.file == InvalidPosition) { parent_entry.file = new_pos; @@ -185,7 +184,7 @@ namespace ams::fs { RomDirectoryEntry entry = {}; R_TRY(this->GetDirectoryEntry(std::addressof(pos), std::addressof(entry), key)); - *out = ConvertToDirectoryId(pos); + *out = PositionToDirectoryId(pos); return ResultSuccess(); } @@ -201,7 +200,7 @@ namespace ams::fs { RomFileEntry entry = {}; R_TRY(this->GetFileEntry(std::addressof(pos), std::addressof(entry), key)); - *out = ConvertToFileId(pos); + *out = PositionToFileId(pos); return ResultSuccess(); } @@ -353,7 +352,7 @@ namespace ams::fs { R_TRY(this->GetDirectoryEntry(std::addressof(dir_pos), std::addressof(dir_entry), dir_key)); Position parent_pos = dir_pos; - while (!parser->IsFinished()) { + while (!parser->IsParseFinished()) { EntryKey old_key = dir_key; R_TRY(parser->GetNextDirectoryName(std::addressof(dir_key.name))); @@ -492,7 +491,7 @@ namespace ams::fs { Result HierarchicalRomFileTable::GetDirectoryEntry(RomDirectoryEntry *out_entry, RomDirectoryId id) { AMS_ASSERT(out_entry != nullptr); - Position pos = ConvertToPosition(id); + Position pos = DirectoryIdToPosition(id); RomEntryKey key = {}; const Result dir_res = this->dir_table.GetByPosition(std::addressof(key), out_entry, pos); @@ -524,7 +523,7 @@ namespace ams::fs { Result HierarchicalRomFileTable::GetFileEntry(RomFileEntry *out_entry, RomFileId id) { AMS_ASSERT(out_entry != nullptr); - Position pos = ConvertToPosition(id); + Position pos = FileIdToPosition(id); RomEntryKey key = {}; const Result file_res = this->file_table.GetByPosition(std::addressof(key), out_entry, pos); diff --git a/libraries/libstratosphere/source/fs/fs_dbm_rom_path_tool.cpp b/libraries/libstratosphere/source/fs/common/fs_dbm_rom_path_tool.cpp similarity index 88% rename from libraries/libstratosphere/source/fs/fs_dbm_rom_path_tool.cpp rename to libraries/libstratosphere/source/fs/common/fs_dbm_rom_path_tool.cpp index a5f10379c..9791368b7 100644 --- a/libraries/libstratosphere/source/fs/fs_dbm_rom_path_tool.cpp +++ b/libraries/libstratosphere/source/fs/common/fs_dbm_rom_path_tool.cpp @@ -28,9 +28,8 @@ namespace ams::fs::RomPathTool { this->prev_path_start = path; this->prev_path_end = path; - this->next_path = path + 1; - while (IsSeparator(this->next_path[0])) { - this->next_path++; + for (this->next_path = path + 1; IsSeparator(this->next_path[0]); ++this->next_path) { + /* ... */ } return ResultSuccess(); @@ -43,12 +42,13 @@ namespace ams::fs::RomPathTool { this->finished = false; } - bool PathParser::IsFinished() const { + bool PathParser::IsParseFinished() const { return this->finished; } bool PathParser::IsDirectoryPath() const { AMS_ASSERT(this->next_path != nullptr); + if (IsNullTerminator(this->next_path[0]) && IsSeparator(this->next_path[-1])) { return true; } @@ -57,11 +57,47 @@ namespace ams::fs::RomPathTool { return true; } - if (IsParentDirectory(this->next_path)) { - return true; + return IsParentDirectory(this->next_path); + } + + Result PathParser::GetNextDirectoryName(RomEntryName *out) { + AMS_ASSERT(out != nullptr); + AMS_ASSERT(this->prev_path_start != nullptr); + AMS_ASSERT(this->prev_path_end != nullptr); + AMS_ASSERT(this->next_path != nullptr); + + /* Set the current path to output. */ + out->length = this->prev_path_end - this->prev_path_start; + out->path = this->prev_path_start; + + /* Parse the next path. */ + this->prev_path_start = this->next_path; + const RomPathChar *cur = this->next_path; + for (size_t name_len = 0; true; name_len++) { + if (IsSeparator(cur[name_len])) { + R_UNLESS(name_len < MaxPathLength, fs::ResultDbmDirectoryNameTooLong()); + + this->prev_path_end = cur + name_len; + this->next_path = this->prev_path_end + 1; + + while (IsSeparator(this->next_path[0])) { + ++this->next_path; + } + if (IsNullTerminator(this->next_path[0])) { + this->finished = true; + } + break; + } + + if (IsNullTerminator(cur[name_len])) { + this->finished = true; + this->next_path = cur + name_len; + this->prev_path_end = cur + name_len; + break; + } } - return false; + return ResultSuccess(); } Result PathParser::GetAsDirectoryName(RomEntryName *out) const { @@ -92,45 +128,6 @@ namespace ams::fs::RomPathTool { return ResultSuccess(); } - Result PathParser::GetNextDirectoryName(RomEntryName *out) { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(this->prev_path_start != nullptr); - AMS_ASSERT(this->prev_path_end != nullptr); - AMS_ASSERT(this->next_path != nullptr); - - /* Set the current path to output. */ - out->length = this->prev_path_end - this->prev_path_start; - out->path = this->prev_path_start; - - /* Parse the next path. */ - this->prev_path_start = this->next_path; - const RomPathChar *cur = this->next_path; - for (size_t name_len = 0; true; name_len++) { - if (IsSeparator(cur[name_len])) { - R_UNLESS(name_len < MaxPathLength, fs::ResultDbmDirectoryNameTooLong()); - - this->prev_path_end = cur + name_len; - this->next_path = this->prev_path_end + 1; - - while (IsSeparator(this->next_path[0])) { - this->next_path++; - } - if (IsNullTerminator(this->next_path[0])) { - this->finished = true; - } - break; - } - - if (IsNullTerminator(cur[name_len])) { - this->finished = true; - this->prev_path_end = this->next_path = cur + name_len; - break; - } - } - - return ResultSuccess(); - } - Result GetParentDirectoryName(RomEntryName *out, const RomEntryName &cur, const RomPathChar *p) { AMS_ASSERT(out != nullptr); AMS_ASSERT(p != nullptr); @@ -140,7 +137,7 @@ namespace ams::fs::RomPathTool { s32 depth = 1; if (IsParentDirectory(cur)) { - depth++; + ++depth; } if (cur.path > p) { @@ -149,7 +146,7 @@ namespace ams::fs::RomPathTool { while (head >= p) { if (IsSeparator(*head)) { if (IsCurrentDirectory(head + 1, len)) { - depth++; + ++depth; } if (IsParentDirectory(head + 1, len)) { @@ -162,16 +159,16 @@ namespace ams::fs::RomPathTool { } while (IsSeparator(*head)) { - head--; + --head; } end = head; len = 0; - depth--; + --depth; } - len++; - head--; + ++len; + --head; } R_UNLESS(depth == 0, fs::ResultDirectoryUnobtainable()); @@ -182,10 +179,10 @@ namespace ams::fs::RomPathTool { } if (end <= p) { - out->path = p; + out->path = p; out->length = 0; } else { - out->path = start; + out->path = start; out->length = end - start + 1; } diff --git a/libraries/libstratosphere/source/fs/fs_romfs_filesystem.cpp b/libraries/libstratosphere/source/fs/fs_romfs_filesystem.cpp index ca6de5ba8..182fe3e0d 100644 --- a/libraries/libstratosphere/source/fs/fs_romfs_filesystem.cpp +++ b/libraries/libstratosphere/source/fs/fs_romfs_filesystem.cpp @@ -316,7 +316,7 @@ namespace ams::fs { out_entries[i].type = fs::DirectoryEntryType_File; RomFsFileSystem::RomFileTable::FileInfo file_info; - R_TRY(this->parent->GetRomFileTable()->OpenFile(std::addressof(file_info), this->parent->GetRomFileTable()->ConvertToFileId(file_pos))); + R_TRY(this->parent->GetRomFileTable()->OpenFile(std::addressof(file_info), this->parent->GetRomFileTable()->PositionToFileId(file_pos))); out_entries[i].file_size = file_info.size.Get(); } diff --git a/libraries/libstratosphere/source/fssystem/fssystem_dbm_rom_path_tool.cpp b/libraries/libstratosphere/source/fssystem/fssystem_dbm_rom_path_tool.cpp deleted file mode 100644 index 6d4e6e1e5..000000000 --- a/libraries/libstratosphere/source/fssystem/fssystem_dbm_rom_path_tool.cpp +++ /dev/null @@ -1,189 +0,0 @@ -/* - * Copyright (c) 2018-2020 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 . - */ -#include - -namespace ams::fssystem::RomPathTool { - - Result PathParser::Initialize(const RomPathChar *path) { - AMS_ASSERT(path != nullptr); - - /* Require paths start with a separator, and skip repeated separators. */ - R_UNLESS(IsSeparator(path[0]), fs::ResultDbmInvalidPathFormat()); - while (IsSeparator(path[1])) { - path++; - } - - this->prev_path_start = path; - this->prev_path_end = path; - this->next_path = path + 1; - while (IsSeparator(this->next_path[0])) { - this->next_path++; - } - - return ResultSuccess(); - } - - void PathParser::Finalize() { - /* ... */ - } - - bool PathParser::IsFinished() const { - return this->finished; - } - - bool PathParser::IsDirectoryPath() const { - AMS_ASSERT(this->next_path != nullptr); - if (IsNullTerminator(this->next_path[0]) && IsSeparator(this->next_path[-1])) { - return true; - } - - if (IsCurrentDirectory(this->next_path)) { - return true; - } - - if (IsParentDirectory(this->next_path)) { - return true; - } - - return false; - } - - Result PathParser::GetAsDirectoryName(RomEntryName *out) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(this->prev_path_start != nullptr); - AMS_ASSERT(this->prev_path_end != nullptr); - AMS_ASSERT(this->next_path != nullptr); - - const size_t len = this->prev_path_end - this->prev_path_start; - R_UNLESS(len <= MaxPathLength, fs::ResultDbmDirectoryNameTooLong()); - - out->length = len; - out->path = this->prev_path_start; - return ResultSuccess(); - } - - Result PathParser::GetAsFileName(RomEntryName *out) const { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(this->prev_path_start != nullptr); - AMS_ASSERT(this->prev_path_end != nullptr); - AMS_ASSERT(this->next_path != nullptr); - - const size_t len = this->prev_path_end - this->prev_path_start; - R_UNLESS(len <= MaxPathLength, fs::ResultDbmFileNameTooLong()); - - out->length = len; - out->path = this->prev_path_start; - return ResultSuccess(); - } - - Result PathParser::GetNextDirectoryName(RomEntryName *out) { - AMS_ASSERT(out != nullptr); - AMS_ASSERT(this->prev_path_start != nullptr); - AMS_ASSERT(this->prev_path_end != nullptr); - AMS_ASSERT(this->next_path != nullptr); - - /* Set the current path to output. */ - out->length = this->prev_path_end - this->prev_path_start; - out->path = this->prev_path_start; - - /* Parse the next path. */ - this->prev_path_start = this->next_path; - const RomPathChar *cur = this->next_path; - for (size_t name_len = 0; true; name_len++) { - if (IsSeparator(cur[name_len])) { - R_UNLESS(name_len < MaxPathLength, fs::ResultDbmDirectoryNameTooLong()); - - this->prev_path_end = cur + name_len; - this->next_path = this->prev_path_end + 1; - - while (IsSeparator(this->next_path[0])) { - this->next_path++; - } - if (IsNullTerminator(this->next_path[0])) { - this->finished = true; - } - break; - } - - if (IsNullTerminator(cur[name_len])) { - this->finished = true; - this->prev_path_end = this->next_path = cur + name_len; - break; - } - } - - return ResultSuccess(); - } - - Result GetParentDirectoryName(RomEntryName *out, const RomEntryName &cur, const RomPathChar *p) { - const RomPathChar *start = cur.path; - const RomPathChar *end = cur.path + cur.length - 1; - - s32 depth = 1; - if (IsParentDirectory(cur)) { - depth++; - } - - if (cur.path > p) { - size_t len = 0; - const RomPathChar *head = cur.path - 1; - while (head >= p) { - if (IsSeparator(*head)) { - if (IsCurrentDirectory(head + 1, len)) { - depth++; - } - - if (IsParentDirectory(head + 1, len)) { - depth += 2; - } - - if (depth == 0) { - start = head + 1; - break; - } - - while (IsSeparator(*head)) { - head--; - } - - end = head; - len = 0; - depth--; - } - - len++; - head--; - } - - R_UNLESS(depth == 0, fs::ResultDbmInvalidPathFormat()); - - if (head == p) { - start = p + 1; - } - } - - if (end <= p) { - out->path = p; - out->length = 0; - } else { - out->path = start; - out->length = end - start + 1; - } - - return ResultSuccess(); - } - -} diff --git a/libraries/libstratosphere/source/fssystem/fssystem_romfs_filesystem.cpp b/libraries/libstratosphere/source/fssystem/fssystem_romfs_filesystem.cpp index 009c51d06..d736962ee 100644 --- a/libraries/libstratosphere/source/fssystem/fssystem_romfs_filesystem.cpp +++ b/libraries/libstratosphere/source/fssystem/fssystem_romfs_filesystem.cpp @@ -19,7 +19,7 @@ namespace ams::fssystem { namespace { - constexpr size_t CalculateRequiredWorkingMemorySize(const RomFileSystemInformation &header) { + constexpr size_t CalculateRequiredWorkingMemorySize(const fs::RomFileSystemInformation &header) { return header.directory_bucket_size + header.directory_entry_size + header.file_bucket_size + header.file_entry_size; } @@ -114,7 +114,7 @@ namespace ams::fssystem { public: virtual Result ReadImpl(s64 *out_count, fs::DirectoryEntry *out_entries, s64 max_entries) { R_TRY(buffers::DoContinuouslyUntilBufferIsAllocated([=, this]() -> Result { - return this->ReadImpl(out_count, std::addressof(this->current_find), out_entries, max_entries); + return this->ReadInternal(out_count, std::addressof(this->current_find), out_entries, max_entries); }, AMS_CURRENT_FUNCTION_NAME)); return ResultSuccess(); } @@ -123,20 +123,20 @@ namespace ams::fssystem { FindPosition find = this->first_find; R_TRY(buffers::DoContinuouslyUntilBufferIsAllocated([&]() -> Result { - R_TRY(this->ReadImpl(out, std::addressof(find), nullptr, 0)); + R_TRY(this->ReadInternal(out, std::addressof(find), nullptr, 0)); return ResultSuccess(); }, AMS_CURRENT_FUNCTION_NAME)); return ResultSuccess(); } private: - Result ReadImpl(s64 *out_count, FindPosition *find, fs::DirectoryEntry *out_entries, s64 max_entries) { + Result ReadInternal(s64 *out_count, FindPosition *find, fs::DirectoryEntry *out_entries, s64 max_entries) { constexpr size_t NameBufferSize = fs::EntryNameLengthMax + 1; - RomPathChar name[NameBufferSize]; + fs::RomPathChar name[NameBufferSize]; s32 i = 0; if (this->mode & fs::OpenDirectoryMode_Directory) { while (i < max_entries || out_entries == nullptr) { - R_TRY_CATCH(this->parent->GetRomFileTable()->FindNextDirectory(name, find)) { + R_TRY_CATCH(this->parent->GetRomFileTable()->FindNextDirectory(name, find, NameBufferSize)) { R_CATCH(fs::ResultDbmFindFinished) { break; } } R_END_TRY_CATCH; @@ -156,7 +156,7 @@ namespace ams::fssystem { while (i < max_entries || out_entries == nullptr) { auto file_pos = find->next_file; - R_TRY_CATCH(this->parent->GetRomFileTable()->FindNextFile(name, find)) { + R_TRY_CATCH(this->parent->GetRomFileTable()->FindNextFile(name, find, NameBufferSize)) { R_CATCH(fs::ResultDbmFindFinished) { break; } } R_END_TRY_CATCH; @@ -167,7 +167,7 @@ namespace ams::fssystem { out_entries[i].type = fs::DirectoryEntryType_File; RomFsFileSystem::RomFileTable::FileInfo file_info; - R_TRY(this->parent->GetRomFileTable()->OpenFile(std::addressof(file_info), this->parent->GetRomFileTable()->ConvertToFileId(file_pos))); + R_TRY(this->parent->GetRomFileTable()->OpenFile(std::addressof(file_info), this->parent->GetRomFileTable()->PositionToFileId(file_pos))); out_entries[i].file_size = file_info.size.Get(); } @@ -204,7 +204,7 @@ namespace ams::fssystem { } Result RomFsFileSystem::GetRequiredWorkingMemorySize(size_t *out, fs::IStorage *storage) { - RomFileSystemInformation header; + fs::RomFileSystemInformation header; R_TRY(buffers::DoContinuouslyUntilBufferIsAllocated([&]() -> Result { R_TRY(storage->Read(0, std::addressof(header), sizeof(header))); @@ -224,7 +224,7 @@ namespace ams::fssystem { buffers::EnableBlockingBufferManagerAllocation(); /* Read the header. */ - RomFileSystemInformation header; + fs::RomFileSystemInformation header; R_TRY(base->Read(0, std::addressof(header), sizeof(header))); /* Set up our storages. */ @@ -261,10 +261,10 @@ namespace ams::fssystem { R_UNLESS(this->file_entry_storage != nullptr, fs::ResultAllocationFailureInRomFsFileSystemB()); /* Initialize the rom table. */ - R_TRY(this->rom_file_table.Initialize(this->dir_bucket_storage.get(), 0, static_cast(header.directory_bucket_size), - this->dir_entry_storage.get(), 0, static_cast(header.directory_entry_size), - this->file_bucket_storage.get(), 0, static_cast(header.file_bucket_size), - this->file_entry_storage.get(), 0, static_cast(header.file_entry_size))); + R_TRY(this->rom_file_table.Initialize(fs::SubStorage(this->dir_bucket_storage.get(), 0, static_cast(header.directory_bucket_size)), + fs::SubStorage(this->dir_entry_storage.get(), 0, static_cast(header.directory_entry_size)), + fs::SubStorage(this->file_bucket_storage.get(), 0, static_cast(header.file_bucket_size)), + fs::SubStorage(this->file_entry_storage.get(), 0, static_cast(header.file_entry_size)))); /* Set members. */ this->entry_size = header.body_offset; @@ -326,7 +326,7 @@ namespace ams::fssystem { Result RomFsFileSystem::GetEntryTypeImpl(fs::DirectoryEntryType *out, const char *path) { R_TRY(buffers::DoContinuouslyUntilBufferIsAllocated([=, this]() -> Result { - RomDirectoryInfo dir_info; + fs::RomDirectoryInfo dir_info; R_TRY_CATCH(this->rom_file_table.GetDirectoryInformation(std::addressof(dir_info), path)) { R_CONVERT(fs::ResultDbmNotFound, fs::ResultPathNotFound())