From 50eee9b2185c59c32fb82cf464230a058edd10ea Mon Sep 17 00:00:00 2001 From: Liam Date: Sat, 12 Aug 2023 15:18:55 -0400 Subject: [PATCH] fssystem: rework for yuzu style --- src/common/alignment.h | 8 +- src/common/lz4_compression.cpp | 2 +- src/common/lz4_compression.h | 2 +- src/core/file_sys/card_image.cpp | 4 +- src/core/file_sys/content_archive.cpp | 9 +- ...ystem_aes_ctr_counter_extended_storage.cpp | 3 +- ...ssystem_aes_ctr_counter_extended_storage.h | 16 +- .../fssystem/fssystem_aes_ctr_storage.h | 12 +- .../fssystem/fssystem_aes_xts_storage.h | 16 +- .../fssystem_alignment_matching_storage.h | 8 +- .../fssystem/fssystem_bucket_tree.cpp | 4 +- .../file_sys/fssystem/fssystem_bucket_tree.h | 151 +++++++++--------- .../fssystem/fssystem_compressed_storage.h | 39 ++--- .../fssystem_compression_configuration.cpp | 14 +- .../fssystem_compression_configuration.h | 2 +- .../fssystem_crypto_configuration.cpp | 8 + ...rarchical_integrity_verification_storage.h | 46 +++--- .../fssystem_hierarchical_sha256_storage.h | 18 +-- .../fssystem/fssystem_indirect_storage.cpp | 3 +- .../fssystem/fssystem_indirect_storage.h | 88 +++++----- .../fssystem_integrity_romfs_storage.h | 10 +- ...ssystem_integrity_verification_storage.cpp | 2 +- .../fssystem_integrity_verification_storage.h | 20 +-- ...stem_memory_resource_buffer_hold_storage.h | 13 +- .../fssystem_nca_file_system_driver.cpp | 2 +- .../fssystem_nca_file_system_driver.h | 54 ++++--- .../file_sys/fssystem/fssystem_nca_reader.cpp | 57 +++---- .../fssystem/fssystem_pooled_buffer.h | 41 +++-- .../fssystem/fssystem_sparse_storage.cpp | 1 - .../fssystem/fssystem_sparse_storage.h | 7 +- .../fssystem/fssystem_switch_storage.h | 10 +- .../file_sys/fssystem/fssystem_utility.cpp | 3 + src/core/file_sys/submission_package.cpp | 6 +- src/core/hle/service/filesystem/fsp_srv.cpp | 4 +- 34 files changed, 344 insertions(+), 339 deletions(-) diff --git a/src/common/alignment.h b/src/common/alignment.h index 0057052af..fc5c26898 100644 --- a/src/common/alignment.h +++ b/src/common/alignment.h @@ -12,7 +12,9 @@ namespace Common { template requires std::is_integral_v -[[nodiscard]] constexpr T AlignUp(T value, size_t size) { +[[nodiscard]] constexpr T AlignUp(T value_, size_t size) { + using U = typename std::make_unsigned_t; + auto value{static_cast(value_)}; auto mod{static_cast(value % size)}; value -= mod; return static_cast(mod == T{0} ? value : value + size); @@ -26,7 +28,9 @@ template template requires std::is_integral_v -[[nodiscard]] constexpr T AlignDown(T value, size_t size) { +[[nodiscard]] constexpr T AlignDown(T value_, size_t size) { + using U = typename std::make_unsigned_t; + const auto value{static_cast(value_)}; return static_cast(value - value % size); } diff --git a/src/common/lz4_compression.cpp b/src/common/lz4_compression.cpp index 6867c03c4..d85ab1742 100644 --- a/src/common/lz4_compression.cpp +++ b/src/common/lz4_compression.cpp @@ -71,7 +71,7 @@ std::vector DecompressDataLZ4(std::span compressed, std::size_t un return uncompressed; } -int DecompressLZ4(void* dst, size_t dst_size, const void* src, size_t src_size) { +int DecompressDataLZ4(void* dst, size_t dst_size, const void* src, size_t src_size) { // This is just a thin wrapper around LZ4. return LZ4_decompress_safe(reinterpret_cast(src), reinterpret_cast(dst), static_cast(src_size), static_cast(dst_size)); diff --git a/src/common/lz4_compression.h b/src/common/lz4_compression.h index 7200e0f22..3ae17c2bb 100644 --- a/src/common/lz4_compression.h +++ b/src/common/lz4_compression.h @@ -56,6 +56,6 @@ namespace Common::Compression { [[nodiscard]] std::vector DecompressDataLZ4(std::span compressed, std::size_t uncompressed_size); -int DecompressLZ4(void* dst, size_t dst_size, const void* src, size_t src_size); +[[nodiscard]] int DecompressDataLZ4(void* dst, size_t dst_size, const void* src, size_t src_size); } // namespace Common::Compression diff --git a/src/core/file_sys/card_image.cpp b/src/core/file_sys/card_image.cpp index 54b53d020..4920905a6 100644 --- a/src/core/file_sys/card_image.cpp +++ b/src/core/file_sys/card_image.cpp @@ -29,8 +29,8 @@ constexpr std::array partition_names{ XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index) : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA}, - partitions(partition_names.size()), partitions_raw(partition_names.size()), - keys{Core::Crypto::KeyManager::Instance()} { + partitions(partition_names.size()), + partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} { if (file->ReadObject(&header) != sizeof(GamecardHeader)) { status = Loader::ResultStatus::ErrorBadXCIHeader; return; diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp index 2361b169e..44e6852fe 100644 --- a/src/core/file_sys/content_archive.cpp +++ b/src/core/file_sys/content_archive.cpp @@ -31,7 +31,7 @@ NCA::NCA(VirtualFile file_, const NCA* base_nca) reader = std::make_shared(); if (Result rc = - reader->Initialize(file, GetCryptoConfiguration(), *GetNcaCompressionConfiguration()); + reader->Initialize(file, GetCryptoConfiguration(), GetNcaCompressionConfiguration()); R_FAILED(rc)) { if (rc != ResultInvalidNcaSignature) { LOG_ERROR(Loader, "File reader errored out during header read: {:#x}", @@ -102,7 +102,6 @@ NCA::NCA(VirtualFile file_, const NCA* base_nca) } } - // TODO: Is this correct?? if (header_reader.GetEncryptionType() == NcaFsHeader::EncryptionType::AesCtrEx) { is_update = true; } @@ -144,16 +143,14 @@ VirtualDir NCA::GetParentDirectory() const { } NCAContentType NCA::GetType() const { - u8 type = static_cast(reader->GetContentType()); - return static_cast(type); + return static_cast(reader->GetContentType()); } u64 NCA::GetTitleId() const { if (is_update) { return reader->GetProgramId() | 0x800; - } else { - return reader->GetProgramId(); } + return reader->GetProgramId(); } RightsId NCA::GetRightsId() const { diff --git a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp index bf189c606..f25c95472 100644 --- a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp +++ b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp @@ -126,7 +126,7 @@ Result AesCtrCounterExtendedStorage::GetEntryList(Entry* out_entries, s32* out_e auto cur_entry = *visitor.Get(); while (cur_entry.GetOffset() < end_offset) { - // Try to write the entry to the out list + // Try to write the entry to the out list. if (entry_count != 0) { if (count >= entry_count) { break; @@ -152,7 +152,6 @@ Result AesCtrCounterExtendedStorage::GetEntryList(Entry* out_entries, s32* out_e size_t AesCtrCounterExtendedStorage::Read(u8* buffer, size_t size, size_t offset) const { // Validate preconditions. - ASSERT(offset >= 0); ASSERT(this->IsInitialized()); // Allow zero size. diff --git a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h index a79904fad..d0e9ceed0 100644 --- a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h +++ b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h @@ -70,14 +70,6 @@ public: static Result CreateSoftwareDecryptor(std::unique_ptr* out); -private: - mutable BucketTree m_table; - VirtualFile m_data_storage; - std::array m_key; - u32 m_secure_value; - s64 m_counter_offset; - std::unique_ptr m_decryptor; - public: AesCtrCounterExtendedStorage() : m_table(), m_data_storage(), m_secure_value(), m_counter_offset(), m_decryptor() {} @@ -109,6 +101,14 @@ public: private: Result Initialize(const void* key, size_t key_size, u32 secure_value, VirtualFile data_storage, VirtualFile table_storage); + +private: + mutable BucketTree m_table; + VirtualFile m_data_storage; + std::array m_key; + u32 m_secure_value; + s64 m_counter_offset; + std::unique_ptr m_decryptor; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h b/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h index bceb1f9ad..339e49697 100644 --- a/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h +++ b/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h @@ -22,12 +22,6 @@ public: static constexpr size_t KeySize = 0x10; static constexpr size_t IvSize = 0x10; -private: - VirtualFile m_base_storage; - std::array m_key; - std::array m_iv; - mutable std::optional> m_cipher; - public: static void MakeIv(void* dst, size_t dst_size, u64 upper, s64 offset); @@ -38,6 +32,12 @@ public: virtual size_t Read(u8* buffer, size_t size, size_t offset) const override; virtual size_t Write(const u8* buffer, size_t size, size_t offset) override; virtual size_t GetSize() const override; + +private: + VirtualFile m_base_storage; + std::array m_key; + std::array m_iv; + mutable std::optional> m_cipher; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_aes_xts_storage.h b/src/core/file_sys/fssystem/fssystem_aes_xts_storage.h index 2307a2659..f342efb57 100644 --- a/src/core/file_sys/fssystem/fssystem_aes_xts_storage.h +++ b/src/core/file_sys/fssystem/fssystem_aes_xts_storage.h @@ -20,14 +20,6 @@ public: static constexpr size_t KeySize = 0x20; static constexpr size_t IvSize = 0x10; -private: - VirtualFile m_base_storage; - std::array m_key; - std::array m_iv; - const size_t m_block_size; - std::mutex m_mutex; - mutable std::optional> m_cipher; - public: static void MakeAesXtsIv(void* dst, size_t dst_size, s64 offset, size_t block_size); @@ -37,6 +29,14 @@ public: virtual size_t Read(u8* buffer, size_t size, size_t offset) const override; virtual size_t GetSize() const override; + +private: + VirtualFile m_base_storage; + std::array m_key; + std::array m_iv; + const size_t m_block_size; + std::mutex m_mutex; + mutable std::optional> m_cipher; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_alignment_matching_storage.h b/src/core/file_sys/fssystem/fssystem_alignment_matching_storage.h index 27d34fd17..f96691d03 100644 --- a/src/core/file_sys/fssystem/fssystem_alignment_matching_storage.h +++ b/src/core/file_sys/fssystem/fssystem_alignment_matching_storage.h @@ -34,7 +34,7 @@ public: virtual size_t Read(u8* buffer, size_t size, size_t offset) const override { // Allocate a work buffer on stack. - alignas(DataAlignMax) char work_buf[DataAlign]; + alignas(DataAlignMax) std::array work_buf; // Succeed if zero size. if (size == 0) { @@ -47,13 +47,13 @@ public: s64 bs_size = this->GetSize(); ASSERT(R_SUCCEEDED(IStorage::CheckAccessRange(offset, size, bs_size))); - return AlignmentMatchingStorageImpl::Read(m_base_storage, work_buf, sizeof(work_buf), + return AlignmentMatchingStorageImpl::Read(m_base_storage, work_buf.data(), work_buf.size(), DataAlign, BufferAlign, offset, buffer, size); } virtual size_t Write(const u8* buffer, size_t size, size_t offset) override { // Allocate a work buffer on stack. - alignas(DataAlignMax) char work_buf[DataAlign]; + alignas(DataAlignMax) std::array work_buf; // Succeed if zero size. if (size == 0) { @@ -66,7 +66,7 @@ public: s64 bs_size = this->GetSize(); ASSERT(R_SUCCEEDED(IStorage::CheckAccessRange(offset, size, bs_size))); - return AlignmentMatchingStorageImpl::Write(m_base_storage, work_buf, sizeof(work_buf), + return AlignmentMatchingStorageImpl::Write(m_base_storage, work_buf.data(), work_buf.size(), DataAlign, BufferAlign, offset, buffer, size); } diff --git a/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp b/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp index 699a366f1..af8541009 100644 --- a/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp +++ b/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp @@ -226,7 +226,7 @@ Result BucketTree::Initialize(VirtualFile node_storage, VirtualFile entry_storag m_offset_cache.offsets.end_offset = end_offset; m_offset_cache.is_initialized = true; - // Cancel guard. + // We succeeded. R_SUCCEED(); } @@ -357,7 +357,7 @@ Result BucketTree::Visitor::MoveNext() { entry_index = 0; } else { - m_entry_index = 1; + m_entry_index = -1; } // Read the new entry. diff --git a/src/core/file_sys/fssystem/fssystem_bucket_tree.h b/src/core/file_sys/fssystem/fssystem_bucket_tree.h index 74a2f7583..46850cd48 100644 --- a/src/core/file_sys/fssystem/fssystem_bucket_tree.h +++ b/src/core/file_sys/fssystem/fssystem_bucket_tree.h @@ -77,11 +77,6 @@ public: }; 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() {} @@ -119,15 +114,17 @@ public: constexpr bool CanDo() const { return m_read_size > 0; } + + private: + size_t m_read_size; + s32 m_skip_count; + bool m_done; }; private: class NodeBuffer { YUZU_NON_COPYABLE(NodeBuffer); - private: - void* m_header; - public: NodeBuffer() : m_header() {} @@ -187,6 +184,9 @@ private: static_assert(sizeof(T) == sizeof(NodeHeader)); return reinterpret_cast(m_header); } + + private: + void* m_header; }; private: @@ -218,51 +218,6 @@ private: 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) { - ASSERT(entry_size >= sizeof(s64)); - ASSERT(node_size >= entry_size + sizeof(NodeHeader)); - ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax); - ASSERT(Common::IsPowerOfTwo(node_size)); - ASSERT(entry_count >= 0); - - if (entry_count <= 0) { - return 0; - } - return (1 + GetNodeL2Count(node_size, entry_size, entry_count)) * - static_cast(node_size); - } - - static constexpr s64 QueryEntryStorageSize(size_t node_size, size_t entry_size, - s32 entry_count) { - ASSERT(entry_size >= sizeof(s64)); - ASSERT(node_size >= entry_size + sizeof(NodeHeader)); - ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax); - ASSERT(Common::IsPowerOfTwo(node_size)); - ASSERT(entry_count >= 0); - - if (entry_count <= 0) { - return 0; - } - return GetEntrySetCount(node_size, entry_size, entry_count) * static_cast(node_size); - } - -private: - mutable VirtualFile m_node_storage; - mutable VirtualFile 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(), @@ -299,6 +254,40 @@ public: R_SUCCEED(); } +public: + static constexpr s64 QueryHeaderStorageSize() { + return sizeof(Header); + } + + static constexpr s64 QueryNodeStorageSize(size_t node_size, size_t entry_size, + s32 entry_count) { + ASSERT(entry_size >= sizeof(s64)); + ASSERT(node_size >= entry_size + sizeof(NodeHeader)); + ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax); + ASSERT(Common::IsPowerOfTwo(node_size)); + ASSERT(entry_count >= 0); + + if (entry_count <= 0) { + return 0; + } + return (1 + GetNodeL2Count(node_size, entry_size, entry_count)) * + static_cast(node_size); + } + + static constexpr s64 QueryEntryStorageSize(size_t node_size, size_t entry_size, + s32 entry_count) { + ASSERT(entry_size >= sizeof(s64)); + ASSERT(node_size >= entry_size + sizeof(NodeHeader)); + ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax); + ASSERT(Common::IsPowerOfTwo(node_size)); + ASSERT(entry_count >= 0); + + if (entry_count <= 0) { + return 0; + } + return GetEntrySetCount(node_size, entry_size, entry_count) * static_cast(node_size); + } + private: template struct ContinuousReadingParam { @@ -327,35 +316,23 @@ private: } Result EnsureOffsetCache(); + +private: + mutable VirtualFile m_node_storage; + mutable VirtualFile 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; }; class BucketTree::Visitor { YUZU_NON_COPYABLE(Visitor); YUZU_NON_MOVEABLE(Visitor); -private: - friend class BucketTree; - - union EntrySetHeader { - NodeHeader header; - struct Info { - s32 index; - s32 count; - s64 end; - s64 start; - } info; - static_assert(std::is_trivial_v); - }; - static_assert(std::is_trivial_v); - -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{} {} @@ -412,6 +389,28 @@ private: 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); + +private: + friend class BucketTree; + + union EntrySetHeader { + NodeHeader header; + struct Info { + s32 index; + s32 count; + s64 end; + s64 start; + } info; + static_assert(std::is_trivial_v); + }; + static_assert(std::is_trivial_v); + + const BucketTree* m_tree; + BucketTree::Offsets m_offsets; + void* m_entry; + s32 m_entry_index; + s32 m_entry_set_count; + EntrySetHeader m_entry_set; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_compressed_storage.h b/src/core/file_sys/fssystem/fssystem_compressed_storage.h index e407add1b..33d93938e 100644 --- a/src/core/file_sys/fssystem/fssystem_compressed_storage.h +++ b/src/core/file_sys/fssystem/fssystem_compressed_storage.h @@ -50,13 +50,6 @@ private: YUZU_NON_COPYABLE(CompressedStorageCore); YUZU_NON_MOVEABLE(CompressedStorageCore); - private: - size_t m_block_size_max; - size_t m_continuous_reading_size_max; - BucketTree m_table; - VirtualFile m_data_storage; - GetDecompressorFunction m_get_decompressor_function; - public: CompressedStorageCore() : m_table(), m_data_storage() {} @@ -296,7 +289,7 @@ private: ASSERT(offset >= 0); ASSERT(this->IsInitialized()); - // Succeed immediately, if we hvae nothing to read. + // Succeed immediately, if we have nothing to read. R_SUCCEED_IF(size == 0); // Declare read lambda. @@ -307,10 +300,13 @@ private: u32 physical_size; u32 virtual_size; }; - Entries entries[EntriesCountMax]; + std::array entries; s32 entry_count = 0; Entry prev_entry = { .virt_offset = -1, + .phys_offset{}, + .compression_type{}, + .phys_size{}, }; bool will_allocate_pooled_buffer = false; s64 required_access_physical_offset = 0; @@ -594,7 +590,7 @@ private: } required_access_physical_size += physical_size + gap_from_prev; - // Create an entry. to access the data storage. + // Create an entry to access the data storage. entries[entry_count++] = { .compression_type = entry.compression_type, .gap_from_prev = static_cast(gap_from_prev), @@ -621,7 +617,7 @@ private: .virtual_size = static_cast(read_size), }; } else { - // We have no entries, we we can just perform the read. + // We have no entries, so we can just perform the read. const Result rc = read_func(static_cast(read_size), [&](void* dst, size_t dst_size) -> Result { @@ -668,6 +664,13 @@ private: bool IsInitialized() const { return m_table.IsInitialized(); } + + private: + size_t m_block_size_max; + size_t m_continuous_reading_size_max; + BucketTree m_table; + VirtualFile m_data_storage; + GetDecompressorFunction m_get_decompressor_function; }; class CacheManager { @@ -687,9 +690,6 @@ private: }; static_assert(std::is_trivial_v); - private: - s64 m_storage_size = 0; - public: CacheManager() = default; @@ -890,11 +890,10 @@ private: R_SUCCEED(); } - }; -private: - mutable CompressedStorageCore m_core; - mutable CacheManager m_cache_manager; + private: + s64 m_storage_size = 0; + }; public: CompressedStorage() = default; @@ -955,6 +954,10 @@ public: return 0; } } + +private: + mutable CompressedStorageCore m_core; + mutable CacheManager m_cache_manager; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_compression_configuration.cpp b/src/core/file_sys/fssystem/fssystem_compression_configuration.cpp index 8734f84ca..ef552cefe 100644 --- a/src/core/file_sys/fssystem/fssystem_compression_configuration.cpp +++ b/src/core/file_sys/fssystem/fssystem_compression_configuration.cpp @@ -9,7 +9,7 @@ namespace FileSys { namespace { Result DecompressLz4(void* dst, size_t dst_size, const void* src, size_t src_size) { - auto result = Common::Compression::DecompressLZ4(dst, dst_size, src, src_size); + auto result = Common::Compression::DecompressDataLZ4(dst, dst_size, src, src_size); R_UNLESS(static_cast(result) == dst_size, ResultUnexpectedInCompressedStorageC); R_SUCCEED(); } @@ -23,14 +23,14 @@ constexpr DecompressorFunction GetNcaDecompressorFunction(CompressionType type) } } -constexpr NcaCompressionConfiguration g_nca_compression_configuration{ - .get_decompressor = GetNcaDecompressorFunction, -}; - } // namespace -const NcaCompressionConfiguration* GetNcaCompressionConfiguration() { - return std::addressof(g_nca_compression_configuration); +const NcaCompressionConfiguration& GetNcaCompressionConfiguration() { + static const NcaCompressionConfiguration configuration = { + .get_decompressor = GetNcaDecompressorFunction, + }; + + return configuration; } } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_compression_configuration.h b/src/core/file_sys/fssystem/fssystem_compression_configuration.h index b4ec4f203..ec9b48e9a 100644 --- a/src/core/file_sys/fssystem/fssystem_compression_configuration.h +++ b/src/core/file_sys/fssystem/fssystem_compression_configuration.h @@ -7,6 +7,6 @@ namespace FileSys { -const NcaCompressionConfiguration* GetNcaCompressionConfiguration(); +const NcaCompressionConfiguration& GetNcaCompressionConfiguration(); } diff --git a/src/core/file_sys/fssystem/fssystem_crypto_configuration.cpp b/src/core/file_sys/fssystem/fssystem_crypto_configuration.cpp index 7b89d4512..a4f0cde28 100644 --- a/src/core/file_sys/fssystem/fssystem_crypto_configuration.cpp +++ b/src/core/file_sys/fssystem/fssystem_crypto_configuration.cpp @@ -48,7 +48,15 @@ void GenerateKey(void* dst_key, size_t dst_key_size, const void* src_key, size_t const NcaCryptoConfiguration& GetCryptoConfiguration() { static const NcaCryptoConfiguration configuration = { + .header_1_sign_key_moduli{}, + .header_1_sign_key_public_exponent{}, + .key_area_encryption_key_source{}, + .header_encryption_key_source{}, + .header_encrypted_encryption_keys{}, .generate_key = GenerateKey, + .verify_sign1{}, + .is_plaintext_header_available{}, + .is_available_sw_key{}, }; return configuration; diff --git a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h index 3d216e4ae..5cf697efe 100644 --- a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h +++ b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h @@ -24,7 +24,7 @@ static_assert(alignof(HierarchicalIntegrityVerificationLevelInformation) == 0x4) struct HierarchicalIntegrityVerificationInformation { u32 max_layers; - HierarchicalIntegrityVerificationLevelInformation info[IntegrityMaxLayerCount - 1]; + std::array info; HashSalt seed; s64 GetLayeredHashSize() const { @@ -52,7 +52,7 @@ static_assert(std::is_trivial_v layered_hash_sizes; }; static_assert(std::is_trivial_v); @@ -60,13 +60,6 @@ class HierarchicalIntegrityVerificationStorage : public IReadOnlyStorage { YUZU_NON_COPYABLE(HierarchicalIntegrityVerificationStorage); YUZU_NON_MOVEABLE(HierarchicalIntegrityVerificationStorage); -private: - friend struct HierarchicalIntegrityVerificationMetaInformation; - -protected: - static constexpr s64 HashSize = 256 / 8; - static constexpr size_t MaxLayers = IntegrityMaxLayerCount; - public: using GenerateRandomFunction = void (*)(void* dst, size_t size); @@ -83,7 +76,7 @@ public: }; private: - VirtualFile m_storages[DataStorage + 1]; + std::array m_storages; public: void SetMasterHashStorage(VirtualFile s) { @@ -114,19 +107,6 @@ public: } }; -private: - static GenerateRandomFunction s_generate_random; - - static void SetGenerateRandomFunction(GenerateRandomFunction func) { - s_generate_random = func; - } - -private: - std::shared_ptr m_verify_storages[MaxLayers - 1]; - VirtualFile m_buffer_storages[MaxLayers - 1]; - s64 m_data_size; - s32 m_max_layers; - public: HierarchicalIntegrityVerificationStorage(); virtual ~HierarchicalIntegrityVerificationStorage() override { @@ -159,6 +139,26 @@ public: static constexpr s8 GetDefaultDataCacheBufferLevel(u32 max_layers) { return static_cast(16 + max_layers - 2); } + +protected: + static constexpr s64 HashSize = 256 / 8; + static constexpr size_t MaxLayers = IntegrityMaxLayerCount; + +private: + static GenerateRandomFunction s_generate_random; + + static void SetGenerateRandomFunction(GenerateRandomFunction func) { + s_generate_random = func; + } + +private: + friend struct HierarchicalIntegrityVerificationMetaInformation; + +private: + std::array, MaxLayers - 1> m_verify_storages; + std::array m_buffer_storages; + s64 m_data_size; + s32 m_max_layers; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h b/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h index 717ba9748..18df400af 100644 --- a/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h +++ b/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h @@ -19,15 +19,6 @@ public: static constexpr s32 LayerCount = 3; static constexpr size_t HashSize = 256 / 8; -private: - VirtualFile m_base_storage; - s64 m_base_storage_size; - char* m_hash_buffer; - size_t m_hash_buffer_size; - s32 m_hash_target_block_size; - s32 m_log_size_ratio; - std::mutex m_mutex; - public: HierarchicalSha256Storage() : m_mutex() {} @@ -39,6 +30,15 @@ public: } virtual size_t Read(u8* buffer, size_t length, size_t offset) const override; + +private: + VirtualFile m_base_storage; + s64 m_base_storage_size; + char* m_hash_buffer; + size_t m_hash_buffer_size; + s32 m_hash_target_block_size; + s32 m_log_size_ratio; + std::mutex m_mutex; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_indirect_storage.cpp b/src/core/file_sys/fssystem/fssystem_indirect_storage.cpp index 45aa08d30..7544e70b2 100644 --- a/src/core/file_sys/fssystem/fssystem_indirect_storage.cpp +++ b/src/core/file_sys/fssystem/fssystem_indirect_storage.cpp @@ -72,7 +72,7 @@ Result IndirectStorage::GetEntryList(Entry* out_entries, s32* out_entry_count, s auto cur_entry = *visitor.Get(); while (cur_entry.GetVirtualOffset() < end_offset) { - // Try to write the entry to the out list + // Try to write the entry to the out list. if (entry_count != 0) { if (count >= entry_count) { break; @@ -98,7 +98,6 @@ Result IndirectStorage::GetEntryList(Entry* out_entries, s32* out_entry_count, s size_t IndirectStorage::Read(u8* buffer, size_t size, size_t offset) const { // Validate pre-conditions. - ASSERT(offset >= 0); ASSERT(this->IsInitialized()); ASSERT(buffer != nullptr); diff --git a/src/core/file_sys/fssystem/fssystem_indirect_storage.h b/src/core/file_sys/fssystem/fssystem_indirect_storage.h index 39293667b..7854335bf 100644 --- a/src/core/file_sys/fssystem/fssystem_indirect_storage.h +++ b/src/core/file_sys/fssystem/fssystem_indirect_storage.h @@ -21,27 +21,27 @@ public: static constexpr size_t NodeSize = 16_KiB; struct Entry { - u8 virt_offset[sizeof(s64)]; - u8 phys_offset[sizeof(s64)]; + std::array virt_offset; + std::array phys_offset; s32 storage_index; void SetVirtualOffset(const s64& ofs) { - std::memcpy(this->virt_offset, std::addressof(ofs), sizeof(s64)); + std::memcpy(this->virt_offset.data(), std::addressof(ofs), sizeof(s64)); } s64 GetVirtualOffset() const { s64 offset; - std::memcpy(std::addressof(offset), this->virt_offset, sizeof(s64)); + std::memcpy(std::addressof(offset), this->virt_offset.data(), sizeof(s64)); return offset; } void SetPhysicalOffset(const s64& ofs) { - std::memcpy(this->phys_offset, std::addressof(ofs), sizeof(s64)); + std::memcpy(this->phys_offset.data(), std::addressof(ofs), sizeof(s64)); } s64 GetPhysicalOffset() const { s64 offset; - std::memcpy(std::addressof(offset), this->phys_offset, sizeof(s64)); + std::memcpy(std::addressof(offset), this->phys_offset.data(), sizeof(s64)); return offset; } }; @@ -61,43 +61,6 @@ public: }; static_assert(std::is_trivial_v); -private: - struct ContinuousReadingEntry { - static constexpr size_t FragmentSizeMax = 4_KiB; - - IndirectStorage::Entry entry; - - s64 GetVirtualOffset() const { - return this->entry.GetVirtualOffset(); - } - - s64 GetPhysicalOffset() const { - return this->entry.GetPhysicalOffset(); - } - - bool IsFragment() const { - return this->entry.storage_index != 0; - } - }; - static_assert(std::is_trivial_v); - -public: - static constexpr s64 QueryHeaderStorageSize() { - return BucketTree::QueryHeaderStorageSize(); - } - - static constexpr s64 QueryNodeStorageSize(s32 entry_count) { - return BucketTree::QueryNodeStorageSize(NodeSize, sizeof(Entry), entry_count); - } - - static constexpr s64 QueryEntryStorageSize(s32 entry_count) { - return BucketTree::QueryEntryStorageSize(NodeSize, sizeof(Entry), entry_count); - } - -private: - mutable BucketTree m_table; - std::array m_data_storage; - public: IndirectStorage() : m_table(), m_data_storage() {} virtual ~IndirectStorage() { @@ -131,7 +94,7 @@ public: s64 size); virtual size_t GetSize() const override { - BucketTree::Offsets offsets; + BucketTree::Offsets offsets{}; m_table.GetOffsets(std::addressof(offsets)); return offsets.end_offset; @@ -139,6 +102,19 @@ public: virtual size_t Read(u8* buffer, size_t size, size_t offset) const override; +public: + static constexpr s64 QueryHeaderStorageSize() { + return BucketTree::QueryHeaderStorageSize(); + } + + static constexpr s64 QueryNodeStorageSize(s32 entry_count) { + return BucketTree::QueryNodeStorageSize(NodeSize, sizeof(Entry), entry_count); + } + + static constexpr s64 QueryEntryStorageSize(s32 entry_count) { + return BucketTree::QueryEntryStorageSize(NodeSize, sizeof(Entry), entry_count); + } + protected: BucketTree& GetEntryTable() { return m_table; @@ -151,6 +127,30 @@ protected: template Result OperatePerEntry(s64 offset, s64 size, F func); + +private: + struct ContinuousReadingEntry { + static constexpr size_t FragmentSizeMax = 4_KiB; + + IndirectStorage::Entry entry; + + s64 GetVirtualOffset() const { + return this->entry.GetVirtualOffset(); + } + + s64 GetPhysicalOffset() const { + return this->entry.GetPhysicalOffset(); + } + + bool IsFragment() const { + return this->entry.storage_index != 0; + } + }; + static_assert(std::is_trivial_v); + +private: + mutable BucketTree m_table; + std::array m_data_storage; }; template diff --git a/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h b/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h index b80e9a302..5f8512b2a 100644 --- a/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h +++ b/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h @@ -13,11 +13,6 @@ constexpr inline size_t IntegrityLayerCountRomFs = 7; constexpr inline size_t IntegrityHashLayerBlockSize = 16_KiB; class IntegrityRomFsStorage : public IReadOnlyStorage { -private: - HierarchicalIntegrityVerificationStorage m_integrity_storage; - Hash m_master_hash; - std::shared_ptr> m_master_hash_storage; - public: IntegrityRomFsStorage() {} virtual ~IntegrityRomFsStorage() override { @@ -37,6 +32,11 @@ public: virtual size_t GetSize() const override { return m_integrity_storage.GetSize(); } + +private: + HierarchicalIntegrityVerificationStorage m_integrity_storage; + Hash m_master_hash; + std::shared_ptr> m_master_hash_storage; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp index 0dba0c8d9..2f73abf86 100644 --- a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp +++ b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp @@ -8,7 +8,7 @@ namespace FileSys { constexpr inline u32 ILog2(u32 val) { ASSERT(val > 0); - return ((sizeof(u32) * 8) - 1 - std::countl_zero(val)); + return static_cast((sizeof(u32) * 8) - 1 - std::countl_zero(val)); } void IntegrityVerificationStorage::Initialize(VirtualFile hs, VirtualFile ds, s64 verif_block_size, diff --git a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h index 08515a268..09f76799d 100644 --- a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h +++ b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h @@ -18,19 +18,10 @@ public: static constexpr s64 HashSize = 256 / 8; struct BlockHash { - u8 hash[HashSize]; + std::array hash; }; static_assert(std::is_trivial_v); -private: - VirtualFile m_hash_storage; - VirtualFile m_data_storage; - s64 m_verification_block_size; - s64 m_verification_block_order; - s64 m_upper_layer_verification_block_size; - s64 m_upper_layer_verification_block_order; - bool m_is_real_data; - public: IntegrityVerificationStorage() : m_verification_block_size(0), m_verification_block_order(0), @@ -60,6 +51,15 @@ private: ASSERT(hash != nullptr); return (hash->hash[HashSize - 1] & 0x80) != 0; } + +private: + VirtualFile m_hash_storage; + VirtualFile m_data_storage; + s64 m_verification_block_size; + s64 m_verification_block_order; + s64 m_upper_layer_verification_block_size; + s64 m_upper_layer_verification_block_order; + bool m_is_real_data; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_memory_resource_buffer_hold_storage.h b/src/core/file_sys/fssystem/fssystem_memory_resource_buffer_hold_storage.h index 7637272d5..c07a127fb 100644 --- a/src/core/file_sys/fssystem/fssystem_memory_resource_buffer_hold_storage.h +++ b/src/core/file_sys/fssystem/fssystem_memory_resource_buffer_hold_storage.h @@ -1,3 +1,6 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + #pragma once #include "core/file_sys/fssystem/fs_i_storage.h" @@ -8,11 +11,6 @@ class MemoryResourceBufferHoldStorage : public IStorage { YUZU_NON_COPYABLE(MemoryResourceBufferHoldStorage); YUZU_NON_MOVEABLE(MemoryResourceBufferHoldStorage); -private: - VirtualFile m_storage; - void* m_buffer; - size_t m_buffer_size; - public: MemoryResourceBufferHoldStorage(VirtualFile storage, size_t buffer_size) : m_storage(std::move(storage)), m_buffer(::operator new(buffer_size)), @@ -53,6 +51,11 @@ public: return m_storage->Write(buffer, size, offset); } + +private: + VirtualFile m_storage; + void* m_buffer; + size_t m_buffer_size; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp index 450135ae0..0f5432203 100644 --- a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp +++ b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp @@ -228,7 +228,7 @@ Result NcaFileSystemDriver::OpenStorageImpl(VirtualFile* out, NcaFsHeaderReader* // Process indirect layer. if (patch_info.HasIndirectTable()) { - // Create the indirect meta storage + // Create the indirect meta storage. VirtualFile indirect_storage_meta_storage = patch_meta_indirect_meta_storage; if (indirect_storage_meta_storage == nullptr) { // If we don't have a meta storage, we must not have a patch meta hash layer. diff --git a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h index d317b35ac..5771a21fc 100644 --- a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h +++ b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h @@ -37,11 +37,13 @@ struct NcaCryptoConfiguration { static constexpr size_t KeyGenerationMax = 32; - const u8* header_1_sign_key_moduli[Header1SignatureKeyGenerationMax + 1]; - u8 header_1_sign_key_public_exponent[Rsa2048KeyPublicExponentSize]; - u8 key_area_encryption_key_source[KeyAreaEncryptionKeyIndexCount][Aes128KeySize]; - u8 header_encryption_key_source[Aes128KeySize]; - u8 header_encrypted_encryption_keys[HeaderEncryptionKeyCount][Aes128KeySize]; + std::array header_1_sign_key_moduli; + std::array header_1_sign_key_public_exponent; + std::array, KeyAreaEncryptionKeyIndexCount> + key_area_encryption_key_source; + std::array header_encryption_key_source; + std::array, HeaderEncryptionKeyCount> + header_encrypted_encryption_keys; KeyGenerationFunction generate_key; VerifySign1Function verify_sign1; bool is_plaintext_header_available; @@ -89,18 +91,6 @@ class NcaReader { YUZU_NON_COPYABLE(NcaReader); YUZU_NON_MOVEABLE(NcaReader); -private: - NcaHeader m_header; - u8 m_decryption_keys[NcaHeader::DecryptionKey_Count][NcaCryptoConfiguration::Aes128KeySize]; - VirtualFile m_body_storage; - VirtualFile m_header_storage; - u8 m_external_decryption_key[NcaCryptoConfiguration::Aes128KeySize]; - bool m_is_software_aes_prioritized; - bool m_is_available_sw_key; - NcaHeader::EncryptionType m_header_encryption_type; - bool m_is_header_sign1_signature_valid; - GetDecompressorFunction m_get_decompressor; - public: NcaReader(); ~NcaReader(); @@ -147,16 +137,26 @@ public: bool GetHeaderSign1Valid() const; void GetHeaderSign2(void* dst, size_t size) const; + +private: + NcaHeader m_header; + std::array, + NcaHeader::DecryptionKey_Count> + m_decryption_keys; + VirtualFile m_body_storage; + VirtualFile m_header_storage; + std::array m_external_decryption_key; + bool m_is_software_aes_prioritized; + bool m_is_available_sw_key; + NcaHeader::EncryptionType m_header_encryption_type; + bool m_is_header_sign1_signature_valid; + GetDecompressorFunction m_get_decompressor; }; class NcaFsHeaderReader { YUZU_NON_COPYABLE(NcaFsHeaderReader); YUZU_NON_MOVEABLE(NcaFsHeaderReader); -private: - NcaFsHeader m_data; - s32 m_fs_index; - public: NcaFsHeaderReader() : m_fs_index(-1) { std::memset(std::addressof(m_data), 0, sizeof(m_data)); @@ -200,6 +200,10 @@ public: NcaMetaDataHashDataInfo& GetSparseMetaDataHashDataInfo(); const NcaMetaDataHashDataInfo& GetSparseMetaDataHashDataInfo() const; NcaFsHeader::MetaDataHashType GetSparseMetaHashType() const; + +private: + NcaFsHeader m_data; + s32 m_fs_index; }; class NcaFileSystemDriver { @@ -236,10 +240,6 @@ private: None = 1, }; -private: - std::shared_ptr m_original_reader; - std::shared_ptr m_reader; - public: static Result SetupFsHeaderReader(NcaFsHeaderReader* out, const NcaReader& reader, s32 fs_index); @@ -355,6 +355,10 @@ public: VirtualFile* out_meta, VirtualFile base_storage, const NcaCompressionInfo& compression_info, GetDecompressorFunction get_decompressor); + +private: + std::shared_ptr m_original_reader; + std::shared_ptr m_reader; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_nca_reader.cpp b/src/core/file_sys/fssystem/fssystem_nca_reader.cpp index cd4c49069..a3714ab37 100644 --- a/src/core/file_sys/fssystem/fssystem_nca_reader.cpp +++ b/src/core/file_sys/fssystem/fssystem_nca_reader.cpp @@ -53,24 +53,27 @@ Result NcaReader::Initialize(VirtualFile base_storage, const NcaCryptoConfigurat // Generate keys for header. using AesXtsStorageForNcaHeader = AesXtsStorage; - constexpr const s32 HeaderKeyTypeValues[NcaCryptoConfiguration::HeaderEncryptionKeyCount] = { - static_cast(KeyType::NcaHeaderKey1), - static_cast(KeyType::NcaHeaderKey2), - }; + constexpr std::array + HeaderKeyTypeValues = { + static_cast(KeyType::NcaHeaderKey1), + static_cast(KeyType::NcaHeaderKey2), + }; - u8 header_decryption_keys[NcaCryptoConfiguration::HeaderEncryptionKeyCount] - [NcaCryptoConfiguration::Aes128KeySize]; + std::array, + NcaCryptoConfiguration::HeaderEncryptionKeyCount> + header_decryption_keys; for (size_t i = 0; i < NcaCryptoConfiguration::HeaderEncryptionKeyCount; i++) { - crypto_cfg.generate_key(header_decryption_keys[i], AesXtsStorageForNcaHeader::KeySize, - crypto_cfg.header_encrypted_encryption_keys[i], + crypto_cfg.generate_key(header_decryption_keys[i].data(), + AesXtsStorageForNcaHeader::KeySize, + crypto_cfg.header_encrypted_encryption_keys[i].data(), AesXtsStorageForNcaHeader::KeySize, HeaderKeyTypeValues[i]); } // Create the header storage. - const u8 header_iv[AesXtsStorageForNcaHeader::IvSize] = {}; + std::array header_iv = {}; work_header_storage = std::make_unique( - base_storage, header_decryption_keys[0], header_decryption_keys[1], - AesXtsStorageForNcaHeader::KeySize, header_iv, AesXtsStorageForNcaHeader::IvSize, + base_storage, header_decryption_keys[0].data(), header_decryption_keys[1].data(), + AesXtsStorageForNcaHeader::KeySize, header_iv.data(), AesXtsStorageForNcaHeader::IvSize, NcaHeader::XtsBlockSize); // Check that we successfully created the storage. @@ -94,20 +97,6 @@ Result NcaReader::Initialize(VirtualFile base_storage, const NcaCryptoConfigurat m_header_encryption_type = NcaHeader::EncryptionType::None; } - // Validate the fixed key signature. - if (m_header.header1_signature_key_generation > - NcaCryptoConfiguration::Header1SignatureKeyGenerationMax) { - LOG_CRITICAL(Frontend, - "NcaCryptoConfiguration::Header1SignatureKeyGenerationMax = {}, " - "m_header.header1_signature_key_generation = {}", - NcaCryptoConfiguration::Header1SignatureKeyGenerationMax, - m_header.header1_signature_key_generation); - } - - R_UNLESS(m_header.header1_signature_key_generation <= - NcaCryptoConfiguration::Header1SignatureKeyGenerationMax, - ResultInvalidNcaHeader1SignatureKeyGeneration); - // Verify the header sign1. if (crypto_cfg.verify_sign1 != nullptr) { const u8* sig = m_header.header_sign_1.data(); @@ -138,31 +127,31 @@ Result NcaReader::Initialize(VirtualFile base_storage, const NcaCryptoConfigurat if (std::memcmp(ZeroRightsId.data(), m_header.rights_id.data(), NcaHeader::RightsIdSize) == 0) { // If we don't, then we don't have an external key, so we need to generate decryption keys. crypto_cfg.generate_key( - m_decryption_keys[NcaHeader::DecryptionKey_AesCtr], Aes128KeySize, + m_decryption_keys[NcaHeader::DecryptionKey_AesCtr].data(), Aes128KeySize, m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesCtr * Aes128KeySize, Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration())); crypto_cfg.generate_key( - m_decryption_keys[NcaHeader::DecryptionKey_AesXts1], Aes128KeySize, + m_decryption_keys[NcaHeader::DecryptionKey_AesXts1].data(), Aes128KeySize, m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesXts1 * Aes128KeySize, Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration())); crypto_cfg.generate_key( - m_decryption_keys[NcaHeader::DecryptionKey_AesXts2], Aes128KeySize, + m_decryption_keys[NcaHeader::DecryptionKey_AesXts2].data(), Aes128KeySize, m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesXts2 * Aes128KeySize, Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration())); crypto_cfg.generate_key( - m_decryption_keys[NcaHeader::DecryptionKey_AesCtrEx], Aes128KeySize, + m_decryption_keys[NcaHeader::DecryptionKey_AesCtrEx].data(), Aes128KeySize, m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesCtrEx * Aes128KeySize, Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration())); // Copy the hardware speed emulation key. - std::memcpy(m_decryption_keys[NcaHeader::DecryptionKey_AesCtrHw], + std::memcpy(m_decryption_keys[NcaHeader::DecryptionKey_AesCtrHw].data(), m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesCtrHw * Aes128KeySize, Aes128KeySize); } // Clear the external decryption key. - std::memset(m_external_decryption_key, 0, sizeof(m_external_decryption_key)); + std::memset(m_external_decryption_key.data(), 0, m_external_decryption_key.size()); // Set software key availability. m_is_available_sw_key = crypto_cfg.is_available_sw_key; @@ -304,7 +293,7 @@ void NcaReader::GetEncryptedKey(void* dst, size_t size) const { const void* NcaReader::GetDecryptionKey(s32 index) const { ASSERT(m_body_storage != nullptr); ASSERT(0 <= index && index < NcaHeader::DecryptionKey_Count); - return m_decryption_keys[index]; + return m_decryption_keys[index].data(); } bool NcaReader::HasValidInternalKey() const { @@ -339,14 +328,14 @@ bool NcaReader::HasExternalDecryptionKey() const { } const void* NcaReader::GetExternalDecryptionKey() const { - return m_external_decryption_key; + return m_external_decryption_key.data(); } void NcaReader::SetExternalDecryptionKey(const void* src, size_t size) { ASSERT(src != nullptr); ASSERT(size == sizeof(m_external_decryption_key)); - std::memcpy(m_external_decryption_key, src, sizeof(m_external_decryption_key)); + std::memcpy(m_external_decryption_key.data(), src, sizeof(m_external_decryption_key)); } void NcaReader::GetRawData(void* dst, size_t dst_size) const { diff --git a/src/core/file_sys/fssystem/fssystem_pooled_buffer.h b/src/core/file_sys/fssystem/fssystem_pooled_buffer.h index 1df3153a1..9a6adbcb5 100644 --- a/src/core/file_sys/fssystem/fssystem_pooled_buffer.h +++ b/src/core/file_sys/fssystem/fssystem_pooled_buffer.h @@ -18,27 +18,6 @@ constexpr inline size_t BufferPoolWorkSize = 320; class PooledBuffer { YUZU_NON_COPYABLE(PooledBuffer); -private: - char* m_buffer; - size_t m_size; - -private: - static size_t GetAllocatableSizeMaxCore(bool large); - -public: - static size_t GetAllocatableSizeMax() { - return GetAllocatableSizeMaxCore(false); - } - static size_t GetAllocatableParticularlyLargeSizeMax() { - return GetAllocatableSizeMaxCore(true); - } - -private: - void Swap(PooledBuffer& rhs) { - std::swap(m_buffer, rhs.m_buffer); - std::swap(m_size, rhs.m_size); - } - public: // Constructor/Destructor. constexpr PooledBuffer() : m_buffer(), m_size() {} @@ -89,8 +68,28 @@ public: return m_size; } +public: + static size_t GetAllocatableSizeMax() { + return GetAllocatableSizeMaxCore(false); + } + static size_t GetAllocatableParticularlyLargeSizeMax() { + return GetAllocatableSizeMaxCore(true); + } + private: + static size_t GetAllocatableSizeMaxCore(bool large); + +private: + void Swap(PooledBuffer& rhs) { + std::swap(m_buffer, rhs.m_buffer); + std::swap(m_size, rhs.m_size); + } + void AllocateCore(size_t ideal_size, size_t required_size, bool large); + +private: + char* m_buffer; + size_t m_size; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_sparse_storage.cpp b/src/core/file_sys/fssystem/fssystem_sparse_storage.cpp index 05e8820f7..8574a11dd 100644 --- a/src/core/file_sys/fssystem/fssystem_sparse_storage.cpp +++ b/src/core/file_sys/fssystem/fssystem_sparse_storage.cpp @@ -7,7 +7,6 @@ namespace FileSys { size_t SparseStorage::Read(u8* buffer, size_t size, size_t offset) const { // Validate preconditions. - ASSERT(offset >= 0); ASSERT(this->IsInitialized()); ASSERT(buffer != nullptr); diff --git a/src/core/file_sys/fssystem/fssystem_sparse_storage.h b/src/core/file_sys/fssystem/fssystem_sparse_storage.h index c1ade7195..6c196ec61 100644 --- a/src/core/file_sys/fssystem/fssystem_sparse_storage.h +++ b/src/core/file_sys/fssystem/fssystem_sparse_storage.h @@ -22,7 +22,6 @@ private: } virtual size_t Read(u8* buffer, size_t size, size_t offset) const override { - ASSERT(offset >= 0); ASSERT(buffer != nullptr || size == 0); if (size > 0) { @@ -33,9 +32,6 @@ private: } }; -private: - VirtualFile m_zero_storage; - public: SparseStorage() : IndirectStorage(), m_zero_storage(std::make_shared()) {} virtual ~SparseStorage() {} @@ -68,6 +64,9 @@ private: void SetZeroStorage() { return this->SetStorage(1, m_zero_storage, 0, std::numeric_limits::max()); } + +private: + VirtualFile m_zero_storage; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_switch_storage.h b/src/core/file_sys/fssystem/fssystem_switch_storage.h index 140f21ab7..2b43927cb 100644 --- a/src/core/file_sys/fssystem/fssystem_switch_storage.h +++ b/src/core/file_sys/fssystem/fssystem_switch_storage.h @@ -17,11 +17,6 @@ public: s64 size; }; -private: - VirtualFile m_inside_region_storage; - VirtualFile m_outside_region_storage; - Region m_region; - public: RegionSwitchStorage(VirtualFile&& i, VirtualFile&& o, Region r) : m_inside_region_storage(std::move(i)), m_outside_region_storage(std::move(o)), @@ -75,6 +70,11 @@ private: return false; } } + +private: + VirtualFile m_inside_region_storage; + VirtualFile m_outside_region_storage; + Region m_region; }; } // namespace FileSys diff --git a/src/core/file_sys/fssystem/fssystem_utility.cpp b/src/core/file_sys/fssystem/fssystem_utility.cpp index 4dddfd75a..ceabb8ff1 100644 --- a/src/core/file_sys/fssystem/fssystem_utility.cpp +++ b/src/core/file_sys/fssystem/fssystem_utility.cpp @@ -1,3 +1,6 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + #include "core/file_sys/fssystem/fssystem_utility.h" namespace FileSys { diff --git a/src/core/file_sys/submission_package.cpp b/src/core/file_sys/submission_package.cpp index aa41c7c31..73582ad50 100644 --- a/src/core/file_sys/submission_package.cpp +++ b/src/core/file_sys/submission_package.cpp @@ -19,9 +19,9 @@ namespace FileSys { NSP::NSP(VirtualFile file_, u64 title_id_, std::size_t program_index_) - : file(std::move(file_)), expected_program_id(title_id_), program_index(program_index_), - status{Loader::ResultStatus::Success}, pfs(std::make_shared(file)), - keys{Core::Crypto::KeyManager::Instance()} { + : file(std::move(file_)), expected_program_id(title_id_), + program_index(program_index_), status{Loader::ResultStatus::Success}, + pfs(std::make_shared(file)), keys{Core::Crypto::KeyManager::Instance()} { if (pfs->GetStatus() != Loader::ResultStatus::Success) { status = pfs->GetStatus(); return; diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp index eaaf8cdd9..6e4d26b1e 100644 --- a/src/core/hle/service/filesystem/fsp_srv.cpp +++ b/src/core/hle/service/filesystem/fsp_srv.cpp @@ -310,8 +310,8 @@ private: class IFileSystem final : public ServiceFramework { public: explicit IFileSystem(Core::System& system_, FileSys::VirtualDir backend_, SizeGetter size_) - : ServiceFramework{system_, "IFileSystem"}, backend{std::move(backend_)}, - size{std::move(size_)} { + : ServiceFramework{system_, "IFileSystem"}, backend{std::move(backend_)}, size{std::move( + size_)} { static const FunctionInfo functions[] = { {0, &IFileSystem::CreateFile, "CreateFile"}, {1, &IFileSystem::DeleteFile, "DeleteFile"},