mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2024-11-08 05:01:44 +00:00
Code Issues Releases Activity

strat: revise fs unsupported operation results, add overflow utils

Browse source
This commit is contained in:
Michael Scire 2022-03-13 01:32:34 -08:00 committed by SciresM
parent ba4e7c5866
commit 11e4bed199
31 changed files with 265 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
fusee/program/source/fs/fusee_fs_storage.hpp
View file

@ -118,7 +118,7 @@ namespace ams::fs {
}
virtual Result SetSize(s64 size) override {
return fs::ResultUnsupportedOperationInSubStorageA();
return fs::ResultUnsupportedSetSizeForNotResizableSubStorage();
}
};

4
libraries/libstratosphere/include/stratosphere/fs/fs_memory_storage.hpp
View file

@ -64,7 +64,7 @@ namespace ams::fs {
virtual Result SetSize(s64 size) override {
AMS_UNUSED(size);
return fs::ResultUnsupportedOperationInMemoryStorageA();
return fs::ResultUnsupportedSetSizeForMemoryStorage();
}
virtual Result OperateRange(void *dst, size_t dst_size, OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
@ -79,7 +79,7 @@ namespace ams::fs {
reinterpret_cast<QueryRangeInfo *>(dst)->Clear();
return ResultSuccess();
default:
return fs::ResultUnsupportedOperationInMemoryStorageB();
return fs::ResultUnsupportedOperateRangeForMemoryStorage();
}
}
};

28
libraries/libstratosphere/include/stratosphere/fs/fs_read_only_filesystem.hpp
View file

@ -52,12 +52,12 @@ namespace ams::fs {
AMS_ASSERT(!need_append);
AMS_UNUSED(buffer);
return fs::ResultUnsupportedOperationInReadOnlyFileA();
return fs::ResultUnsupportedWriteForReadOnlyFile();
}
virtual Result DoSetSize(s64 size) override final {
R_TRY(this->DrySetSize(size, fs::OpenMode_Read));
return fs::ResultUnsupportedOperationInReadOnlyFileA();
return fs::ResultUnsupportedWriteForReadOnlyFile();
}
virtual Result DoOperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override final {
@ -66,7 +66,7 @@ namespace ams::fs {
case OperationId::QueryRange:
return m_base_file->OperateRange(dst, dst_size, op_id, offset, size, src, src_size);
default:
return fs::ResultUnsupportedOperationInReadOnlyFileB();
return fs::ResultUnsupportedOperateRangeForReadOnlyFile();
}
}
public:
@ -115,57 +115,57 @@ namespace ams::fs {
virtual Result DoCreateFile(const fs::Path &path, s64 size, int flags) override final {
AMS_UNUSED(path, size, flags);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
return fs::ResultUnsupportedWriteForReadOnlyFileSystem();
}
virtual Result DoDeleteFile(const fs::Path &path) override final {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
return fs::ResultUnsupportedWriteForReadOnlyFileSystem();
}
virtual Result DoCreateDirectory(const fs::Path &path) override final {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
return fs::ResultUnsupportedWriteForReadOnlyFileSystem();
}
virtual Result DoDeleteDirectory(const fs::Path &path) override final {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
return fs::ResultUnsupportedWriteForReadOnlyFileSystem();
}
virtual Result DoDeleteDirectoryRecursively(const fs::Path &path) override final {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
return fs::ResultUnsupportedWriteForReadOnlyFileSystem();
}
virtual Result DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) override final {
AMS_UNUSED(old_path, new_path);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
return fs::ResultUnsupportedWriteForReadOnlyFileSystem();
}
virtual Result DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) override final {
AMS_UNUSED(old_path, new_path);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
return fs::ResultUnsupportedWriteForReadOnlyFileSystem();
}
virtual Result DoCleanDirectoryRecursively(const fs::Path &path) override final {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
return fs::ResultUnsupportedWriteForReadOnlyFileSystem();
}
virtual Result DoGetFreeSpaceSize(s64 *out, const fs::Path &path) override final {
AMS_UNUSED(out, path);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateB();
return fs::ResultUnsupportedCommitProvisionallyForReadOnlyFileSystem();
}
virtual Result DoGetTotalSpaceSize(s64 *out, const fs::Path &path) override final {
AMS_UNUSED(out, path);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateB();
return fs::ResultUnsupportedCommitProvisionallyForReadOnlyFileSystem();
}
virtual Result DoCommitProvisionally(s64 counter) override final {
AMS_UNUSED(counter);
return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateC();
return fs::ResultUnsupportedGetTotalSpaceSizeForReadOnlyFileSystem();
}
};

2
libraries/libstratosphere/include/stratosphere/fs/fs_remote_filesystem.hpp
View file

