mirror of
https://github.com/Atmosphere-NX/Atmosphere-libs.git
synced 2025-11-04 13:21:17 +01:00
356 lines
14 KiB
C++
356 lines
14 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/>.
|
|
*/
|
|
#pragma once
|
|
#include <vapours.hpp>
|
|
#include <stratosphere/fs/fs_substorage.hpp>
|
|
|
|
namespace ams::fssystem {
|
|
|
|
/* ACCURATE_TO_VERSION: Unknown */
|
|
class BucketTree {
|
|
NON_COPYABLE(BucketTree);
|
|
NON_MOVEABLE(BucketTree);
|
|
public:
|
|
static constexpr u32 Magic = util::FourCC<'B','K','T','R'>::Code;
|
|
static constexpr u32 Version = 1;
|
|
|
|
static constexpr size_t NodeSizeMin = 1_KB;
|
|
static constexpr size_t NodeSizeMax = 512_KB;
|
|
public:
|
|
class Visitor;
|
|
|
|
struct Header {
|
|
u32 magic;
|
|
u32 version;
|
|
s32 entry_count;
|
|
s32 reserved;
|
|
|
|
void Format(s32 entry_count);
|
|
Result Verify() const;
|
|
};
|
|
static_assert(util::is_pod<Header>::value);
|
|
static_assert(sizeof(Header) == 0x10);
|
|
|
|
struct NodeHeader {
|
|
s32 index;
|
|
s32 count;
|
|
s64 offset;
|
|
|
|
Result Verify(s32 node_index, size_t node_size, size_t entry_size) const;
|
|
};
|
|
static_assert(util::is_pod<NodeHeader>::value);
|
|
static_assert(sizeof(NodeHeader) == 0x10);
|
|
|
|
struct Offsets {
|
|
s64 start_offset;
|
|
s64 end_offset;
|
|
|
|
constexpr bool IsInclude(s64 offset) const {
|
|
return this->start_offset <= offset && offset < this->end_offset;
|
|
}
|
|
|
|
constexpr bool IsInclude(s64 offset, s64 size) const {
|
|
return size > 0 && this->start_offset <= offset && size <= (this->end_offset - offset);
|
|
}
|
|
};
|
|
static_assert(util::is_pod<Offsets>::value);
|
|
static_assert(sizeof(Offsets) == 0x10);
|
|
|
|
struct OffsetCache {
|
|
Offsets offsets;
|
|
os::SdkMutex mutex;
|
|
bool is_initialized;
|
|
|
|
constexpr OffsetCache() : offsets{ -1, -1 }, mutex(), is_initialized(false) { /* ... */ }
|
|
};
|
|
|
|
class ContinuousReadingInfo {
|
|
private:
|
|
size_t m_read_size;
|
|
s32 m_skip_count;
|
|
bool m_done;
|
|
public:
|
|
constexpr ContinuousReadingInfo() : m_read_size(), m_skip_count(), m_done() { /* ... */ }
|
|
|
|
constexpr void Reset() { m_read_size = 0; m_skip_count = 0; m_done = false; }
|
|
|
|
constexpr void SetSkipCount(s32 count) { AMS_ASSERT(count >= 0); m_skip_count = count; }
|
|
constexpr s32 GetSkipCount() const { return m_skip_count; }
|
|
constexpr bool CheckNeedScan() { return (--m_skip_count) <= 0; }
|
|
|
|
constexpr void Done() { m_read_size = 0; m_done = true; }
|
|
constexpr bool IsDone() const { return m_done; }
|
|
|
|
constexpr void SetReadSize(size_t size) { m_read_size = size; }
|
|
constexpr size_t GetReadSize() const { return m_read_size; }
|
|
constexpr bool CanDo() const { return m_read_size > 0; }
|
|
};
|
|
|
|
using IAllocator = MemoryResource;
|
|
private:
|
|
class NodeBuffer {
|
|
NON_COPYABLE(NodeBuffer);
|
|
private:
|
|
IAllocator *m_allocator;
|
|
void *m_header;
|
|
public:
|
|
NodeBuffer() : m_allocator(), m_header() { /* ... */ }
|
|
|
|
~NodeBuffer() {
|
|
AMS_ASSERT(m_header == nullptr);
|
|
}
|
|
|
|
NodeBuffer(NodeBuffer &&rhs) : m_allocator(rhs.m_allocator), m_header(rhs.m_header) {
|
|
rhs.m_allocator = nullptr;
|
|
rhs.m_header = nullptr;
|
|
}
|
|
|
|
NodeBuffer &operator=(NodeBuffer &&rhs) {
|
|
if (this != std::addressof(rhs)) {
|
|
AMS_ASSERT(m_header == nullptr);
|
|
|
|
m_allocator = rhs.m_allocator;
|
|
m_header = rhs.m_header;
|
|
|
|
rhs.m_allocator = nullptr;
|
|
rhs.m_header = nullptr;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
bool Allocate(IAllocator *allocator, size_t node_size) {
|
|
AMS_ASSERT(m_header == nullptr);
|
|
|
|
m_allocator = allocator;
|
|
m_header = allocator->Allocate(node_size, sizeof(s64));
|
|
|
|
AMS_ASSERT(util::IsAligned(m_header, sizeof(s64)));
|
|
|
|
return m_header != nullptr;
|
|
}
|
|
|
|
void Free(size_t node_size) {
|
|
if (m_header) {
|
|
m_allocator->Deallocate(m_header, node_size);
|
|
m_header = nullptr;
|
|
}
|
|
m_allocator = nullptr;
|
|
}
|
|
|
|
void FillZero(size_t node_size) const {
|
|
if (m_header) {
|
|
std::memset(m_header, 0, node_size);
|
|
}
|
|
}
|
|
|
|
NodeHeader *Get() const {
|
|
return reinterpret_cast<NodeHeader *>(m_header);
|
|
}
|
|
|
|
NodeHeader *operator->() const { return this->Get(); }
|
|
|
|
template<typename T>
|
|
T *Get() const {
|
|
static_assert(util::is_pod<T>::value);
|
|
static_assert(sizeof(T) == sizeof(NodeHeader));
|
|
return reinterpret_cast<T *>(m_header);
|
|
}
|
|
|
|
IAllocator *GetAllocator() const {
|
|
return m_allocator;
|
|
}
|
|
};
|
|
private:
|
|
static constexpr s32 GetEntryCount(size_t node_size, size_t entry_size) {
|
|
return static_cast<s32>((node_size - sizeof(NodeHeader)) / entry_size);
|
|
}
|
|
|
|
static constexpr s32 GetOffsetCount(size_t node_size) {
|
|
return static_cast<s32>((node_size - sizeof(NodeHeader)) / sizeof(s64));
|
|
}
|
|
|
|
static constexpr s32 GetEntrySetCount(size_t node_size, size_t entry_size, s32 entry_count) {
|
|
const s32 entry_count_per_node = GetEntryCount(node_size, entry_size);
|
|
return util::DivideUp(entry_count, entry_count_per_node);
|
|
}
|
|
|
|
static constexpr s32 GetNodeL2Count(size_t node_size, size_t entry_size, s32 entry_count) {
|
|
const s32 offset_count_per_node = GetOffsetCount(node_size);
|
|
const s32 entry_set_count = GetEntrySetCount(node_size, entry_size, entry_count);
|
|
|
|
if (entry_set_count <= offset_count_per_node) {
|
|
return 0;
|
|
}
|
|
|
|
const s32 node_l2_count = util::DivideUp(entry_set_count, offset_count_per_node);
|
|
AMS_ABORT_UNLESS(node_l2_count <= offset_count_per_node);
|
|
|
|
return util::DivideUp(entry_set_count - (offset_count_per_node - (node_l2_count - 1)), offset_count_per_node);
|
|
}
|
|
public:
|
|
static constexpr s64 QueryHeaderStorageSize() { return sizeof(Header); }
|
|
|
|
static constexpr s64 QueryNodeStorageSize(size_t node_size, size_t entry_size, s32 entry_count) {
|
|
AMS_ASSERT(entry_size >= sizeof(s64));
|
|
AMS_ASSERT(node_size >= entry_size + sizeof(NodeHeader));
|
|
AMS_ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax);
|
|
AMS_ASSERT(util::IsPowerOfTwo(node_size));
|
|
AMS_ASSERT(entry_count >= 0);
|
|
|
|
if (entry_count <= 0) {
|
|
return 0;
|
|
}
|
|
return (1 + GetNodeL2Count(node_size, entry_size, entry_count)) * static_cast<s64>(node_size);
|
|
}
|
|
|
|
static constexpr s64 QueryEntryStorageSize(size_t node_size, size_t entry_size, s32 entry_count) {
|
|
AMS_ASSERT(entry_size >= sizeof(s64));
|
|
AMS_ASSERT(node_size >= entry_size + sizeof(NodeHeader));
|
|
AMS_ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax);
|
|
AMS_ASSERT(util::IsPowerOfTwo(node_size));
|
|
AMS_ASSERT(entry_count >= 0);
|
|
|
|
if (entry_count <= 0) {
|
|
return 0;
|
|
}
|
|
return GetEntrySetCount(node_size, entry_size, entry_count) * static_cast<s64>(node_size);
|
|
}
|
|
private:
|
|
mutable fs::SubStorage m_node_storage;
|
|
mutable fs::SubStorage m_entry_storage;
|
|
NodeBuffer m_node_l1;
|
|
size_t m_node_size;
|
|
size_t m_entry_size;
|
|
s32 m_entry_count;
|
|
s32 m_offset_count;
|
|
s32 m_entry_set_count;
|
|
OffsetCache m_offset_cache;
|
|
public:
|
|
BucketTree() : m_node_storage(), m_entry_storage(), m_node_l1(), m_node_size(), m_entry_size(), m_entry_count(), m_offset_count(), m_entry_set_count(), m_offset_cache() { /* ... */ }
|
|
~BucketTree() { this->Finalize(); }
|
|
|
|
Result Initialize(IAllocator *allocator, fs::SubStorage node_storage, fs::SubStorage entry_storage, size_t node_size, size_t entry_size, s32 entry_count);
|
|
void Initialize(size_t node_size, s64 end_offset);
|
|
void Finalize();
|
|
|
|
bool IsInitialized() const { return m_node_size > 0; }
|
|
bool IsEmpty() const { return m_entry_size == 0; }
|
|
|
|
Result Find(Visitor *visitor, s64 virtual_address);
|
|
Result InvalidateCache();
|
|
|
|
s32 GetEntryCount() const { return m_entry_count; }
|
|
IAllocator *GetAllocator() const { return m_node_l1.GetAllocator(); }
|
|
|
|
Result GetOffsets(Offsets *out) {
|
|
/* Ensure we have an offset cache. */
|
|
R_TRY(this->EnsureOffsetCache());
|
|
|
|
/* Set the output. */
|
|
*out = m_offset_cache.offsets;
|
|
R_SUCCEED();
|
|
}
|
|
private:
|
|
template<typename EntryType>
|
|
struct ContinuousReadingParam {
|
|
s64 offset;
|
|
size_t size;
|
|
NodeHeader entry_set;
|
|
s32 entry_index;
|
|
Offsets offsets;
|
|
EntryType entry;
|
|
};
|
|
private:
|
|
template<typename EntryType>
|
|
Result ScanContinuousReading(ContinuousReadingInfo *out_info, const ContinuousReadingParam<EntryType> ¶m) const;
|
|
|
|
bool IsExistL2() const { return m_offset_count < m_entry_set_count; }
|
|
bool IsExistOffsetL2OnL1() const { return this->IsExistL2() && m_node_l1->count < m_offset_count; }
|
|
|
|
s64 GetEntrySetIndex(s32 node_index, s32 offset_index) const {
|
|
return (m_offset_count - m_node_l1->count) + (m_offset_count * node_index) + offset_index;
|
|
}
|
|
|
|
Result EnsureOffsetCache();
|
|
};
|
|
|
|
/* ACCURATE_TO_VERSION: Unknown */
|
|
class BucketTree::Visitor {
|
|
NON_COPYABLE(Visitor);
|
|
NON_MOVEABLE(Visitor);
|
|
private:
|
|
friend class BucketTree;
|
|
|
|
union EntrySetHeader {
|
|
NodeHeader header;
|
|
struct Info {
|
|
s32 index;
|
|
s32 count;
|
|
s64 end;
|
|
s64 start;
|
|
} info;
|
|
static_assert(util::is_pod<Info>::value);
|
|
};
|
|
static_assert(util::is_pod<EntrySetHeader>::value);
|
|
private:
|
|
const BucketTree *m_tree;
|
|
BucketTree::Offsets m_offsets;
|
|
void *m_entry;
|
|
s32 m_entry_index;
|
|
s32 m_entry_set_count;
|
|
EntrySetHeader m_entry_set;
|
|
public:
|
|
constexpr Visitor() : m_tree(), m_entry(), m_entry_index(-1), m_entry_set_count(), m_entry_set{} { /* ... */ }
|
|
~Visitor() {
|
|
if (m_entry != nullptr) {
|
|
m_tree->GetAllocator()->Deallocate(m_entry, m_tree->m_entry_size);
|
|
m_tree = nullptr;
|
|
m_entry = nullptr;
|
|
}
|
|
}
|
|
|
|
bool IsValid() const { return m_entry_index >= 0; }
|
|
bool CanMoveNext() const { return this->IsValid() && (m_entry_index + 1 < m_entry_set.info.count || m_entry_set.info.index + 1 < m_entry_set_count); }
|
|
bool CanMovePrevious() const { return this->IsValid() && (m_entry_index > 0 || m_entry_set.info.index > 0); }
|
|
|
|
Result MoveNext();
|
|
Result MovePrevious();
|
|
|
|
template<typename EntryType>
|
|
Result ScanContinuousReading(ContinuousReadingInfo *out_info, s64 offset, size_t size) const;
|
|
|
|
const void *Get() const { AMS_ASSERT(this->IsValid()); return m_entry; }
|
|
|
|
template<typename T>
|
|
const T *Get() const { AMS_ASSERT(this->IsValid()); return reinterpret_cast<const T *>(m_entry); }
|
|
|
|
const BucketTree *GetTree() const { return m_tree; }
|
|
private:
|
|
Result Initialize(const BucketTree *tree, const BucketTree::Offsets &offsets);
|
|
|
|
Result Find(s64 virtual_address);
|
|
|
|
Result FindEntrySet(s32 *out_index, s64 virtual_address, s32 node_index);
|
|
Result FindEntrySetWithBuffer(s32 *out_index, s64 virtual_address, s32 node_index, char *buffer);
|
|
Result FindEntrySetWithoutBuffer(s32 *out_index, s64 virtual_address, s32 node_index);
|
|
|
|
Result FindEntry(s64 virtual_address, s32 entry_set_index);
|
|
Result FindEntryWithBuffer(s64 virtual_address, s32 entry_set_index, char *buffer);
|
|
Result FindEntryWithoutBuffer(s64 virtual_address, s32 entry_set_index);
|
|
};
|
|
|
|
}
|