yuzu-emu/yuzu-android
1
0
Fork 0
mirror of https://github.com/yuzu-emu/yuzu-android.git synced 2024-11-25 22:05:41 +01:00
Code Issues Packages Projects Releases Wiki Activity

fssystem: reduce overalignment of unbuffered storage operations

Browse Source
This commit is contained in:
Liam 2023-08-10 21:49:19 -04:00
parent 86f6b6b7b2
commit 0398b34370
5 changed files with 28 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.cpp
View File

@ -17,8 +17,6 @@ Result HierarchicalIntegrityVerificationStorage::Initialize(
const HierarchicalIntegrityVerificationInformation& info,
HierarchicalStorageInformation storage, int max_data_cache_entries, int max_hash_cache_entries,
s8 buffer_level) {
using AlignedStorage = AlignmentMatchingStoragePooledBuffer<1>;
// Validate preconditions.
ASSERT(IntegrityMinLayerCount <= info.max_layers && info.max_layers <= IntegrityMaxLayerCount);
@ -38,8 +36,7 @@ Result HierarchicalIntegrityVerificationStorage::Initialize(
};
// Initialize the top level buffer storage.
m_buffer_storages[0] = std::make_shared<AlignedStorage>(
m_verify_storages[0], static_cast<s64>(1) << info.info[0].block_order);
m_buffer_storages[0] = m_verify_storages[0];
R_UNLESS(m_buffer_storages[0] != nullptr, ResultAllocationMemoryFailedAllocateShared);
// Prepare to initialize the level storages.
@ -65,8 +62,7 @@ Result HierarchicalIntegrityVerificationStorage::Initialize(
static_cast<s64>(1) << info.info[level].block_order, false);
// Initialize the buffer storage.
m_buffer_storages[level + 1] = std::make_shared<AlignedStorage>(
m_verify_storages[level + 1], static_cast<s64>(1) << info.info[level + 1].block_order);
m_buffer_storages[level + 1] = m_verify_storages[level + 1];
R_UNLESS(m_buffer_storages[level + 1] != nullptr,
ResultAllocationMemoryFailedAllocateShared);
}
@ -82,8 +78,7 @@ Result HierarchicalIntegrityVerificationStorage::Initialize(
static_cast<s64>(1) << info.info[level].block_order, true);
// Initialize the buffer storage.
m_buffer_storages[level + 1] = std::make_shared<AlignedStorage>(
m_verify_storages[level + 1], static_cast<s64>(1) << info.info[level + 1].block_order);
m_buffer_storages[level + 1] = m_verify_storages[level + 1];
R_UNLESS(m_buffer_storages[level + 1] != nullptr,
ResultAllocationMemoryFailedAllocateShared);
}

2
src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h
View File

@ -123,7 +123,7 @@ private:
private:
std::shared_ptr<IntegrityVerificationStorage> m_verify_storages[MaxLayers - 1];
std::shared_ptr<AlignmentMatchingStoragePooledBuffer<1>> m_buffer_storages[MaxLayers - 1];
VirtualFile m_buffer_storages[MaxLayers - 1];
s64 m_data_size;
s32 m_max_layers;

25
src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.cpp
View File

@ -73,31 +73,8 @@ size_t HierarchicalSha256Storage::Read(u8* buffer, size_t size, size_t offset) c
// Validate that we have a buffer to read into.
ASSERT(buffer != nullptr);
// Validate preconditions.
ASSERT(Common::IsAligned(offset, m_hash_target_block_size));
ASSERT(Common::IsAligned(size, m_hash_target_block_size));
// Read the data.
const size_t reduced_size = static_cast<size_t>(
std::min<s64>(m_base_storage_size,
Common::AlignUp(offset + size, m_hash_target_block_size)) -
offset);
m_base_storage->Read(buffer, reduced_size, offset);
// Setup tracking variables.
auto cur_offset = offset;
auto remaining_size = reduced_size;
while (remaining_size > 0) {
const auto cur_size =
static_cast<size_t>(std::min<s64>(m_hash_target_block_size, remaining_size));
ASSERT(static_cast<size_t>(cur_offset >> m_log_size_ratio) < m_hash_buffer_size);
// Advance.
cur_offset += cur_size;
remaining_size -= cur_size;
}
return size;
return m_base_storage->Read(buffer, size, offset);
}
} // namespace FileSys