@ -57,7 +57,7 @@ namespace ams::fs {
virtual Result DoOperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override final {
AMS_UNUSED(src, src_size);
R_UNLESS(op_id == OperationId::QueryRange, fs::ResultUnsupportedOperationInFileServiceObjectAdapterA());
R_UNLESS(op_id == OperationId::QueryRange, fs::ResultUnsupportedOperateRangeForFileServiceObjectAdapter());
R_UNLESS(dst_size == sizeof(FileQueryRangeInfo), fs::ResultInvalidSize());
return fsFileOperateRange(std::addressof(m_base_file), static_cast<::FsOperationId>(op_id), offset, size, reinterpret_cast<::FsRangeInfo *>(dst));

6
libraries/libstratosphere/include/stratosphere/fs/fs_substorage.hpp
View file

@ -107,13 +107,13 @@ namespace ams::fs {
virtual Result SetSize(s64 size) override {
/* Ensure we're initialized and validate arguments. */
R_UNLESS(this->IsValid(), fs::ResultNotInitialized());
R_UNLESS(m_resizable, fs::ResultUnsupportedOperationInSubStorageA());
R_UNLESS(m_resizable, fs::ResultUnsupportedSetSizeForNotResizableSubStorage());
R_UNLESS(IStorage::CheckOffsetAndSize(m_offset, size), fs::ResultInvalidSize());
/* Ensure that we're allowed to set size. */
s64 cur_size;
R_TRY(m_base_storage->GetSize(std::addressof(cur_size)));
R_UNLESS(cur_size == m_offset + m_size, fs::ResultUnsupportedOperationInSubStorageB());
R_UNLESS(cur_size == m_offset + m_size, fs::ResultUnsupportedSetSizeForResizableSubStorage());
/* Set the size. */
R_TRY(m_base_storage->SetSize(m_offset + size));
@ -132,7 +132,7 @@ namespace ams::fs {
virtual Result OperateRange(void *dst, size_t dst_size, OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
/* Ensure we're initialized. */
R_UNLESS(this->IsValid(), fs::ResultNotInitialized());
R_UNLESS(this->IsValid(), fs::ResultNotInitialized());
/* Succeed immediately on zero-sized operation. */
R_SUCCEED_IF(size == 0);

4
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_aes_ctr_counter_extended_storage.hpp
View file

@ -109,12 +109,12 @@ namespace ams::fssystem {
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
AMS_UNUSED(offset, buffer, size);
R_THROW(fs::ResultUnsupportedOperationInAesCtrCounterExtendedStorageA());
R_THROW(fs::ResultUnsupportedWriteForAesCtrCounterExtendedStorage());
}
virtual Result SetSize(s64 size) override {
AMS_UNUSED(size);
R_THROW(fs::ResultUnsupportedOperationInAesCtrCounterExtendedStorageB());
R_THROW(fs::ResultUnsupportedSetSizeForAesCtrCounterExtendedStorage());
}
private:
Result Initialize(IAllocator *allocator, const void *key, size_t key_size, u32 secure_value, fs::SubStorage data_storage, fs::SubStorage table_storage);

2
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_block_cache_buffered_storage.hpp
View file

@ -110,7 +110,7 @@ namespace ams::fssystem {
virtual Result Read(s64 offset, void *buffer, size_t size) override;
virtual Result Write(s64 offset, const void *buffer, size_t size) override;
virtual Result SetSize(s64) override { R_THROW(fs::ResultUnsupportedOperationInBlockCacheBufferedStorageA()); }
virtual Result SetSize(s64) override { R_THROW(fs::ResultUnsupportedSetSizeForBlockCacheBufferedStorage()); }
virtual Result GetSize(s64 *out) override;
virtual Result Flush() override;

6
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_compressed_storage.hpp
View file

@ -1424,7 +1424,7 @@ namespace ams::fssystem {
R_TRY(m_core.QueryRange(dst, dst_size, offset, size));
break;
default:
R_THROW(fs::ResultUnsupportedOperationInCompressedStorageB());
R_THROW(fs::ResultUnsupportedOperateRangeForCompressedStorage());
}
R_SUCCEED();
@ -1440,13 +1440,13 @@ namespace ams::fssystem {
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
AMS_UNUSED(offset, buffer, size);
R_THROW(fs::ResultUnsupportedOperationInCompressedStorageA());
R_THROW(fs::ResultUnsupportedWriteForCompressedStorage());
}
virtual Result SetSize(s64 size) override {
AMS_UNUSED(size);
/* NOTE: Is Nintendo returning the wrong result here? */
R_THROW(fs::ResultUnsupportedOperationInIndirectStorageB());
R_THROW(fs::ResultUnsupportedSetSizeForIndirectStorage());
}
};

2
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_hierarchical_integrity_verification_storage.hpp
View file

@ -162,7 +162,7 @@ namespace ams::fssystem {
virtual Result Read(s64 offset, void *buffer, size_t size) override;
virtual Result Write(s64 offset, const void *buffer, size_t size) override;
virtual Result SetSize(s64 size) override { AMS_UNUSED(size); return fs::ResultUnsupportedOperationInHierarchicalIntegrityVerificationStorageA(); }
virtual Result SetSize(s64 size) override { AMS_UNUSED(size); return fs::ResultUnsupportedSetSizeForHierarchicalIntegrityVerificationStorage(); }
virtual Result GetSize(s64 *out) override;
virtual Result Flush() override;

4
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_indirect_storage.hpp
View file

@ -147,12 +147,12 @@ namespace ams::fssystem {
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
AMS_UNUSED(offset, buffer, size);
R_THROW(fs::ResultUnsupportedOperationInIndirectStorageA());
R_THROW(fs::ResultUnsupportedWriteForIndirectStorage());
}
virtual Result SetSize(s64 size) override {
AMS_UNUSED(size);
R_THROW(fs::ResultUnsupportedOperationInIndirectStorageB());
R_THROW(fs::ResultUnsupportedSetSizeForIndirectStorage());
}
protected:
BucketTree &GetEntryTable() { return m_table; }

2
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_integrity_romfs_storage.hpp
View file

@ -48,7 +48,7 @@ namespace ams::fssystem {
return m_integrity_storage.Write(offset, buffer, size);
}
virtual Result SetSize(s64 size) override { AMS_UNUSED(size); return fs::ResultUnsupportedOperationInIntegrityRomFsStorageA(); }
virtual Result SetSize(s64 size) override { AMS_UNUSED(size); return fs::ResultUnsupportedSetSizeForIntegrityRomFsStorage(); }
virtual Result GetSize(s64 *out) override {
return m_integrity_storage.GetSize(out);

2
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_integrity_verification_storage.hpp
View file

@ -55,7 +55,7 @@ namespace ams::fssystem {
virtual Result Read(s64 offset, void *buffer, size_t size) override;
virtual Result Write(s64 offset, const void *buffer, size_t size) override;
virtual Result SetSize(s64 size) override { AMS_UNUSED(size); return fs::ResultUnsupportedOperationInIntegrityVerificationStorageA(); }
virtual Result SetSize(s64 size) override { AMS_UNUSED(size); return fs::ResultUnsupportedSetSizeForIntegrityVerificationStorage(); }
virtual Result GetSize(s64 *out) override;
virtual Result Flush() override;

4
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_sparse_storage.hpp
View file

@ -56,12 +56,12 @@ namespace ams::fssystem {
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
AMS_UNUSED(offset, buffer, size);
R_THROW(fs::ResultUnsupportedOperationInZeroStorageA());
R_THROW(fs::ResultUnsupportedWriteForZeroStorage());
}
virtual Result SetSize(s64 size) override {
AMS_UNUSED(size);
R_THROW(fs::ResultUnsupportedOperationInZeroStorageB());
R_THROW(fs::ResultUnsupportedSetSizeForZeroStorage());
}
};
private:

4
libraries/libstratosphere/source/fs/common/fs_file_storage.cpp
View file

@ -86,7 +86,7 @@ namespace ams::fs {
R_UNLESS(IStorage::CheckOffsetAndSize(offset, size), fs::ResultOutOfRange());
return m_base_file->OperateRange(dst, dst_size, op_id, offset, size, src, src_size);
default:
return fs::ResultUnsupportedOperationInFileStorageA();
return fs::ResultUnsupportedOperateRangeForFileStorage();
}
}
@ -171,7 +171,7 @@ namespace ams::fs {
return QueryRange(static_cast<QueryRangeInfo *>(dst), m_handle, offset, size);
default:
return fs::ResultUnsupportedOperationInFileStorageB();
return fs::ResultUnsupportedOperateRangeForFileHandleStorage();
}
}

26
libraries/libstratosphere/source/fs/fs_romfs_filesystem.cpp
View file

@ -221,12 +221,12 @@ namespace ams::fs {
virtual Result DoWrite(s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) override {
AMS_UNUSED(offset, buffer, size, option);
return fs::ResultUnsupportedOperationInRomFsFileA();
return fs::ResultUnsupportedWriteForRomFsFile();
}
virtual Result DoSetSize(s64 size) override {
AMS_UNUSED(size);
return fs::ResultUnsupportedOperationInRomFsFileA();
return fs::ResultUnsupportedWriteForRomFsFile();
}
virtual Result DoOperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
@ -245,7 +245,7 @@ namespace ams::fs {
return this->GetStorage()->OperateRange(dst, dst_size, op_id, m_start + offset, operate_size, src, src_size);
}
default:
return fs::ResultUnsupportedOperationInRomFsFileB();
return fs::ResultUnsupportedOperateRangeForRomFsFile();
}
}
public:
@ -447,37 +447,37 @@ namespace ams::fs {
Result RomFsFileSystem::DoCreateFile(const fs::Path &path, s64 size, int flags) {
AMS_UNUSED(path, size, flags);
return fs::ResultUnsupportedOperationInRomFsFileSystemA();
return fs::ResultUnsupportedWriteForRomFsFileSystem();
}
Result RomFsFileSystem::DoDeleteFile(const fs::Path &path) {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInRomFsFileSystemA();
return fs::ResultUnsupportedWriteForRomFsFileSystem();
}
Result RomFsFileSystem::DoCreateDirectory(const fs::Path &path) {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInRomFsFileSystemA();
return fs::ResultUnsupportedWriteForRomFsFileSystem();
}
Result RomFsFileSystem::DoDeleteDirectory(const fs::Path &path) {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInRomFsFileSystemA();
return fs::ResultUnsupportedWriteForRomFsFileSystem();
}
Result RomFsFileSystem::DoDeleteDirectoryRecursively(const fs::Path &path) {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInRomFsFileSystemA();
return fs::ResultUnsupportedWriteForRomFsFileSystem();
}
Result RomFsFileSystem::DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) {
AMS_UNUSED(old_path, new_path);
return fs::ResultUnsupportedOperationInRomFsFileSystemA();
return fs::ResultUnsupportedWriteForRomFsFileSystem();
}
Result RomFsFileSystem::DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) {
AMS_UNUSED(old_path, new_path);
return fs::ResultUnsupportedOperationInRomFsFileSystemA();
return fs::ResultUnsupportedWriteForRomFsFileSystem();
}
Result RomFsFileSystem::DoGetEntryType(fs::DirectoryEntryType *out, const fs::Path &path) {
@ -540,17 +540,17 @@ namespace ams::fs {
Result RomFsFileSystem::DoGetTotalSpaceSize(s64 *out, const fs::Path &path) {
AMS_UNUSED(out, path);
return fs::ResultUnsupportedOperationInRomFsFileSystemC();
return fs::ResultUnsupportedGetTotalSpaceSizeForRomFsFileSystem();
}
Result RomFsFileSystem::DoCleanDirectoryRecursively(const fs::Path &path) {
AMS_UNUSED(path);
return fs::ResultUnsupportedOperationInRomFsFileSystemA();
return fs::ResultUnsupportedWriteForRomFsFileSystem();
}
Result RomFsFileSystem::DoCommitProvisionally(s64 counter) {
AMS_UNUSED(counter);
return fs::ResultUnsupportedOperationInRomFsFileSystemB();
return fs::ResultUnsupportedCommitProvisionallyForRomFsFileSystem();
}
Result RomFsFileSystem::DoRollback() {

2
libraries/libstratosphere/source/fs/impl/fs_storage_service_object_adapter.hpp
View file

@ -64,7 +64,7 @@ namespace ams::fs::impl {
}
default:
{
R_THROW(fs::ResultUnsupportedOperationInStorageServiceObjectAdapterA());
R_THROW(fs::ResultUnsupportedOperateRangeForStorageServiceObjectAdapter());
}
}
}

2
libraries/libstratosphere/source/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp
View file

@ -245,7 +245,7 @@ namespace ams::fssystem {
return ResultSuccess();
}
default:
return fs::ResultUnsupportedOperationInAesCtrCounterExtendedStorageC();
return fs::ResultUnsupportedOperateRangeForAesCtrCounterExtendedStorage();
}
}

2
libraries/libstratosphere/source/fssystem/fssystem_aes_ctr_storage.cpp
View file

@ -135,7 +135,7 @@ namespace ams::fssystem {
template<typename BasePointer>
Result AesCtrStorage<BasePointer>::SetSize(s64 size) {
AMS_UNUSED(size);
return fs::ResultUnsupportedOperationInAesCtrStorageA();
return fs::ResultUnsupportedSetSizeForAesCtrStorage();
}
template<typename BasePointer>

4
libraries/libstratosphere/source/fssystem/fssystem_block_cache_buffered_storage.cpp
View file

@ -395,7 +395,7 @@ namespace ams::fssystem {
}
case fs::OperationId::Invalidate:
{
R_UNLESS(m_storage_type != fs::StorageType_SaveData, fs::ResultUnsupportedOperationInBlockCacheBufferedStorageB());
R_UNLESS(m_storage_type != fs::StorageType_SaveData, fs::ResultUnsupportedOperateRangeForNonSaveDataBlockCacheBufferedStorage());
R_TRY(this->InvalidateImpl());
R_SUCCEED();
}
@ -405,7 +405,7 @@ namespace ams::fssystem {
R_SUCCEED();
}
default:
R_THROW(fs::ResultUnsupportedOperationInBlockCacheBufferedStorageC());
R_THROW(fs::ResultUnsupportedOperateRangeForBlockCacheBufferedStorage());
}
}

2
libraries/libstratosphere/source/fssystem/fssystem_directory_savedata_filesystem.cpp
View file

@ -348,7 +348,7 @@ namespace ams::fssystem {
Result DirectorySaveDataFileSystem::DoCommitProvisionally(s64 counter) {
/* Check that we support multi-commit. */
R_UNLESS(m_is_multi_commit_supported, fs::ResultUnsupportedOperationInDirectorySaveDataFileSystemA());
R_UNLESS(m_is_multi_commit_supported, fs::ResultUnsupportedCommitProvisionallyForDirectorySaveDataFileSystem());
/* Do nothing. */
AMS_UNUSED(counter);

2
libraries/libstratosphere/source/fssystem/fssystem_hierarchical_integrity_verification_storage.cpp
View file

@ -330,7 +330,7 @@ namespace ams::fssystem {
return ResultSuccess();
}
default:
return fs::ResultUnsupportedOperationInHierarchicalIntegrityVerificationStorageB();
return fs::ResultUnsupportedOperateRangeForHierarchicalIntegrityVerificationStorage();
}
}

2
libraries/libstratosphere/source/fssystem/fssystem_hierarchical_sha256_storage.hpp
View file

@ -53,7 +53,7 @@ namespace ams::fssystem {
virtual Result SetSize(s64 size) override {
AMS_UNUSED(size);
return fs::ResultUnsupportedOperationInHierarchicalSha256StorageA();
return fs::ResultUnsupportedSetSizeForHierarchicalSha256Storage();
}
};

2
libraries/libstratosphere/source/fssystem/fssystem_indirect_storage.cpp
View file

@ -171,7 +171,7 @@ namespace ams::fssystem {
R_SUCCEED();
}
default:
return fs::ResultUnsupportedOperationInIndirectStorageC();
return fs::ResultUnsupportedOperateRangeForIndirectStorage();
}
R_SUCCEED();

4
libraries/libstratosphere/source/fssystem/fssystem_integrity_verification_storage.cpp
View file

@ -332,7 +332,7 @@ namespace ams::fssystem {
case fs::OperationId::Invalidate:
{
/* Only allow cache invalidation for RomFs. */
R_UNLESS(m_storage_type != fs::StorageType_SaveData, fs::ResultUnsupportedOperationInIntegrityVerificationStorageB());
R_UNLESS(m_storage_type != fs::StorageType_SaveData, fs::ResultUnsupportedOperateRangeForNonSaveDataIntegrityVerificationStorage());
/* Operate on our storages. */
@ -357,7 +357,7 @@ namespace ams::fssystem {
return ResultSuccess();
}
default:
return fs::ResultUnsupportedOperationInIntegrityVerificationStorageC();
return fs::ResultUnsupportedOperateRangeForIntegrityVerificationStorage();
}
}

4
libraries/libstratosphere/source/fssystem/fssystem_local_file_system.cpp
View file

@ -303,7 +303,7 @@ namespace ams::fssystem {
static_cast<fs::QueryRangeInfo *>(dst)->Clear();
R_SUCCEED();
default:
R_THROW(fs::ResultUnsupportedOperationInLocalFileA());
R_THROW(fs::ResultUnsupportedOperateRangeForTmFileSystemFile());
}
}
public:
@ -619,7 +619,7 @@ namespace ams::fssystem {
static_cast<fs::QueryRangeInfo *>(dst)->Clear();
R_SUCCEED();
default:
R_THROW(fs::ResultUnsupportedOperationInLocalFileA());
R_THROW(fs::ResultUnsupportedOperateRangeForTmFileSystemFile());
}
}
public:

