mika/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2025-07-14 21:12:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

ams-except-ncm: use R_SUCCEED_IF

Browse Source
This commit is contained in:
Michael Scire 2020-03-06 02:25:03 -08:00
parent 8d1d1f7999
commit 06ba2ed8de
22 changed files with 81 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libraries/libmesosphere/source/arch/arm64/kern_k_interrupt_manager.cpp
View File

@ -262,8 +262,8 @@ namespace ams::kern::arch::arm64 {
R_UNLESS(entry.handler != nullptr, svc::ResultInvalidState()); R_UNLESS(entry.handler != nullptr, svc::ResultInvalidState());
/* If auto-cleared, we can succeed immediately. */ /* If auto-cleared, we can succeed immediately. */
R_UNLESS(entry.manually_cleared, ResultSuccess()); R_SUCCEED_IF(!entry.manually_cleared);
R_UNLESS(entry.needs_clear, ResultSuccess()); R_SUCCEED_IF(!entry.needs_clear);
/* Clear and enable. */ /* Clear and enable. */
entry.needs_clear = false; entry.needs_clear = false;
@ -277,8 +277,8 @@ namespace ams::kern::arch::arm64 {
R_UNLESS(entry.handler != nullptr, svc::ResultInvalidState()); R_UNLESS(entry.handler != nullptr, svc::ResultInvalidState());
/* If auto-cleared, we can succeed immediately. */ /* If auto-cleared, we can succeed immediately. */
R_UNLESS(entry.manually_cleared, ResultSuccess()); R_SUCCEED_IF(!entry.manually_cleared);
R_UNLESS(entry.needs_clear, ResultSuccess()); R_SUCCEED_IF(!entry.needs_clear);
/* Clear and set priority. */ /* Clear and set priority. */
entry.needs_clear = false; entry.needs_clear = false;

12
libraries/libmesosphere/source/arch/arm64/kern_k_page_table.cpp
View File

@ -832,7 +832,7 @@ namespace ams::kern::arch::arm64 {
L1PageTableEntry *l1_entry = impl.GetL1Entry(virt_addr); L1PageTableEntry *l1_entry = impl.GetL1Entry(virt_addr);
if (l1_entry->IsBlock()) { if (l1_entry->IsBlock()) {
/* If our block size is too big, don't bother. */ /* If our block size is too big, don't bother. */
R_UNLESS(block_size < L1BlockSize, ResultSuccess()); R_SUCCEED_IF(block_size >= L1BlockSize);
/* Get the addresses we're working with. */ /* Get the addresses we're working with. */
const KProcessAddress block_virt_addr = util::AlignDown(GetInteger(virt_addr), L1BlockSize); const KProcessAddress block_virt_addr = util::AlignDown(GetInteger(virt_addr), L1BlockSize);
@ -859,10 +859,10 @@ namespace ams::kern::arch::arm64 {
} }
/* If we don't have an l1 table, we're done. */ /* If we don't have an l1 table, we're done. */
R_UNLESS(l1_entry->IsTable(), ResultSuccess()); R_SUCCEED_IF(!l1_entry->IsTable());
/* We want to separate L2 contiguous blocks into L2 blocks, so check that our size permits that. */ /* We want to separate L2 contiguous blocks into L2 blocks, so check that our size permits that. */
R_UNLESS(block_size < L2ContiguousBlockSize, ResultSuccess()); R_SUCCEED_IF(block_size >= L2ContiguousBlockSize);
L2PageTableEntry *l2_entry = impl.GetL2Entry(l1_entry, virt_addr); L2PageTableEntry *l2_entry = impl.GetL2Entry(l1_entry, virt_addr);
if (l2_entry->IsBlock()) { if (l2_entry->IsBlock()) {
@ -878,7 +878,7 @@ namespace ams::kern::arch::arm64 {
} }
/* We want to separate L2 blocks into L3 contiguous blocks, so check that our size permits that. */ /* We want to separate L2 blocks into L3 contiguous blocks, so check that our size permits that. */
R_UNLESS(block_size < L2BlockSize, ResultSuccess()); R_SUCCEED_IF(block_size >= L2BlockSize);
/* Get the addresses we're working with. */ /* Get the addresses we're working with. */
const KProcessAddress block_virt_addr = util::AlignDown(GetInteger(virt_addr), L2BlockSize); const KProcessAddress block_virt_addr = util::AlignDown(GetInteger(virt_addr), L2BlockSize);
@ -905,10 +905,10 @@ namespace ams::kern::arch::arm64 {
} }
/* If we don't have an L3 table, we're done. */ /* If we don't have an L3 table, we're done. */
R_UNLESS(l2_entry->IsTable(), ResultSuccess()); R_SUCCEED_IF(!l2_entry->IsTable());
/* We want to separate L3 contiguous blocks into L2 blocks, so check that our size permits that. */ /* We want to separate L3 contiguous blocks into L2 blocks, so check that our size permits that. */
R_UNLESS(block_size < L3ContiguousBlockSize, ResultSuccess()); R_SUCCEED_IF(block_size >= L3ContiguousBlockSize);
/* If we're contiguous, try to separate. */ /* If we're contiguous, try to separate. */
L3PageTableEntry *l3_entry = impl.GetL3Entry(l2_entry, virt_addr); L3PageTableEntry *l3_entry = impl.GetL3Entry(l2_entry, virt_addr);

2
libraries/libmesosphere/source/board/nintendo/nx/kern_k_device_page_table.cpp
View File

@ -257,7 +257,7 @@ namespace ams::kern::board::nintendo::nx {
const WordType clear_bit = (this->state[i] + 1) ^ (this->state[i]); const WordType clear_bit = (this->state[i] + 1) ^ (this->state[i]);
this->state[i] |= clear_bit; this->state[i] |= clear_bit;
out[num_reserved++] = static_cast<u8>(BitsPerWord * i + BitsPerWord - 1 - ClearLeadingZero(clear_bit)); out[num_reserved++] = static_cast<u8>(BitsPerWord * i + BitsPerWord - 1 - ClearLeadingZero(clear_bit));
R_UNLESS(num_reserved != num_desired, ResultSuccess()); R_SUCCEED_IF(num_reserved == num_desired);
} }
} }

4
libraries/libmesosphere/source/kern_k_capabilities.cpp
View File

@ -211,7 +211,9 @@ namespace ams::kern {
/* Validate this is a capability we can act on. */ /* Validate this is a capability we can act on. */
const auto type = GetCapabilityType(cap); const auto type = GetCapabilityType(cap);
R_UNLESS(type != CapabilityType::Invalid, svc::ResultInvalidArgument()); R_UNLESS(type != CapabilityType::Invalid, svc::ResultInvalidArgument());
R_UNLESS(type != CapabilityType::Padding, ResultSuccess());
/* If the type is padding, we have no work to do. */
R_SUCCEED_IF(type == CapabilityType::Padding);
/* Check that we haven't already processed this capability. */ /* Check that we haven't already processed this capability. */
const auto flag = GetCapabilityFlag(type); const auto flag = GetCapabilityFlag(type);

4
libraries/libmesosphere/source/kern_k_page_group.cpp
View File

@ -38,7 +38,7 @@ namespace ams::kern {
Result KPageGroup::AddBlock(KVirtualAddress addr, size_t num_pages) { Result KPageGroup::AddBlock(KVirtualAddress addr, size_t num_pages) {
/* Succeed immediately if we're adding no pages. */ /* Succeed immediately if we're adding no pages. */
R_UNLESS(num_pages != 0, ResultSuccess()); R_SUCCEED_IF(num_pages == 0);
/* Check for overflow. */ /* Check for overflow. */
MESOSPHERE_ASSERT(addr < addr + num_pages * PageSize); MESOSPHERE_ASSERT(addr < addr + num_pages * PageSize);
@ -46,7 +46,7 @@ namespace ams::kern {
/* Try to just append to the last block. */ /* Try to just append to the last block. */
if (!this->block_list.empty()) { if (!this->block_list.empty()) {
auto it = --(this->block_list.end()); auto it = --(this->block_list.end());
R_UNLESS(!it->TryConcatenate(addr, num_pages), ResultSuccess()); R_SUCCEED_IF(it->TryConcatenate(addr, num_pages));
} }
/* Allocate a new block. */ /* Allocate a new block. */

16
libraries/libstratosphere/include/stratosphere/fs/fs_memory_storage.hpp
View File

@ -28,17 +28,27 @@ namespace ams::fs {
MemoryStorage(void *b, s64 sz) : buf(static_cast<u8 *>(b)), size(sz) { /* .. */ } MemoryStorage(void *b, s64 sz) : buf(static_cast<u8 *>(b)), size(sz) { /* .. */ }
public: public:
virtual Result Read(s64 offset, void *buffer, size_t size) override { virtual Result Read(s64 offset, void *buffer, size_t size) override {
R_UNLESS(size != 0, ResultSuccess()); /* Succeed immediately on zero-sized read. */
R_SUCCEED_IF(size == 0);
/* Validate arguments. */
R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument()); R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
R_UNLESS(IStorage::IsRangeValid(offset, size, this->size), fs::ResultOutOfRange()); R_UNLESS(IStorage::IsRangeValid(offset, size, this->size), fs::ResultOutOfRange());
/* Copy from memory. */
std::memcpy(buffer, this->buf + offset, size); std::memcpy(buffer, this->buf + offset, size);
return ResultSuccess(); return ResultSuccess();
} }
virtual Result Write(s64 offset, const void *buffer, size_t size) override{ virtual Result Write(s64 offset, const void *buffer, size_t size) override {
R_UNLESS(size != 0, ResultSuccess()); /* Succeed immediately on zero-sized write. */
R_SUCCEED_IF(size == 0);
/* Validate arguments. */
R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument()); R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
R_UNLESS(IStorage::IsRangeValid(offset, size, this->size), fs::ResultOutOfRange()); R_UNLESS(IStorage::IsRangeValid(offset, size, this->size), fs::ResultOutOfRange());
/* Copy to memory. */
std::memcpy(this->buf + offset, buffer, size); std::memcpy(this->buf + offset, buffer, size);
return ResultSuccess(); return ResultSuccess();
} }

28
libraries/libstratosphere/include/stratosphere/fs/fs_substorage.hpp
View File

@ -69,16 +69,27 @@ namespace ams::fs {
} }
public: public:
virtual Result Read(s64 offset, void *buffer, size_t size) override { virtual Result Read(s64 offset, void *buffer, size_t size) override {
/* Ensure we're initialized. */
R_UNLESS(this->IsValid(), fs::ResultNotInitialized()); R_UNLESS(this->IsValid(), fs::ResultNotInitialized());
R_UNLESS(size != 0, ResultSuccess());
/* Succeed immediately on zero-sized operation. */
R_SUCCEED_IF(size == 0);
/* Validate arguments and read. */
R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument()); R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
R_UNLESS(IStorage::IsRangeValid(offset, size, this->size), fs::ResultOutOfRange()); R_UNLESS(IStorage::IsRangeValid(offset, size, this->size), fs::ResultOutOfRange());
return this->base_storage->Read(this->offset + offset, buffer, size); return this->base_storage->Read(this->offset + offset, buffer, size);
} }
virtual Result Write(s64 offset, const void *buffer, size_t size) override{ virtual Result Write(s64 offset, const void *buffer, size_t size) override{
/* Ensure we're initialized. */
R_UNLESS(this->IsValid(), fs::ResultNotInitialized()); R_UNLESS(this->IsValid(), fs::ResultNotInitialized());
R_UNLESS(size != 0, ResultSuccess());
/* Succeed immediately on zero-sized operation. */
R_SUCCEED_IF(size == 0);
/* Validate arguments and write. */
R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument()); R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
R_UNLESS(IStorage::IsRangeValid(offset, size, this->size), fs::ResultOutOfRange()); R_UNLESS(IStorage::IsRangeValid(offset, size, this->size), fs::ResultOutOfRange());
return this->base_storage->Write(this->offset + offset, buffer, size); return this->base_storage->Write(this->offset + offset, buffer, size);
@ -90,15 +101,17 @@ namespace ams::fs {
} }
virtual Result SetSize(s64 size) override { virtual Result SetSize(s64 size) override {
/* Ensure we're initialized and validate arguments. */
R_UNLESS(this->IsValid(), fs::ResultNotInitialized()); R_UNLESS(this->IsValid(), fs::ResultNotInitialized());
R_UNLESS(this->resizable, fs::ResultUnsupportedOperation()); R_UNLESS(this->resizable, fs::ResultUnsupportedOperation());
R_UNLESS(IStorage::IsOffsetAndSizeValid(this->offset, size), fs::ResultInvalidSize()); R_UNLESS(IStorage::IsOffsetAndSizeValid(this->offset, size), fs::ResultInvalidSize());
/* Ensure that we're allowed to set size. */
s64 cur_size; s64 cur_size;
R_TRY(this->base_storage->GetSize(std::addressof(cur_size))); R_TRY(this->base_storage->GetSize(std::addressof(cur_size)));
R_UNLESS(cur_size == this->offset + this->size, fs::ResultUnsupportedOperation()); R_UNLESS(cur_size == this->offset + this->size, fs::ResultUnsupportedOperation());
/* Set the size. */
R_TRY(this->base_storage->SetSize(this->offset + size)); R_TRY(this->base_storage->SetSize(this->offset + size));
this->size = size; this->size = size;
@ -106,14 +119,21 @@ namespace ams::fs {
} }
virtual Result GetSize(s64 *out) override { virtual Result GetSize(s64 *out) override {
/* Ensure we're initialized. */
R_UNLESS(this->IsValid(), fs::ResultNotInitialized()); R_UNLESS(this->IsValid(), fs::ResultNotInitialized());
*out = this->size; *out = this->size;
return ResultSuccess(); return ResultSuccess();
} }
virtual Result OperateRange(void *dst, size_t dst_size, OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override { 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());
R_UNLESS(size != 0, ResultSuccess());
/* Succeed immediately on zero-sized operation. */
R_SUCCEED_IF(size == 0);
/* Validate arguments and operate. */
R_UNLESS(IStorage::IsOffsetAndSizeValid(offset, size), fs::ResultOutOfRange()); R_UNLESS(IStorage::IsOffsetAndSizeValid(offset, size), fs::ResultOutOfRange());
return this->base_storage->OperateRange(dst, dst_size, op_id, this->offset + offset, size, src, src_size); return this->base_storage->OperateRange(dst, dst_size, op_id, this->offset + offset, size, src, src_size);
} }

2
libraries/libstratosphere/include/stratosphere/spl/spl_types.hpp
View File

@ -65,7 +65,7 @@ namespace ams::spl {
constexpr inline ::ams::Result ConvertResult(Result smc_result) { constexpr inline ::ams::Result ConvertResult(Result smc_result) {
/* smc::Result::Success becomes ResultSuccess() directly. */ /* smc::Result::Success becomes ResultSuccess() directly. */
R_UNLESS(smc_result != Result::Success, ResultSuccess()); R_SUCCEED_IF(smc_result == smc::Result::Success);
/* Convert to the list of known SecureMonitorErrors. */ /* Convert to the list of known SecureMonitorErrors. */
const auto converted = R_MAKE_NAMESPACE_RESULT(::ams::spl, static_cast<u32>(smc_result)); const auto converted = R_MAKE_NAMESPACE_RESULT(::ams::spl, static_cast<u32>(smc_result));

6
libraries/libstratosphere/source/fs/fs_file_storage.cpp
View File

@ -18,13 +18,13 @@
namespace ams::fs { namespace ams::fs {
Result FileStorage::UpdateSize() { Result FileStorage::UpdateSize() {
R_UNLESS(this->size == InvalidSize, ResultSuccess()); R_SUCCEED_IF(this->size != InvalidSize);
return this->base_file->GetSize(&this->size); return this->base_file->GetSize(&this->size);
} }
Result FileStorage::Read(s64 offset, void *buffer, size_t size) { Result FileStorage::Read(s64 offset, void *buffer, size_t size) {
/* Immediately succeed if there's nothing to read. */ /* Immediately succeed if there's nothing to read. */
R_UNLESS(size > 0, ResultSuccess()); R_SUCCEED_IF(size == 0);
/* Validate buffer. */ /* Validate buffer. */
R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument()); R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
@ -41,7 +41,7 @@ namespace ams::fs {
Result FileStorage::Write(s64 offset, const void *buffer, size_t size) { Result FileStorage::Write(s64 offset, const void *buffer, size_t size) {
/* Immediately succeed if there's nothing to write. */ /* Immediately succeed if there's nothing to write. */
R_UNLESS(size > 0, ResultSuccess()); R_SUCCEED_IF(size == 0);
/* Validate buffer. */ /* Validate buffer. */
R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument()); R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());

2
libraries/libstratosphere/source/fs/fs_path_utils.cpp
View File

@ -25,7 +25,7 @@ namespace ams::fs {
const char c = *(cur++); const char c = *(cur++);
/* If terminated, we're done. */ /* If terminated, we're done. */
R_UNLESS(c != StringTraits::NullTerminator, ResultSuccess()); R_SUCCEED_IF(PathTool::IsNullTerminator(c));
/* TODO: Nintendo converts the path from utf-8 to utf-32, one character at a time. */ /* TODO: Nintendo converts the path from utf-8 to utf-32, one character at a time. */
/* We should do this. */ /* We should do this. */

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

@ -178,7 +178,7 @@ namespace ams::fssystem {
Result DirectorySaveDataFileSystem::CopySaveFromFileSystem(fs::fsa::IFileSystem *save_fs) { Result DirectorySaveDataFileSystem::CopySaveFromFileSystem(fs::fsa::IFileSystem *save_fs) {
/* If the input save is null, there's nothing to copy. */ /* If the input save is null, there's nothing to copy. */
R_UNLESS(save_fs != nullptr, ResultSuccess()); R_SUCCEED_IF(save_fs == nullptr);
/* Get a work buffer to work with. */ /* Get a work buffer to work with. */
std::unique_ptr<u8[]> work_buf; std::unique_ptr<u8[]> work_buf;

4
libraries/libstratosphere/source/lr/lr_content_location_resolver_impl.cpp
View File

@ -30,7 +30,7 @@ namespace ams::lr {
Result ContentLocationResolverImpl::ResolveProgramPath(sf::Out<Path> out, ncm::ProgramId id) { Result ContentLocationResolverImpl::ResolveProgramPath(sf::Out<Path> out, ncm::ProgramId id) {
/* Use a redirection if present. */ /* Use a redirection if present. */
R_UNLESS(!this->program_redirector.FindRedirection(out.GetPointer(), id), ResultSuccess()); R_SUCCEED_IF(this->program_redirector.FindRedirection(out.GetPointer(), id));
/* Find the latest program content for the program id. */ /* Find the latest program content for the program id. */
ncm::ContentId program_content_id; ncm::ContentId program_content_id;
@ -164,7 +164,7 @@ namespace ams::lr {
Result ContentLocationResolverImpl::ResolveProgramPathForDebug(sf::Out<Path> out, ncm::ProgramId id) { Result ContentLocationResolverImpl::ResolveProgramPathForDebug(sf::Out<Path> out, ncm::ProgramId id) {
/* Use a redirection if present. */ /* Use a redirection if present. */
R_UNLESS(!this->debug_program_redirector.FindRedirection(out.GetPointer(), id), ResultSuccess()); R_SUCCEED_IF(this->debug_program_redirector.FindRedirection(out.GetPointer(), id));
/* Otherwise find the path for the program id. */ /* Otherwise find the path for the program id. */
R_TRY_CATCH(this->ResolveProgramPath(out.GetPointer(), id)) { R_TRY_CATCH(this->ResolveProgramPath(out.GetPointer(), id)) {

10
libraries/libstratosphere/source/lr/lr_redirect_only_location_resolver_impl.cpp
View File

@ -128,13 +128,11 @@ namespace ams::lr {
} }
Result RedirectOnlyLocationResolverImpl::ResolveProgramPathForDebug(sf::Out<Path> out, ncm::ProgramId id) { Result RedirectOnlyLocationResolverImpl::ResolveProgramPathForDebug(sf::Out<Path> out, ncm::ProgramId id) {
/* Use a redirection if present. */ /* If a debug program redirection is present, use it. */
R_UNLESS(!this->debug_program_redirector.FindRedirection(out.GetPointer(), id), ResultSuccess()); R_SUCCEED_IF(this->debug_program_redirector.FindRedirection(out.GetPointer(), id));
/* Otherwise find the path for the program id. */ /* Otherwise, try to find a normal program redirection. */
R_TRY_CATCH(this->ResolveProgramPath(out.GetPointer(), id)) { R_UNLESS(this->program_redirector.FindRedirection(out.GetPointer(), id), lr::ResultDebugProgramNotFound());
R_CONVERT(ResultProgramNotFound, lr::ResultDebugProgramNotFound())
} R_END_TRY_CATCH;
return ResultSuccess(); return ResultSuccess();
} }

2
stratosphere/ams_mitm/source/fs_mitm/fsmitm_layered_romfs_storage.cpp
View File

@ -98,7 +98,7 @@ namespace ams::mitm::fs {
Result LayeredRomfsStorage::Read(s64 offset, void *buffer, size_t size) { Result LayeredRomfsStorage::Read(s64 offset, void *buffer, size_t size) {
/* Check if we can succeed immediately. */ /* Check if we can succeed immediately. */
R_UNLESS(size >= 0, fs::ResultInvalidSize()); R_UNLESS(size >= 0, fs::ResultInvalidSize());
R_UNLESS(size > 0, ResultSuccess()); R_SUCCEED_IF(size == 0);
/* Ensure we're initialized. */ /* Ensure we're initialized. */
if (!this->is_initialized) { if (!this->is_initialized) {

2
stratosphere/boot/source/boot_i2c_utils.cpp
View File

@ -27,7 +27,7 @@ namespace ams::boot {
u64 cur_time = 0; u64 cur_time = 0;
while (true) { while (true) {
const auto retry_result = f(); const auto retry_result = f();
R_UNLESS(R_FAILED(retry_result), ResultSuccess()); R_SUCCEED_IF(R_SUCCEEDED(retry_result));
cur_time += retry_interval; cur_time += retry_interval;
if (cur_time < timeout) { if (cur_time < timeout) {

6
stratosphere/boot/source/i2c/driver/impl/i2c_bus_accessor.cpp
View File

@ -379,7 +379,8 @@ namespace ams::i2c::driver::impl {
/* Wait for flush to finish, check every ms for 5 ms. */ /* Wait for flush to finish, check every ms for 5 ms. */
for (size_t i = 0; i < 5; i++) { for (size_t i = 0; i < 5; i++) {
R_UNLESS((reg::Read(&this->i2c_registers->I2C_FIFO_CONTROL_0) & 3), ResultSuccess()); const bool flush_done = (reg::Read(&this->i2c_registers->I2C_FIFO_CONTROL_0) & 3) == 0;
R_SUCCEED_IF(flush_done);
svcSleepThread(1'000'000ul); svcSleepThread(1'000'000ul);
} }
@ -418,7 +419,8 @@ namespace ams::i2c::driver::impl {
Result BusAccessor::GetAndHandleTransactionResult() { Result BusAccessor::GetAndHandleTransactionResult() {
const auto transaction_result = this->GetTransactionResult(); const auto transaction_result = this->GetTransactionResult();
R_UNLESS(R_FAILED(transaction_result), ResultSuccess()); R_SUCCEED_IF(R_SUCCEEDED(transaction_result));
this->HandleTransactionResult(transaction_result); this->HandleTransactionResult(transaction_result);
this->ClearInterruptMask(); this->ClearInterruptMask();
this->interrupt_event.Reset(); this->interrupt_event.Reset();

2
stratosphere/dmnt/source/cheat/impl/dmnt_cheat_api.cpp
View File

@ -602,7 +602,7 @@ namespace ams::dmnt::cheat::impl {
{ {
if (this->HasActiveCheatProcess()) { if (this->HasActiveCheatProcess()) {
/* When forcing attach, we're done. */ /* When forcing attach, we're done. */
R_UNLESS(on_process_launch, ResultSuccess()); R_SUCCEED_IF(!on_process_launch);
} }
/* Detach from the current process, if it's open. */ /* Detach from the current process, if it's open. */

2
stratosphere/dmnt/source/dmnt_service_target_io.cpp
View File

@ -49,7 +49,7 @@ namespace ams::dmnt {
Result EnsureSdInitialized() { Result EnsureSdInitialized() {
std::scoped_lock lk(g_sd_lock); std::scoped_lock lk(g_sd_lock);
R_UNLESS(!g_sd_initialized, ResultSuccess()); R_SUCCEED_IF(g_sd_initialized);
R_TRY(fsOpenSdCardFileSystem(&g_sd_fs)); R_TRY(fsOpenSdCardFileSystem(&g_sd_fs));
g_sd_initialized = true; g_sd_initialized = true;

4
stratosphere/fatal/source/fatal_service.cpp
View File

@ -64,8 +64,8 @@ namespace ams::fatal::srv {
/* Throw implementation. */ /* Throw implementation. */
Result ServiceContext::ThrowFatalWithCpuContext(Result result, os::ProcessId process_id, FatalPolicy policy, const CpuContext &cpu_ctx) { Result ServiceContext::ThrowFatalWithCpuContext(Result result, os::ProcessId process_id, FatalPolicy policy, const CpuContext &cpu_ctx) {
/* We don't support Error Report only fatals. */ /* We don't support Error-Report-only fatals. */
R_UNLESS(policy != FatalPolicy_ErrorReport, ResultSuccess()); R_SUCCEED_IF(policy == FatalPolicy_ErrorReport);
/* Note that we've thrown fatal. */ /* Note that we've thrown fatal. */
R_TRY(this->TrySetHasThrown()); R_TRY(this->TrySetHasThrown());

2
stratosphere/loader/source/ldr_content_management.cpp
View File

@ -307,7 +307,7 @@ namespace ams::ldr {
R_TRY(lr::OpenLocationResolver(std::addressof(lr), static_cast<ncm::StorageId>(loc.storage_id))); R_TRY(lr::OpenLocationResolver(std::addressof(lr), static_cast<ncm::StorageId>(loc.storage_id)));
/* If there's already a Html Document path, we don't need to set one. */ /* If there's already a Html Document path, we don't need to set one. */
R_UNLESS(R_FAILED(lr.ResolveApplicationHtmlDocumentPath(std::addressof(path), loc.program_id)), ResultSuccess()); R_SUCCEED_IF(R_SUCCEEDED(lr.ResolveApplicationHtmlDocumentPath(std::addressof(path), loc.program_id)));
/* We just need to set this to any valid NCA path. Let's use the executable path. */ /* We just need to set this to any valid NCA path. Let's use the executable path. */
R_TRY(lr.ResolveProgramPath(std::addressof(path), loc.program_id)); R_TRY(lr.ResolveProgramPath(std::addressof(path), loc.program_id));

5
stratosphere/loader/source/ldr_process_creation.cpp
View File

@ -84,7 +84,10 @@ namespace ams::ldr {
#include "ldr_anti_downgrade_tables.inc" #include "ldr_anti_downgrade_tables.inc"
Result ValidateProgramVersion(ncm::ProgramId program_id, u32 version) { Result ValidateProgramVersion(ncm::ProgramId program_id, u32 version) {
R_UNLESS(hos::GetVersion() >= hos::Version_810, ResultSuccess()); /* No version verification is done before 8.1.0. */
R_SUCCEED_IF(hos::GetVersion() < hos::Version_810);
/* Do version-dependent validation, if compiled to do so. */
#ifdef LDR_VALIDATE_PROCESS_VERSION #ifdef LDR_VALIDATE_PROCESS_VERSION
const MinimumProgramVersion *entries = nullptr; const MinimumProgramVersion *entries = nullptr;
size_t num_entries = 0; size_t num_entries = 0;

2
stratosphere/sm/source/impl/sm_service_manager.cpp
View File

@ -297,7 +297,7 @@ namespace ams::sm::impl {
is_valid &= std::memcmp(&ac_service, &service, access_control.GetServiceNameSize() - 1) == 0; is_valid &= std::memcmp(&ac_service, &service, access_control.GetServiceNameSize() - 1) == 0;
} }
R_UNLESS(!is_valid, ResultSuccess()); R_SUCCEED_IF(is_valid);
} }
access_control = access_control.GetNextEntry(); access_control = access_control.GetNextEntry();
} }