4
src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp
View File

@ -48,10 +48,6 @@ void IntegrityVerificationStorage::Finalize() {
}
size_t IntegrityVerificationStorage::Read(u8* buffer, size_t size, size_t offset) const {
// Validate preconditions.
ASSERT(Common::IsAligned(offset, static_cast<size_t>(m_verification_block_size)));
ASSERT(Common::IsAligned(size, static_cast<size_t>(m_verification_block_size)));
// Succeed if zero size.
if (size == 0) {
return size;

40
src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp
View File

@ -508,12 +508,15 @@ Result NcaFileSystemDriver::CreateSparseStorageMetaStorage(VirtualFile* out,
offset + meta_offset, sparse_info.MakeAesCtrUpperIv(upper_iv),
AlignmentStorageRequirement::None));
// Create meta storage.
auto meta_storage = std::make_shared<OffsetVfsFile>(decrypted_storage, meta_size, 0);
R_UNLESS(meta_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
// Create buffered storage.
std::vector<u8> meta_data(meta_size);
decrypted_storage->Read(meta_data.data(), meta_size, 0);
auto buffered_storage = std::make_shared<VectorVfsFile>(std::move(meta_data));
R_UNLESS(buffered_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
// Set the output.
*out = std::move(meta_storage);
*out = std::move(buffered_storage);
R_SUCCEED();
}
@ -817,13 +820,15 @@ Result NcaFileSystemDriver::CreateAesCtrExStorageMetaStorage(
auto meta_storage = std::make_shared<OffsetVfsFile>(decrypted_storage, meta_size, 0);
R_UNLESS(meta_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
// Create an alignment-matching storage.
using AlignedStorage = AlignmentMatchingStorage<NcaHeader::CtrBlockSize, 1>;
auto aligned_storage = std::make_shared<AlignedStorage>(std::move(meta_storage));
R_UNLESS(aligned_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
// Create buffered storage.
std::vector<u8> meta_data(meta_size);
meta_storage->Read(meta_data.data(), meta_size, 0);
auto buffered_storage = std::make_shared<VectorVfsFile>(std::move(meta_data));
R_UNLESS(buffered_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
// Set the output.
*out = std::move(aligned_storage);
*out = std::move(buffered_storage);
R_SUCCEED();
}
@ -937,8 +942,15 @@ Result NcaFileSystemDriver::CreateIndirectStorageMetaStorage(VirtualFile* out,
patch_info.indirect_offset);
R_UNLESS(meta_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
// Create buffered storage.
std::vector<u8> meta_data(patch_info.indirect_size);
meta_storage->Read(meta_data.data(), patch_info.indirect_size, 0);
auto buffered_storage = std::make_shared<VectorVfsFile>(std::move(meta_data));
R_UNLESS(buffered_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
// Set the output.
*out = std::move(meta_storage);
*out = std::move(buffered_storage);
R_SUCCEED();
}
@ -1090,7 +1102,6 @@ Result NcaFileSystemDriver::CreateSha256Storage(
// Define storage types.
using VerificationStorage = HierarchicalSha256Storage;
using AlignedStorage = AlignmentMatchingStoragePooledBuffer<1>;
// Validate the hash data.
R_UNLESS(Common::IsPowerOfTwo(hash_data.hash_block_size),
@ -1141,13 +1152,8 @@ Result NcaFileSystemDriver::CreateSha256Storage(
hash_data.hash_block_size,
buffer_hold_storage->GetBuffer(), hash_buffer_size));
// Make the aligned storage.
auto aligned_storage = std::make_shared<AlignedStorage>(std::move(verification_storage),
hash_data.hash_block_size);
R_UNLESS(aligned_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
// Set the output.
*out = std::move(aligned_storage);
*out = std::move(verification_storage);
R_SUCCEED();
}