6
libraries/libstratosphere/source/fssystem/fssystem_nca_file_system_driver.cpp
View file

@ -212,12 +212,12 @@ namespace ams::fssystem {
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
AMS_UNUSED(offset, buffer, size);
return fs::ResultUnsupportedOperationInAesCtrStorageExternalA();
return fs::ResultUnsupportedWriteForAesCtrStorageExternal();
}
virtual Result SetSize(s64 size) override {
AMS_UNUSED(size);
return fs::ResultUnsupportedOperationInAesCtrStorageExternalB();
return fs::ResultUnsupportedSetSizeForAesCtrStorageExternal();
}
};
@ -254,7 +254,7 @@ namespace ams::fssystem {
return ResultSuccess();
}
default:
return fs::ResultUnsupportedOperationInSwitchStorageA();
return fs::ResultUnsupportedOperateRangeForSwitchStorage();
}
}

26
libraries/libstratosphere/source/fssystem/fssystem_partition_file_system.cpp
View file

@ -70,7 +70,7 @@ namespace ams::fssystem {
/* Ensure appending is not required. */
bool needs_append;
R_TRY(this->DryWrite(std::addressof(needs_append), offset, size, option, m_mode));
R_UNLESS(!needs_append, fs::ResultUnsupportedOperationInPartitionFileA());
R_UNLESS(!needs_append, fs::ResultUnsupportedWriteForPartitionFile());
/* Appending is prohibited. */
AMS_ASSERT((m_mode & fs::OpenMode_AllowAppend) == 0);
@ -85,7 +85,7 @@ namespace ams::fssystem {
virtual Result DoSetSize(s64 size) override final {
R_TRY(this->DrySetSize(size, m_mode));
R_RETURN(fs::ResultUnsupportedOperationInPartitionFileA());
R_RETURN(fs::ResultUnsupportedWriteForPartitionFile());
}
virtual Result DoOperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override final {
@ -93,12 +93,12 @@ namespace ams::fssystem {
switch (op_id) {
case fs::OperationId::Invalidate:
R_UNLESS((m_mode & fs::OpenMode_Read) != 0, fs::ResultReadNotPermitted());
R_UNLESS((m_mode & fs::OpenMode_Write) == 0, fs::ResultUnsupportedOperationInPartitionFileB());
R_UNLESS((m_mode & fs::OpenMode_Write) == 0, fs::ResultUnsupportedOperateRangeForPartitionFile());
break;
case fs::OperationId::QueryRange:
break;
default:
R_THROW(fs::ResultUnsupportedOperationInPartitionFileB());
R_THROW(fs::ResultUnsupportedOperateRangeForPartitionFile());
}
/* Validate offset and size. */
@ -408,55 +408,55 @@ namespace ams::fssystem {
template <typename MetaType>
Result PartitionFileSystemCore<MetaType>::DoCleanDirectoryRecursively(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInPartitionFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForPartitionFileSystem());
}
template <typename MetaType>
Result PartitionFileSystemCore<MetaType>::DoCreateDirectory(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInPartitionFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForPartitionFileSystem());
}
template <typename MetaType>
Result PartitionFileSystemCore<MetaType>::DoCreateFile(const fs::Path &path, s64 size, int option) {
AMS_UNUSED(path, size, option);
R_THROW(fs::ResultUnsupportedOperationInPartitionFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForPartitionFileSystem());
}
template <typename MetaType>
Result PartitionFileSystemCore<MetaType>::DoDeleteDirectory(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInPartitionFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForPartitionFileSystem());
}
template <typename MetaType>
Result PartitionFileSystemCore<MetaType>::DoDeleteDirectoryRecursively(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInPartitionFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForPartitionFileSystem());
}
template <typename MetaType>
Result PartitionFileSystemCore<MetaType>::DoDeleteFile(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInPartitionFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForPartitionFileSystem());
}
template <typename MetaType>
Result PartitionFileSystemCore<MetaType>::DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) {
AMS_UNUSED(old_path, new_path);
R_THROW(fs::ResultUnsupportedOperationInPartitionFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForPartitionFileSystem());
}
template <typename MetaType>
Result PartitionFileSystemCore<MetaType>::DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) {
AMS_UNUSED(old_path, new_path);
R_THROW(fs::ResultUnsupportedOperationInPartitionFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForPartitionFileSystem());
}
template <typename MetaType>
Result PartitionFileSystemCore<MetaType>::DoCommitProvisionally(s64 counter) {
AMS_UNUSED(counter);
R_THROW(fs::ResultUnsupportedOperationInPartitionFileSystemB());
R_THROW(fs::ResultUnsupportedCommitProvisionallyForPartitionFileSystem());
}
template class PartitionFileSystemCore<PartitionFileSystemMeta>;

4
libraries/libstratosphere/source/fssystem/fssystem_read_only_block_cache_storage.hpp
View file

@ -119,12 +119,12 @@ namespace ams::fssystem {
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
AMS_UNUSED(offset, buffer, size);
return fs::ResultUnsupportedOperationInReadOnlyBlockCacheStorageA();
return fs::ResultUnsupportedWriteForReadOnlyBlockCacheStorage();
}
virtual Result SetSize(s64 size) override {
AMS_UNUSED(size);
return fs::ResultUnsupportedOperationInReadOnlyBlockCacheStorageB();
return fs::ResultUnsupportedSetSizeForReadOnlyBlockCacheStorage();
}
};

24
libraries/libstratosphere/source/fssystem/fssystem_romfs_filesystem.cpp
View file

@ -66,12 +66,12 @@ namespace ams::fssystem {
R_TRY(this->DryWrite(std::addressof(needs_append), offset, size, option, fs::OpenMode_Read));
AMS_ASSERT(needs_append == false);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFile());
}
virtual Result DoSetSize(s64 size) override {
R_TRY(this->DrySetSize(size, fs::OpenMode_Read));
R_THROW(fs::ResultUnsupportedOperationInRomFsFileA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFile());
}
virtual Result DoOperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
@ -94,7 +94,7 @@ namespace ams::fssystem {
R_SUCCEED();
}
default:
R_THROW(fs::ResultUnsupportedOperationInRomFsFileB());
R_THROW(fs::ResultUnsupportedOperateRangeForRomFsFile());
}
}
public:
@ -303,37 +303,37 @@ namespace ams::fssystem {
Result RomFsFileSystem::DoCreateFile(const fs::Path &path, s64 size, int flags) {
AMS_UNUSED(path, size, flags);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFileSystem());
}
Result RomFsFileSystem::DoDeleteFile(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFileSystem());
}
Result RomFsFileSystem::DoCreateDirectory(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFileSystem());
}
Result RomFsFileSystem::DoDeleteDirectory(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFileSystem());
}
Result RomFsFileSystem::DoDeleteDirectoryRecursively(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFileSystem());
}
Result RomFsFileSystem::DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) {
AMS_UNUSED(old_path, new_path);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFileSystem());
}
Result RomFsFileSystem::DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) {
AMS_UNUSED(old_path, new_path);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFileSystem());
}
Result RomFsFileSystem::DoGetEntryType(fs::DirectoryEntryType *out, const fs::Path &path) {
@ -407,12 +407,12 @@ namespace ams::fssystem {
Result RomFsFileSystem::DoCleanDirectoryRecursively(const fs::Path &path) {
AMS_UNUSED(path);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileSystemA());
R_THROW(fs::ResultUnsupportedWriteForRomFsFileSystem());
}
Result RomFsFileSystem::DoCommitProvisionally(s64 counter) {
AMS_UNUSED(counter);
R_THROW(fs::ResultUnsupportedOperationInRomFsFileSystemB());
R_THROW(fs::ResultUnsupportedCommitProvisionallyForRomFsFileSystem());
}
}

136
libraries/libvapours/include/vapours/results/fs_results.hpp
View file

@ -346,56 +346,92 @@ namespace ams::fs {
R_DEFINE_ERROR_RESULT(WriteNotPermitted, 6203);
R_DEFINE_ERROR_RANGE(UnsupportedOperation, 6300, 6399);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInSubStorageA, 6302);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInSubStorageB, 6303);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInMemoryStorageA, 6304);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInMemoryStorageB, 6305);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInFileStorageA, 6306);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInFileStorageB, 6307);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInSwitchStorageA, 6308);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInStorageServiceObjectAdapterA, 6309);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInAesCtrCounterExtendedStorageA, 6310);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInAesCtrCounterExtendedStorageB, 6311);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInAesCtrCounterExtendedStorageC, 6312);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInAesCtrStorageExternalA, 6313);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInAesCtrStorageExternalB, 6314);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInAesCtrStorageA, 6315);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInHierarchicalIntegrityVerificationStorageA, 6316);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInHierarchicalIntegrityVerificationStorageB, 6317);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInIntegrityVerificationStorageA, 6318);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInIntegrityVerificationStorageB, 6319);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInIntegrityVerificationStorageC, 6320);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInBlockCacheBufferedStorageA, 6321);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInBlockCacheBufferedStorageB, 6322);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInBlockCacheBufferedStorageC, 6323);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInIndirectStorageA, 6324);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInIndirectStorageB, 6325);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInIndirectStorageC, 6326);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInZeroStorageA, 6327);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInZeroStorageB, 6328);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInHierarchicalSha256StorageA, 6329);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInReadOnlyBlockCacheStorageA, 6330);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInReadOnlyBlockCacheStorageB, 6331);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInIntegrityRomFsStorageA , 6332);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInFileServiceObjectAdapterA, 6362);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInRomFsFileSystemA, 6364);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInRomFsFileSystemB, 6365);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInRomFsFileSystemC, 6366);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInRomFsFileA, 6367);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInRomFsFileB, 6368);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInReadOnlyFileSystemTemplateA, 6369);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInReadOnlyFileSystemTemplateB, 6370);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInReadOnlyFileSystemTemplateC, 6371);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInReadOnlyFileA, 6372);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInReadOnlyFileB, 6373);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInPartitionFileSystemA, 6374);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInPartitionFileSystemB, 6375);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInPartitionFileA, 6376);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInPartitionFileB, 6377);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInLocalFileA, 6378);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInDirectorySaveDataFileSystemA, 6384);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInCompressedStorageA, 6387);
R_DEFINE_ERROR_RESULT(UnsupportedOperationInCompressedStorageB, 6388);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForNotResizableSubStorage, 6302);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForResizableSubStorage, 6303);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForMemoryStorage, 6304);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForMemoryStorage, 6305);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForFileStorage, 6306);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForFileHandleStorage, 6307);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForSwitchStorage, 6308);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForStorageServiceObjectAdapter, 6309);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForAesCtrCounterExtendedStorage, 6310);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForAesCtrCounterExtendedStorage, 6311);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForAesCtrCounterExtendedStorage, 6312);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForAesCtrStorageExternal, 6313);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForAesCtrStorageExternal, 6314);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForAesCtrStorage, 6315);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForHierarchicalIntegrityVerificationStorage, 6316);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForHierarchicalIntegrityVerificationStorage, 6317);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForIntegrityVerificationStorage, 6318);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForNonSaveDataIntegrityVerificationStorage, 6319);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForIntegrityVerificationStorage, 6320);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForBlockCacheBufferedStorage, 6321);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForNonSaveDataBlockCacheBufferedStorage, 6322);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForBlockCacheBufferedStorage, 6323);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForIndirectStorage, 6324);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForIndirectStorage, 6325);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForIndirectStorage, 6326);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForZeroStorage, 6327);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForZeroStorage, 6328);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForHierarchicalSha256Storage, 6329);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForReadOnlyBlockCacheStorage, 6330);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForReadOnlyBlockCacheStorage, 6331);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForIntegrityRomFsStorage, 6332);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForDuplexStorage, 6333);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForDuplexStorage, 6334);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForHierarchicalDuplexStorage, 6335);
R_DEFINE_ERROR_RESULT(UnsupportedGetSizeForRemapStorage, 6336);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForRemapStorage, 6337);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForRemapStorage, 6338);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForIntegritySaveDataStorage, 6339);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForIntegritySaveDataStorage, 6340);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForJournalIntegritySaveDataStorage, 6341);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForJournalIntegritySaveDataStorage, 6342);
R_DEFINE_ERROR_RESULT(UnsupportedGetSizeForJournalStorage, 6343);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForJournalStorage, 6344);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForJournalStorage, 6345);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForUnionStorage, 6346);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForAllocationTableStorage, 6347);
R_DEFINE_ERROR_RESULT(UnsupportedReadForWriteOnlyGameCardStorage, 6348);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForWriteOnlyGameCardStorage, 6349);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForReadOnlyGameCardStorage, 6350);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForReadOnlyGameCardStorage, 6351);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForReadOnlyGameCardStorage, 6352);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForSdmmcStorage, 6353);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForSdmmcStorage, 6354);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForFatFile, 6355);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForStorageFile, 6356);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForInternalStorageConcatenationFile, 6357);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForInternalStorageConcatenationFile, 6358);
R_DEFINE_ERROR_RESULT(UnsupportedQueryEntryForConcatenationFileSystem, 6359);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForConcatenationFile, 6360);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForZeroBitmapFile, 6361);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForFileServiceObjectAdapter, 6362);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForAesXtsFile, 6363);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForRomFsFileSystem, 6364);
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForRomFsFileSystem, 6365);
R_DEFINE_ERROR_RESULT(UnsupportedGetTotalSpaceSizeForRomFsFileSystem, 6366);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForRomFsFile, 6367);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForRomFsFile, 6368);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForReadOnlyFileSystem, 6369);
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForReadOnlyFileSystem, 6370);
R_DEFINE_ERROR_RESULT(UnsupportedGetTotalSpaceSizeForReadOnlyFileSystem, 6371);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForReadOnlyFile, 6372);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForReadOnlyFile, 6373);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForPartitionFileSystem, 6374);
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForPartitionFileSystem, 6375);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForPartitionFile, 6376);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForPartitionFile, 6377);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForTmFileSystemFile, 6378);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForSaveDataInternalStorageFileSystem, 6379);
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForApplicationTemporaryFileSystem, 6382);
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForSaveDataFileSystem, 6383);
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForDirectorySaveDataFileSystem, 6384);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForZeroBitmapHashStorageFile, 6385);
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForZeroBitmapHashStorageFile, 6386);
R_DEFINE_ERROR_RESULT(UnsupportedWriteForCompressedStorage, 6387);
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForCompressedStorage, 6388);
R_DEFINE_ERROR_RANGE(PermissionDenied, 6400, 6449);
R_DEFINE_ERROR_RESULT(PermissionDeniedForCreateHostFileSystem, 6403);

87
libraries/libvapours/include/vapours/util/util_int_util.hpp
View file

@ -69,4 +69,91 @@ namespace ams::util {
return ::ams::util::impl::IsIntValueRepresentableImpl<To, From>(v);
}
template<std::integral T>
constexpr ALWAYS_INLINE bool CanAddWithoutOverflow(T x, T y) {
if constexpr (std::unsigned_integral<T>) {
return x <= std::numeric_limits<T>::max() - y;
} else {
if (y >= 0) {
return x <= std::numeric_limits<T>::max() - y;
} else {
return x >= std::numeric_limits<T>::min() - y;
}
}
}
template<std::integral T>
constexpr ALWAYS_INLINE bool CanSubtractWithoutOverflow(T x, T y) {
if constexpr (std::unsigned_integral<T>) {
return x >= std::numeric_limits<T>::min() + y;
} else {
if (y >= 0) {
return x >= std::numeric_limits<T>::min() + y;
} else {
return x <= std::numeric_limits<T>::max() + y;
}
}
}
template<std::integral T>
constexpr ALWAYS_INLINE bool CanMultiplyWithoutOverflow(T x, T y) {
if (x == 0 || y == 0) {
return true;
}
if constexpr (std::unsigned_integral<T>) {
return y <= std::numeric_limits<T>::max() / x;
} else {
if (x > 0) {
if (y > 0) {
return y <= std::numeric_limits<T>::max() / x;
} else /*if (y < 0) */ {
return y >= std::numeric_limits<T>::min() / x;
}
} else /* if (x < 0) */ {
if (y > 0) {
return x >= std::numeric_limits<T>::min() / y;
} else /*if (y < 0) */ {
return y >= std::numeric_limits<T>::max() / x;
}
}
}
}
template<std::integral T>
constexpr inline bool TryAddWithoutOverflow(T *out, T x, T y) {
AMS_ASSERT(out != nullptr);
if (CanAddWithoutOverflow(x, y)) {
*out = x + y;
return true;
} else {
return false;
}
}
template<std::integral T>
constexpr inline bool TrySubtractWithoutOverflow(T *out, T x, T y) {
AMS_ASSERT(out != nullptr);
if (CanSubtractWithoutOverflow(x, y)) {
*out = x - y;
return true;
} else {
return false;
}
}
template<std::integral T>
constexpr inline bool TryMultiplyWithoutOverflow(T *out, T x, T y) {
AMS_ASSERT(out != nullptr);
if (CanMultiplyWithoutOverflow(x, y)) {
*out = x * y;
return true;
} else {
return false;
}
}
}