ShuriZma
/
suyu
mirror of https://git.suyu.dev/suyu/suyu
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

kernel: Unify result codes (#5890) 

* kernel: Unify result codes

Drop the usage of ERR_NAME convention in kernel for ResultName. Removed seperation between svc_results.h & errors.h as we mainly include both most of the time anyways.

* oops

* rename errors to svc_results
This commit is contained in:
Chloe 2021-02-13 10:43:01 +11:00 committed by GitHub
parent a0379c2db5
commit 37939482fb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 223 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/core/CMakeLists.txt
View File

@ -148,7 +148,7 @@ add_library(core STATIC
hle/kernel/client_session.h hle/kernel/client_session.h
hle/kernel/code_set.cpp hle/kernel/code_set.cpp
hle/kernel/code_set.h hle/kernel/code_set.h
hle/kernel/errors.h hle/kernel/svc_results.h
hle/kernel/global_scheduler_context.cpp hle/kernel/global_scheduler_context.cpp
hle/kernel/global_scheduler_context.h hle/kernel/global_scheduler_context.h
hle/kernel/handle_table.cpp hle/kernel/handle_table.cpp
@ -223,7 +223,6 @@ add_library(core STATIC
hle/kernel/svc.cpp hle/kernel/svc.cpp
hle/kernel/svc.h hle/kernel/svc.h
hle/kernel/svc_common.h hle/kernel/svc_common.h
hle/kernel/svc_results.h
hle/kernel/svc_types.h hle/kernel/svc_types.h
hle/kernel/svc_wrap.h hle/kernel/svc_wrap.h
hle/kernel/time_manager.cpp hle/kernel/time_manager.cpp

4
src/core/hle/kernel/client_port.cpp
View File

@ -4,11 +4,11 @@
#include "core/hle/kernel/client_port.h" #include "core/hle/kernel/client_port.h"
#include "core/hle/kernel/client_session.h" #include "core/hle/kernel/client_session.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/hle_ipc.h" #include "core/hle/kernel/hle_ipc.h"
#include "core/hle/kernel/object.h" #include "core/hle/kernel/object.h"
#include "core/hle/kernel/server_port.h" #include "core/hle/kernel/server_port.h"
#include "core/hle/kernel/session.h" #include "core/hle/kernel/session.h"
#include "core/hle/kernel/svc_results.h"
namespace Kernel { namespace Kernel {
@ -21,7 +21,7 @@ std::shared_ptr<ServerPort> ClientPort::GetServerPort() const {
ResultVal<std::shared_ptr<ClientSession>> ClientPort::Connect() { ResultVal<std::shared_ptr<ClientSession>> ClientPort::Connect() {
if (active_sessions >= max_sessions) { if (active_sessions >= max_sessions) {
return ERR_MAX_CONNECTIONS_REACHED; return ResultMaxConnectionsReached;
} }
active_sessions++; active_sessions++;

4
src/core/hle/kernel/client_session.cpp
View File

@ -3,11 +3,11 @@
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include "core/hle/kernel/client_session.h" #include "core/hle/kernel/client_session.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/hle_ipc.h" #include "core/hle/kernel/hle_ipc.h"
#include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/k_thread.h"
#include "core/hle/kernel/server_session.h" #include "core/hle/kernel/server_session.h"
#include "core/hle/kernel/session.h" #include "core/hle/kernel/session.h"
#include "core/hle/kernel/svc_results.h"
#include "core/hle/result.h" #include "core/hle/result.h"
namespace Kernel { namespace Kernel {
@ -43,7 +43,7 @@ ResultCode ClientSession::SendSyncRequest(std::shared_ptr<KThread> thread,
Core::Timing::CoreTiming& core_timing) { Core::Timing::CoreTiming& core_timing) {
// Keep ServerSession alive until we're done working with it. // Keep ServerSession alive until we're done working with it.
if (!parent->Server()) { if (!parent->Server()) {
return ERR_SESSION_CLOSED_BY_REMOTE; return ResultSessionClosedByRemote;
} }
// Signal the server session that new data is available // Signal the server session that new data is available

43
src/core/hle/kernel/errors.h
View File

@ -1,43 +0,0 @@
// Copyright 2018 yuzu emulator team
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include "core/hle/result.h"
namespace Kernel {
// Confirmed Switch kernel error codes
constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED{ErrorModule::Kernel, 7};
constexpr ResultCode ERR_INVALID_CAPABILITY_DESCRIPTOR{ErrorModule::Kernel, 14};
constexpr ResultCode ERR_THREAD_TERMINATING{ErrorModule::Kernel, 59};
constexpr ResultCode ERR_TERMINATION_REQUESTED{ErrorModule::Kernel, 59};
constexpr ResultCode ERR_INVALID_SIZE{ErrorModule::Kernel, 101};
constexpr ResultCode ERR_INVALID_ADDRESS{ErrorModule::Kernel, 102};
constexpr ResultCode ERR_OUT_OF_RESOURCES{ErrorModule::Kernel, 103};
constexpr ResultCode ERR_OUT_OF_MEMORY{ErrorModule::Kernel, 104};
constexpr ResultCode ERR_HANDLE_TABLE_FULL{ErrorModule::Kernel, 105};
constexpr ResultCode ERR_INVALID_ADDRESS_STATE{ErrorModule::Kernel, 106};
constexpr ResultCode ERR_INVALID_CURRENT_MEMORY{ErrorModule::Kernel, 106};
constexpr ResultCode ERR_INVALID_MEMORY_PERMISSIONS{ErrorModule::Kernel, 108};
constexpr ResultCode ERR_INVALID_MEMORY_RANGE{ErrorModule::Kernel, 110};
constexpr ResultCode ERR_INVALID_PROCESSOR_ID{ErrorModule::Kernel, 113};
constexpr ResultCode ERR_INVALID_THREAD_PRIORITY{ErrorModule::Kernel, 112};
constexpr ResultCode ERR_INVALID_HANDLE{ErrorModule::Kernel, 114};
constexpr ResultCode ERR_INVALID_POINTER{ErrorModule::Kernel, 115};
constexpr ResultCode ERR_INVALID_COMBINATION{ErrorModule::Kernel, 116};
constexpr ResultCode RESULT_TIMEOUT{ErrorModule::Kernel, 117};
constexpr ResultCode ERR_SYNCHRONIZATION_CANCELED{ErrorModule::Kernel, 118};
constexpr ResultCode ERR_CANCELLED{ErrorModule::Kernel, 118};
constexpr ResultCode ERR_OUT_OF_RANGE{ErrorModule::Kernel, 119};
constexpr ResultCode ERR_INVALID_ENUM_VALUE{ErrorModule::Kernel, 120};
constexpr ResultCode ERR_NOT_FOUND{ErrorModule::Kernel, 121};
constexpr ResultCode ERR_BUSY{ErrorModule::Kernel, 122};
constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE{ErrorModule::Kernel, 123};
constexpr ResultCode ERR_INVALID_STATE{ErrorModule::Kernel, 125};
constexpr ResultCode ERR_RESERVED_VALUE{ErrorModule::Kernel, 126};
constexpr ResultCode ERR_RESOURCE_LIMIT_EXCEEDED{ErrorModule::Kernel, 132};
} // namespace Kernel

10
src/core/hle/kernel/handle_table.cpp
View File

@ -6,12 +6,12 @@
#include "common/assert.h" #include "common/assert.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "core/core.h" #include "core/core.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/handle_table.h"
#include "core/hle/kernel/k_scheduler.h" #include "core/hle/kernel/k_scheduler.h"
#include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/k_thread.h"
#include "core/hle/kernel/kernel.h" #include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/process.h" #include "core/hle/kernel/process.h"
#include "core/hle/kernel/svc_results.h"
namespace Kernel { namespace Kernel {
namespace { namespace {
@ -33,7 +33,7 @@ HandleTable::~HandleTable() = default;
ResultCode HandleTable::SetSize(s32 handle_table_size) { ResultCode HandleTable::SetSize(s32 handle_table_size) {
if (static_cast<u32>(handle_table_size) > MAX_COUNT) { if (static_cast<u32>(handle_table_size) > MAX_COUNT) {
LOG_ERROR(Kernel, "Handle table size {} is greater than {}", handle_table_size, MAX_COUNT); LOG_ERROR(Kernel, "Handle table size {} is greater than {}", handle_table_size, MAX_COUNT);
return ERR_OUT_OF_MEMORY; return ResultOutOfMemory;
} }
// Values less than or equal to zero indicate to use the maximum allowable // Values less than or equal to zero indicate to use the maximum allowable
@ -53,7 +53,7 @@ ResultVal<Handle> HandleTable::Create(std::shared_ptr<Object> obj) {
const u16 slot = next_free_slot; const u16 slot = next_free_slot;
if (slot >= table_size) { if (slot >= table_size) {
LOG_ERROR(Kernel, "Unable to allocate Handle, too many slots in use."); LOG_ERROR(Kernel, "Unable to allocate Handle, too many slots in use.");
return ERR_HANDLE_TABLE_FULL; return ResultHandleTableFull;
} }
next_free_slot = generations[slot]; next_free_slot = generations[slot];
@ -76,7 +76,7 @@ ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
std::shared_ptr<Object> object = GetGeneric(handle); std::shared_ptr<Object> object = GetGeneric(handle);
if (object == nullptr) { if (object == nullptr) {
LOG_ERROR(Kernel, "Tried to duplicate invalid handle: {:08X}", handle); LOG_ERROR(Kernel, "Tried to duplicate invalid handle: {:08X}", handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
return Create(std::move(object)); return Create(std::move(object));
} }
@ -84,7 +84,7 @@ ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
ResultCode HandleTable::Close(Handle handle) { ResultCode HandleTable::Close(Handle handle) {
if (!IsValid(handle)) { if (!IsValid(handle)) {
LOG_ERROR(Kernel, "Handle is not valid! handle={:08X}", handle); LOG_ERROR(Kernel, "Handle is not valid! handle={:08X}", handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
const u16 slot = GetSlot(handle); const u16 slot = GetSlot(handle);

2
src/core/hle/kernel/hle_ipc.cpp
View File

@ -14,7 +14,6 @@
#include "common/common_types.h" #include "common/common_types.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "core/hle/ipc_helpers.h" #include "core/hle/ipc_helpers.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/handle_table.h"
#include "core/hle/kernel/hle_ipc.h" #include "core/hle/kernel/hle_ipc.h"
#include "core/hle/kernel/k_readable_event.h" #include "core/hle/kernel/k_readable_event.h"
@ -26,6 +25,7 @@
#include "core/hle/kernel/object.h" #include "core/hle/kernel/object.h"
#include "core/hle/kernel/process.h" #include "core/hle/kernel/process.h"
#include "core/hle/kernel/server_session.h" #include "core/hle/kernel/server_session.h"
#include "core/hle/kernel/svc_results.h"
#include "core/hle/kernel/time_manager.h" #include "core/hle/kernel/time_manager.h"
#include "core/memory.h" #include "core/memory.h"

28
src/core/hle/kernel/k_address_arbiter.cpp
View File

@ -120,10 +120,10 @@ ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32
s32 user_value{}; s32 user_value{};
if (!UpdateIfEqual(system, &user_value, addr, value, value + 1)) { if (!UpdateIfEqual(system, &user_value, addr, value, value + 1)) {
LOG_ERROR(Kernel, "Invalid current memory!"); LOG_ERROR(Kernel, "Invalid current memory!");
return Svc::ResultInvalidCurrentMemory; return ResultInvalidCurrentMemory;
} }
if (user_value != value) { if (user_value != value) {
return Svc::ResultInvalidState; return ResultInvalidState;
} }
auto it = thread_tree.nfind_light({addr, -1}); auto it = thread_tree.nfind_light({addr, -1});
@ -189,10 +189,10 @@ ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32
if (!succeeded) { if (!succeeded) {
LOG_ERROR(Kernel, "Invalid current memory!"); LOG_ERROR(Kernel, "Invalid current memory!");
return Svc::ResultInvalidCurrentMemory; return ResultInvalidCurrentMemory;
} }
if (user_value != value) { if (user_value != value) {
return Svc::ResultInvalidState; return ResultInvalidState;
} }
while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) && while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) &&
@ -221,11 +221,11 @@ ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement
// Check that the thread isn't terminating. // Check that the thread isn't terminating.
if (cur_thread->IsTerminationRequested()) { if (cur_thread->IsTerminationRequested()) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultTerminationRequested; return ResultTerminationRequested;
} }
// Set the synced object. // Set the synced object.
cur_thread->SetSyncedObject(nullptr, Svc::ResultTimedOut); cur_thread->SetSyncedObject(nullptr, ResultTimedOut);
// Read the value from userspace. // Read the value from userspace.
s32 user_value{}; s32 user_value{};
@ -238,19 +238,19 @@ ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement
if (!succeeded) { if (!succeeded) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultInvalidCurrentMemory; return ResultInvalidCurrentMemory;
} }
// Check that the value is less than the specified one. // Check that the value is less than the specified one.
if (user_value >= value) { if (user_value >= value) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultInvalidState; return ResultInvalidState;
} }
// Check that the timeout is non-zero. // Check that the timeout is non-zero.
if (timeout == 0) { if (timeout == 0) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultTimedOut; return ResultTimedOut;
} }
// Set the arbiter. // Set the arbiter.
@ -288,29 +288,29 @@ ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
// Check that the thread isn't terminating. // Check that the thread isn't terminating.
if (cur_thread->IsTerminationRequested()) { if (cur_thread->IsTerminationRequested()) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultTerminationRequested; return ResultTerminationRequested;
} }
// Set the synced object. // Set the synced object.
cur_thread->SetSyncedObject(nullptr, Svc::ResultTimedOut); cur_thread->SetSyncedObject(nullptr, ResultTimedOut);
// Read the value from userspace. // Read the value from userspace.
s32 user_value{}; s32 user_value{};
if (!ReadFromUser(system, &user_value, addr)) { if (!ReadFromUser(system, &user_value, addr)) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultInvalidCurrentMemory; return ResultInvalidCurrentMemory;
} }
// Check that the value is equal. // Check that the value is equal.
if (value != user_value) { if (value != user_value) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultInvalidState; return ResultInvalidState;
} }
// Check that the timeout is non-zero. // Check that the timeout is non-zero.
if (timeout == 0) { if (timeout == 0) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultTimedOut; return ResultTimedOut;
} }
// Set the arbiter. // Set the arbiter.

20
src/core/hle/kernel/k_condition_variable.cpp
View File

@ -92,10 +92,10 @@ ResultCode KConditionVariable::SignalToAddress(VAddr addr) {
// Write the value to userspace. // Write the value to userspace.
if (!WriteToUser(system, addr, std::addressof(next_value))) { if (!WriteToUser(system, addr, std::addressof(next_value))) {
if (next_owner_thread) { if (next_owner_thread) {
next_owner_thread->SetSyncedObject(nullptr, Svc::ResultInvalidCurrentMemory); next_owner_thread->SetSyncedObject(nullptr, ResultInvalidCurrentMemory);
} }
return Svc::ResultInvalidCurrentMemory; return ResultInvalidCurrentMemory;
} }
} }
@ -114,20 +114,20 @@ ResultCode KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 val
cur_thread->SetSyncedObject(nullptr, RESULT_SUCCESS); cur_thread->SetSyncedObject(nullptr, RESULT_SUCCESS);
// Check if the thread should terminate. // Check if the thread should terminate.
R_UNLESS(!cur_thread->IsTerminationRequested(), Svc::ResultTerminationRequested); R_UNLESS(!cur_thread->IsTerminationRequested(), ResultTerminationRequested);
{ {
// Read the tag from userspace. // Read the tag from userspace.
u32 test_tag{}; u32 test_tag{};
R_UNLESS(ReadFromUser(system, std::addressof(test_tag), addr), R_UNLESS(ReadFromUser(system, std::addressof(test_tag), addr),
Svc::ResultInvalidCurrentMemory); ResultInvalidCurrentMemory);
// If the tag isn't the handle (with wait mask), we're done. // If the tag isn't the handle (with wait mask), we're done.
R_UNLESS(test_tag == (handle | Svc::HandleWaitMask), RESULT_SUCCESS); R_UNLESS(test_tag == (handle | Svc::HandleWaitMask), RESULT_SUCCESS);
// Get the lock owner thread. // Get the lock owner thread.
owner_thread = kernel.CurrentProcess()->GetHandleTable().Get<KThread>(handle); owner_thread = kernel.CurrentProcess()->GetHandleTable().Get<KThread>(handle);
R_UNLESS(owner_thread, Svc::ResultInvalidHandle); R_UNLESS(owner_thread, ResultInvalidHandle);
// Update the lock. // Update the lock.
cur_thread->SetAddressKey(addr, value); cur_thread->SetAddressKey(addr, value);
@ -191,13 +191,13 @@ KThread* KConditionVariable::SignalImpl(KThread* thread) {
thread_to_close = owner_thread.get(); thread_to_close = owner_thread.get();
} else { } else {
// The lock was tagged with a thread that doesn't exist. // The lock was tagged with a thread that doesn't exist.
thread->SetSyncedObject(nullptr, Svc::ResultInvalidState); thread->SetSyncedObject(nullptr, ResultInvalidState);
thread->Wakeup(); thread->Wakeup();
} }
} }
} else { } else {
// If the address wasn't accessible, note so. // If the address wasn't accessible, note so.
thread->SetSyncedObject(nullptr, Svc::ResultInvalidCurrentMemory); thread->SetSyncedObject(nullptr, ResultInvalidCurrentMemory);
thread->Wakeup(); thread->Wakeup();
} }
@ -263,12 +263,12 @@ ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout)
KScopedSchedulerLockAndSleep slp{kernel, cur_thread, timeout}; KScopedSchedulerLockAndSleep slp{kernel, cur_thread, timeout};
// Set the synced object. // Set the synced object.
cur_thread->SetSyncedObject(nullptr, Svc::ResultTimedOut); cur_thread->SetSyncedObject(nullptr, ResultTimedOut);
// Check that the thread isn't terminating. // Check that the thread isn't terminating.
if (cur_thread->IsTerminationRequested()) { if (cur_thread->IsTerminationRequested()) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultTerminationRequested; return ResultTerminationRequested;
} }
// Update the value and process for the next owner. // Update the value and process for the next owner.
@ -302,7 +302,7 @@ ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout)
// Write the value to userspace. // Write the value to userspace.
if (!WriteToUser(system, addr, std::addressof(next_value))) { if (!WriteToUser(system, addr, std::addressof(next_value))) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultInvalidCurrentMemory; return ResultInvalidCurrentMemory;
} }
} }

3
src/core/hle/kernel/k_readable_event.cpp
View File

@ -6,7 +6,6 @@
#include "common/assert.h" #include "common/assert.h"
#include "common/common_funcs.h" #include "common/common_funcs.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/k_readable_event.h" #include "core/hle/kernel/k_readable_event.h"
#include "core/hle/kernel/k_scheduler.h" #include "core/hle/kernel/k_scheduler.h"
#include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/k_thread.h"
@ -47,7 +46,7 @@ ResultCode KReadableEvent::Reset() {
KScopedSchedulerLock lk{kernel}; KScopedSchedulerLock lk{kernel};
if (!is_signaled) { if (!is_signaled) {
return Svc::ResultInvalidState; return ResultInvalidState;
} }
is_signaled = false; is_signaled = false;

2
src/core/hle/kernel/k_resource_limit.cpp
View File

@ -75,7 +75,7 @@ s64 KResourceLimit::GetFreeValue(LimitableResource which) const {
ResultCode KResourceLimit::SetLimitValue(LimitableResource which, s64 value) { ResultCode KResourceLimit::SetLimitValue(LimitableResource which, s64 value) {
const auto index = static_cast<std::size_t>(which); const auto index = static_cast<std::size_t>(which);
KScopedLightLock lk(lock); KScopedLightLock lk(lock);
R_UNLESS(current_values[index] <= value, Svc::ResultInvalidState); R_UNLESS(current_values[index] <= value, ResultInvalidState);
limit_values[index] = value; limit_values[index] = value;

8
src/core/hle/kernel/k_synchronization_object.cpp
View File

@ -40,20 +40,20 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index,
// Check if the timeout is zero. // Check if the timeout is zero.
if (timeout == 0) { if (timeout == 0) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultTimedOut; return ResultTimedOut;
} }
// Check if the thread should terminate. // Check if the thread should terminate.
if (thread->IsTerminationRequested()) { if (thread->IsTerminationRequested()) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultTerminationRequested; return ResultTerminationRequested;
} }
// Check if waiting was canceled. // Check if waiting was canceled.
if (thread->IsWaitCancelled()) { if (thread->IsWaitCancelled()) {
slp.CancelSleep(); slp.CancelSleep();
thread->ClearWaitCancelled(); thread->ClearWaitCancelled();
return Svc::ResultCancelled; return ResultCancelled;
} }
// Add the waiters. // Add the waiters.
@ -75,7 +75,7 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index,
// Mark the thread as waiting. // Mark the thread as waiting.
thread->SetCancellable(); thread->SetCancellable();
thread->SetSyncedObject(nullptr, Svc::ResultTimedOut); thread->SetSyncedObject(nullptr, ResultTimedOut);
thread->SetState(ThreadState::Waiting); thread->SetState(ThreadState::Waiting);
thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Synchronization); thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Synchronization);
} }

30
src/core/hle/kernel/k_thread.cpp
View File

@ -18,7 +18,6 @@
#include "core/core.h" #include "core/core.h"
#include "core/cpu_manager.h" #include "core/cpu_manager.h"
#include "core/hardware_properties.h" #include "core/hardware_properties.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/handle_table.h"
#include "core/hle/kernel/k_condition_variable.h" #include "core/hle/kernel/k_condition_variable.h"
#include "core/hle/kernel/k_resource_limit.h" #include "core/hle/kernel/k_resource_limit.h"
@ -127,7 +126,7 @@ ResultCode KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_s
// Set core ID and wait result. // Set core ID and wait result.
core_id = phys_core; core_id = phys_core;
wait_result = Svc::ResultNoSynchronizationObject; wait_result = ResultNoSynchronizationObject;
// Set priorities. // Set priorities.
priority = prio; priority = prio;
@ -238,7 +237,7 @@ void KThread::Finalize() {
while (it != waiter_list.end()) { while (it != waiter_list.end()) {
// The thread shouldn't be a kernel waiter. // The thread shouldn't be a kernel waiter.
it->SetLockOwner(nullptr); it->SetLockOwner(nullptr);
it->SetSyncedObject(nullptr, Svc::ResultInvalidState); it->SetSyncedObject(nullptr, ResultInvalidState);
it->Wakeup(); it->Wakeup();
it = waiter_list.erase(it); it = waiter_list.erase(it);
} }
@ -447,7 +446,7 @@ ResultCode KThread::SetCoreMask(s32 core_id, u64 v_affinity_mask) {
// If the core id is no-update magic, preserve the ideal core id. // If the core id is no-update magic, preserve the ideal core id.
if (core_id == Svc::IdealCoreNoUpdate) { if (core_id == Svc::IdealCoreNoUpdate) {
core_id = virtual_ideal_core_id; core_id = virtual_ideal_core_id;
R_UNLESS(((1ULL << core_id) & v_affinity_mask) != 0, Svc::ResultInvalidCombination); R_UNLESS(((1ULL << core_id) & v_affinity_mask) != 0, ResultInvalidCombination);
} }
// Set the virtual core/affinity mask. // Set the virtual core/affinity mask.
@ -526,7 +525,7 @@ ResultCode KThread::SetCoreMask(s32 core_id, u64 v_affinity_mask) {
if (GetStackParameters().is_pinned) { if (GetStackParameters().is_pinned) {
// Verify that the current thread isn't terminating. // Verify that the current thread isn't terminating.
R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(), R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(),
Svc::ResultTerminationRequested); ResultTerminationRequested);
// Note that the thread was pinned. // Note that the thread was pinned.
thread_is_pinned = true; thread_is_pinned = true;
@ -604,7 +603,7 @@ void KThread::WaitCancel() {
sleeping_queue->WakeupThread(this); sleeping_queue->WakeupThread(this);
wait_cancelled = true; wait_cancelled = true;
} else { } else {
SetSyncedObject(nullptr, Svc::ResultCancelled); SetSyncedObject(nullptr, ResultCancelled);
SetState(ThreadState::Runnable); SetState(ThreadState::Runnable);
wait_cancelled = false; wait_cancelled = false;
} }
@ -663,12 +662,12 @@ ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
// Verify our state. // Verify our state.
const auto cur_state = GetState(); const auto cur_state = GetState();
R_UNLESS((cur_state == ThreadState::Waiting || cur_state == ThreadState::Runnable), R_UNLESS((cur_state == ThreadState::Waiting || cur_state == ThreadState::Runnable),
Svc::ResultInvalidState); ResultInvalidState);
// Either pause or resume. // Either pause or resume.
if (activity == Svc::ThreadActivity::Paused) { if (activity == Svc::ThreadActivity::Paused) {
// Verify that we're not suspended. // Verify that we're not suspended.
R_UNLESS(!IsSuspendRequested(SuspendType::Thread), Svc::ResultInvalidState); R_UNLESS(!IsSuspendRequested(SuspendType::Thread), ResultInvalidState);
// Suspend. // Suspend.
RequestSuspend(SuspendType::Thread); RequestSuspend(SuspendType::Thread);
@ -676,7 +675,7 @@ ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
ASSERT(activity == Svc::ThreadActivity::Runnable); ASSERT(activity == Svc::ThreadActivity::Runnable);
// Verify that we're suspended. // Verify that we're suspended.
R_UNLESS(IsSuspendRequested(SuspendType::Thread), Svc::ResultInvalidState); R_UNLESS(IsSuspendRequested(SuspendType::Thread), ResultInvalidState);
// Resume. // Resume.
Resume(SuspendType::Thread); Resume(SuspendType::Thread);
@ -698,7 +697,7 @@ ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
if (GetStackParameters().is_pinned) { if (GetStackParameters().is_pinned) {
// Verify that the current thread isn't terminating. // Verify that the current thread isn't terminating.
R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(), R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(),
Svc::ResultTerminationRequested); ResultTerminationRequested);
// Note that the thread was pinned and not current. // Note that the thread was pinned and not current.
thread_is_pinned = true; thread_is_pinned = true;
@ -745,7 +744,7 @@ ResultCode KThread::GetThreadContext3(std::vector<u8>& out) {
KScopedSchedulerLock sl{kernel}; KScopedSchedulerLock sl{kernel};
// Verify that we're suspended. // Verify that we're suspended.
R_UNLESS(IsSuspendRequested(SuspendType::Thread), Svc::ResultInvalidState); R_UNLESS(IsSuspendRequested(SuspendType::Thread), ResultInvalidState);
// If we're not terminating, get the thread's user context. // If we're not terminating, get the thread's user context.
if (!IsTerminationRequested()) { if (!IsTerminationRequested()) {
@ -905,12 +904,11 @@ ResultCode KThread::Run() {
KScopedSchedulerLock lk{kernel}; KScopedSchedulerLock lk{kernel};
// If either this thread or the current thread are requesting termination, note it. // If either this thread or the current thread are requesting termination, note it.
R_UNLESS(!IsTerminationRequested(), Svc::ResultTerminationRequested); R_UNLESS(!IsTerminationRequested(), ResultTerminationRequested);
R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(), R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(), ResultTerminationRequested);
Svc::ResultTerminationRequested);
// Ensure our thread state is correct. // Ensure our thread state is correct.
R_UNLESS(GetState() == ThreadState::Initialized, Svc::ResultInvalidState); R_UNLESS(GetState() == ThreadState::Initialized, ResultInvalidState);
// If the current thread has been asked to suspend, suspend it and retry. // If the current thread has been asked to suspend, suspend it and retry.
if (GetCurrentThread(kernel).IsSuspended()) { if (GetCurrentThread(kernel).IsSuspended()) {
@ -962,7 +960,7 @@ ResultCode KThread::Sleep(s64 timeout) {
// Check if the thread should terminate. // Check if the thread should terminate.
if (IsTerminationRequested()) { if (IsTerminationRequested()) {
slp.CancelSleep(); slp.CancelSleep();
return Svc::ResultTerminationRequested; return ResultTerminationRequested;
} }
// Mark the thread as waiting. // Mark the thread as waiting.

2
src/core/hle/kernel/kernel.cpp
View File

@ -26,7 +26,6 @@
#include "core/device_memory.h" #include "core/device_memory.h"
#include "core/hardware_properties.h" #include "core/hardware_properties.h"
#include "core/hle/kernel/client_port.h" #include "core/hle/kernel/client_port.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/handle_table.h"
#include "core/hle/kernel/k_resource_limit.h" #include "core/hle/kernel/k_resource_limit.h"
#include "core/hle/kernel/k_scheduler.h" #include "core/hle/kernel/k_scheduler.h"
@ -39,6 +38,7 @@
#include "core/hle/kernel/process.h" #include "core/hle/kernel/process.h"
#include "core/hle/kernel/service_thread.h" #include "core/hle/kernel/service_thread.h"
#include "core/hle/kernel/shared_memory.h" #include "core/hle/kernel/shared_memory.h"
#include "core/hle/kernel/svc_results.h"
#include "core/hle/kernel/time_manager.h" #include "core/hle/kernel/time_manager.h"
#include "core/hle/lock.h" #include "core/hle/lock.h"
#include "core/hle/result.h" #include "core/hle/result.h"

6
src/core/hle/kernel/memory/memory_manager.cpp
View File

@ -8,9 +8,9 @@
#include "common/assert.h" #include "common/assert.h"
#include "common/common_types.h" #include "common/common_types.h"
#include "common/scope_exit.h" #include "common/scope_exit.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/memory/memory_manager.h" #include "core/hle/kernel/memory/memory_manager.h"
#include "core/hle/kernel/memory/page_linked_list.h" #include "core/hle/kernel/memory/page_linked_list.h"
#include "core/hle/kernel/svc_results.h"
namespace Kernel::Memory { namespace Kernel::Memory {
@ -95,7 +95,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
// Choose a heap based on our page size request // Choose a heap based on our page size request
const s32 heap_index{PageHeap::GetBlockIndex(num_pages)}; const s32 heap_index{PageHeap::GetBlockIndex(num_pages)};
if (heap_index < 0) { if (heap_index < 0) {
return ERR_OUT_OF_MEMORY; return ResultOutOfMemory;
} }
// TODO (bunnei): Support multiple managers // TODO (bunnei): Support multiple managers
@ -140,7 +140,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
// Only succeed if we allocated as many pages as we wanted // Only succeed if we allocated as many pages as we wanted
if (num_pages) { if (num_pages) {
return ERR_OUT_OF_MEMORY; return ResultOutOfMemory;
} }
// We succeeded! // We succeeded!

48
src/core/hle/kernel/memory/page_table.cpp
View File

@ -6,7 +6,6 @@
#include "common/assert.h" #include "common/assert.h"
#include "common/scope_exit.h" #include "common/scope_exit.h"
#include "core/core.h" #include "core/core.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/k_resource_limit.h" #include "core/hle/kernel/k_resource_limit.h"
#include "core/hle/kernel/kernel.h" #include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/memory/address_space_info.h" #include "core/hle/kernel/memory/address_space_info.h"
@ -16,6 +15,7 @@
#include "core/hle/kernel/memory/page_table.h" #include "core/hle/kernel/memory/page_table.h"
#include "core/hle/kernel/memory/system_control.h" #include "core/hle/kernel/memory/system_control.h"
#include "core/hle/kernel/process.h" #include "core/hle/kernel/process.h"
#include "core/hle/kernel/svc_results.h"
#include "core/memory.h" #include "core/memory.h"
namespace Kernel::Memory { namespace Kernel::Memory {
@ -141,7 +141,7 @@ ResultCode PageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_t
(alias_region_size + heap_region_size + stack_region_size + kernel_map_region_size)}; (alias_region_size + heap_region_size + stack_region_size + kernel_map_region_size)};
if (alloc_size < needed_size) { if (alloc_size < needed_size) {
UNREACHABLE(); UNREACHABLE();
return ERR_OUT_OF_MEMORY; return ResultOutOfMemory;
} }
const std::size_t remaining_size{alloc_size - needed_size}; const std::size_t remaining_size{alloc_size - needed_size};
@ -277,11 +277,11 @@ ResultCode PageTable::MapProcessCode(VAddr addr, std::size_t num_pages, MemorySt
const u64 size{num_pages * PageSize}; const u64 size{num_pages * PageSize};
if (!CanContain(addr, size, state)) { if (!CanContain(addr, size, state)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (IsRegionMapped(addr, size)) { if (IsRegionMapped(addr, size)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
PageLinkedList page_linked_list; PageLinkedList page_linked_list;
@ -307,7 +307,7 @@ ResultCode PageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::
MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)); MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
if (IsRegionMapped(dst_addr, size)) { if (IsRegionMapped(dst_addr, size)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
PageLinkedList page_linked_list; PageLinkedList page_linked_list;
@ -415,7 +415,7 @@ ResultCode PageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
if (process->GetResourceLimit() && if (process->GetResourceLimit() &&
!process->GetResourceLimit()->Reserve(LimitableResource::PhysicalMemory, remaining_size)) { !process->GetResourceLimit()->Reserve(LimitableResource::PhysicalMemory, remaining_size)) {
return ERR_RESOURCE_LIMIT_EXCEEDED; return ResultResourceLimitedExceeded;
} }
PageLinkedList page_linked_list; PageLinkedList page_linked_list;
@ -454,12 +454,12 @@ ResultCode PageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
block_manager->IterateForRange(addr, end_addr, [&](const MemoryInfo& info) { block_manager->IterateForRange(addr, end_addr, [&](const MemoryInfo& info) {
if (info.state == MemoryState::Normal) { if (info.state == MemoryState::Normal) {
if (info.attribute != MemoryAttribute::None) { if (info.attribute != MemoryAttribute::None) {
result = ERR_INVALID_ADDRESS_STATE; result = ResultInvalidCurrentMemory;
return; return;
} }
mapped_size += GetSizeInRange(info, addr, end_addr); mapped_size += GetSizeInRange(info, addr, end_addr);
} else if (info.state != MemoryState::Free) { } else if (info.state != MemoryState::Free) {
result = ERR_INVALID_ADDRESS_STATE; result = ResultInvalidCurrentMemory;
} }
}); });
@ -526,7 +526,7 @@ ResultCode PageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)); MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
if (IsRegionMapped(dst_addr, size)) { if (IsRegionMapped(dst_addr, size)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
PageLinkedList page_linked_list; PageLinkedList page_linked_list;
@ -577,7 +577,7 @@ ResultCode PageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
AddRegionToPages(dst_addr, num_pages, dst_pages); AddRegionToPages(dst_addr, num_pages, dst_pages);
if (!dst_pages.IsEqual(src_pages)) { if (!dst_pages.IsEqual(src_pages)) {
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
{ {
@ -626,11 +626,11 @@ ResultCode PageTable::MapPages(VAddr addr, PageLinkedList& page_linked_list, Mem
const std::size_t size{num_pages * PageSize}; const std::size_t size{num_pages * PageSize};
if (!CanContain(addr, size, state)) { if (!CanContain(addr, size, state)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (IsRegionMapped(addr, num_pages * PageSize)) { if (IsRegionMapped(addr, num_pages * PageSize)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
CASCADE_CODE(MapPages(addr, page_linked_list, perm)); CASCADE_CODE(MapPages(addr, page_linked_list, perm));
@ -768,7 +768,7 @@ ResultCode PageTable::SetHeapCapacity(std::size_t new_heap_capacity) {
ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) { ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {
if (size > heap_region_end - heap_region_start) { if (size > heap_region_end - heap_region_start) {
return ERR_OUT_OF_MEMORY; return ResultOutOfMemory;
} }
const u64 previous_heap_size{GetHeapSize()}; const u64 previous_heap_size{GetHeapSize()};
@ -784,7 +784,7 @@ ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {
auto process{system.Kernel().CurrentProcess()}; auto process{system.Kernel().CurrentProcess()};
if (process->GetResourceLimit() && delta != 0 && if (process->GetResourceLimit() && delta != 0 &&
!process->GetResourceLimit()->Reserve(LimitableResource::PhysicalMemory, delta)) { !process->GetResourceLimit()->Reserve(LimitableResource::PhysicalMemory, delta)) {
return ERR_RESOURCE_LIMIT_EXCEEDED; return ResultResourceLimitedExceeded;
} }
PageLinkedList page_linked_list; PageLinkedList page_linked_list;
@ -794,7 +794,7 @@ ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {
system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool)); system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool));
if (IsRegionMapped(current_heap_addr, delta)) { if (IsRegionMapped(current_heap_addr, delta)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
CASCADE_CODE( CASCADE_CODE(
@ -816,17 +816,17 @@ ResultVal<VAddr> PageTable::AllocateAndMapMemory(std::size_t needed_num_pages, s
std::lock_guard lock{page_table_lock}; std::lock_guard lock{page_table_lock};
if (!CanContain(region_start, region_num_pages * PageSize, state)) { if (!CanContain(region_start, region_num_pages * PageSize, state)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (region_num_pages <= needed_num_pages) { if (region_num_pages <= needed_num_pages) {
return ERR_OUT_OF_MEMORY; return ResultOutOfMemory;
} }
const VAddr addr{ const VAddr addr{
AllocateVirtualMemory(region_start, region_num_pages, needed_num_pages, align)}; AllocateVirtualMemory(region_start, region_num_pages, needed_num_pages, align)};
if (!addr) { if (!addr) {
return ERR_OUT_OF_MEMORY; return ResultOutOfMemory;
} }
if (is_map_only) { if (is_map_only) {
@ -1105,13 +1105,13 @@ constexpr ResultCode PageTable::CheckMemoryState(const MemoryInfo& info, MemoryS
MemoryAttribute attr) const { MemoryAttribute attr) const {
// Validate the states match expectation // Validate the states match expectation
if ((info.state & state_mask) != state) { if ((info.state & state_mask) != state) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if ((info.perm & perm_mask) != perm) { if ((info.perm & perm_mask) != perm) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if ((info.attribute & attr_mask) != attr) { if ((info.attribute & attr_mask) != attr) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
return RESULT_SUCCESS; return RESULT_SUCCESS;
@ -1138,14 +1138,14 @@ ResultCode PageTable::CheckMemoryState(MemoryState* out_state, MemoryPermission*
while (true) { while (true) {
// Validate the current block // Validate the current block
if (!(info.state == first_state)) { if (!(info.state == first_state)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (!(info.perm == first_perm)) { if (!(info.perm == first_perm)) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (!((info.attribute | static_cast<MemoryAttribute>(ignore_attr)) == if (!((info.attribute | static_cast<MemoryAttribute>(ignore_attr)) ==
(first_attr | static_cast<MemoryAttribute>(ignore_attr)))) { (first_attr | static_cast<MemoryAttribute>(ignore_attr)))) {
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
// Validate against the provided masks // Validate against the provided masks

5
src/core/hle/kernel/process.cpp
View File

@ -14,7 +14,6 @@
#include "core/device_memory.h" #include "core/device_memory.h"
#include "core/file_sys/program_metadata.h" #include "core/file_sys/program_metadata.h"
#include "core/hle/kernel/code_set.h" #include "core/hle/kernel/code_set.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/k_resource_limit.h" #include "core/hle/kernel/k_resource_limit.h"
#include "core/hle/kernel/k_scheduler.h" #include "core/hle/kernel/k_scheduler.h"
#include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/k_thread.h"
@ -248,8 +247,8 @@ ResultCode Process::Reset() {
KScopedSchedulerLock sl{kernel}; KScopedSchedulerLock sl{kernel};
// Validate that we're in a state that we can reset. // Validate that we're in a state that we can reset.
R_UNLESS(status != ProcessStatus::Exited, Svc::ResultInvalidState); R_UNLESS(status != ProcessStatus::Exited, ResultInvalidState);
R_UNLESS(is_signaled, Svc::ResultInvalidState); R_UNLESS(is_signaled, ResultInvalidState);
// Clear signaled. // Clear signaled.
is_signaled = false; is_signaled = false;

34
src/core/hle/kernel/process_capability.cpp
View File

@ -6,10 +6,10 @@
#include "common/bit_util.h" #include "common/bit_util.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/handle_table.h"
#include "core/hle/kernel/memory/page_table.h" #include "core/hle/kernel/memory/page_table.h"
#include "core/hle/kernel/process_capability.h" #include "core/hle/kernel/process_capability.h"
#include "core/hle/kernel/svc_results.h"
namespace Kernel { namespace Kernel {
namespace { namespace {
@ -123,13 +123,13 @@ ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
// If there's only one, then there's a problem. // If there's only one, then there's a problem.
if (i >= num_capabilities) { if (i >= num_capabilities) {
LOG_ERROR(Kernel, "Invalid combination! i={}", i); LOG_ERROR(Kernel, "Invalid combination! i={}", i);
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
const auto size_flags = capabilities[i]; const auto size_flags = capabilities[i];
if (GetCapabilityType(size_flags) != CapabilityType::MapPhysical) { if (GetCapabilityType(size_flags) != CapabilityType::MapPhysical) {
LOG_ERROR(Kernel, "Invalid capability type! size_flags={}", size_flags); LOG_ERROR(Kernel, "Invalid capability type! size_flags={}", size_flags);
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
const auto result = HandleMapPhysicalFlags(descriptor, size_flags, page_table); const auto result = HandleMapPhysicalFlags(descriptor, size_flags, page_table);
@ -159,7 +159,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
const auto type = GetCapabilityType(flag); const auto type = GetCapabilityType(flag);
if (type == CapabilityType::Unset) { if (type == CapabilityType::Unset) {
return ERR_INVALID_CAPABILITY_DESCRIPTOR; return ResultInvalidCapabilityDescriptor;
} }
// Bail early on ignorable entries, as one would expect, // Bail early on ignorable entries, as one would expect,
@ -176,7 +176,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
LOG_ERROR(Kernel, LOG_ERROR(Kernel,
"Attempted to initialize flags that may only be initialized once. set_flags={}", "Attempted to initialize flags that may only be initialized once. set_flags={}",
set_flags); set_flags);
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
set_flags |= set_flag; set_flags |= set_flag;
@ -202,7 +202,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
} }
LOG_ERROR(Kernel, "Invalid capability type! type={}", type); LOG_ERROR(Kernel, "Invalid capability type! type={}", type);
return ERR_INVALID_CAPABILITY_DESCRIPTOR; return ResultInvalidCapabilityDescriptor;
} }
void ProcessCapabilities::Clear() { void ProcessCapabilities::Clear() {
@ -225,7 +225,7 @@ ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
if (priority_mask != 0 || core_mask != 0) { if (priority_mask != 0 || core_mask != 0) {
LOG_ERROR(Kernel, "Core or priority mask are not zero! priority_mask={}, core_mask={}", LOG_ERROR(Kernel, "Core or priority mask are not zero! priority_mask={}, core_mask={}",
priority_mask, core_mask); priority_mask, core_mask);
return ERR_INVALID_CAPABILITY_DESCRIPTOR; return ResultInvalidCapabilityDescriptor;
} }
const u32 core_num_min = (flags >> 16) & 0xFF; const u32 core_num_min = (flags >> 16) & 0xFF;
@ -233,7 +233,7 @@ ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
if (core_num_min > core_num_max) { if (core_num_min > core_num_max) {
LOG_ERROR(Kernel, "Core min is greater than core max! core_num_min={}, core_num_max={}", LOG_ERROR(Kernel, "Core min is greater than core max! core_num_min={}, core_num_max={}",
core_num_min, core_num_max); core_num_min, core_num_max);
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
const u32 priority_min = (flags >> 10) & 0x3F; const u32 priority_min = (flags >> 10) & 0x3F;
@ -242,13 +242,13 @@ ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
LOG_ERROR(Kernel, LOG_ERROR(Kernel,
"Priority min is greater than priority max! priority_min={}, priority_max={}", "Priority min is greater than priority max! priority_min={}, priority_max={}",
core_num_min, priority_max); core_num_min, priority_max);
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
// The switch only has 4 usable cores. // The switch only has 4 usable cores.
if (core_num_max >= 4) { if (core_num_max >= 4) {
LOG_ERROR(Kernel, "Invalid max cores specified! core_num_max={}", core_num_max); LOG_ERROR(Kernel, "Invalid max cores specified! core_num_max={}", core_num_max);
return ERR_INVALID_PROCESSOR_ID; return ResultInvalidCoreId;
} }
const auto make_mask = [](u64 min, u64 max) { const auto make_mask = [](u64 min, u64 max) {
@ -269,7 +269,7 @@ ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags)
// If we've already set this svc before, bail. // If we've already set this svc before, bail.
if ((set_svc_bits & svc_bit) != 0) { if ((set_svc_bits & svc_bit) != 0) {
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
set_svc_bits |= svc_bit; set_svc_bits |= svc_bit;
@ -283,7 +283,7 @@ ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags)
if (svc_number >= svc_capabilities.size()) { if (svc_number >= svc_capabilities.size()) {
LOG_ERROR(Kernel, "Process svc capability is out of range! svc_number={}", svc_number); LOG_ERROR(Kernel, "Process svc capability is out of range! svc_number={}", svc_number);
return ERR_OUT_OF_RANGE; return ResultOutOfRange;
} }
svc_capabilities[svc_number] = true; svc_capabilities[svc_number] = true;
@ -321,7 +321,7 @@ ResultCode ProcessCapabilities::HandleInterruptFlags(u32 flags) {
if (interrupt >= interrupt_capabilities.size()) { if (interrupt >= interrupt_capabilities.size()) {
LOG_ERROR(Kernel, "Process interrupt capability is out of range! svc_number={}", LOG_ERROR(Kernel, "Process interrupt capability is out of range! svc_number={}",
interrupt); interrupt);
return ERR_OUT_OF_RANGE; return ResultOutOfRange;
} }
interrupt_capabilities[interrupt] = true; interrupt_capabilities[interrupt] = true;
@ -334,7 +334,7 @@ ResultCode ProcessCapabilities::HandleProgramTypeFlags(u32 flags) {
const u32 reserved = flags >> 17; const u32 reserved = flags >> 17;
if (reserved != 0) { if (reserved != 0) {
LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved); LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
return ERR_RESERVED_VALUE; return ResultReservedValue;
} }
program_type = static_cast<ProgramType>((flags >> 14) & 0b111); program_type = static_cast<ProgramType>((flags >> 14) & 0b111);
@ -354,7 +354,7 @@ ResultCode ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
LOG_ERROR(Kernel, LOG_ERROR(Kernel,
"Kernel version is non zero or flags are too small! major_version={}, flags={}", "Kernel version is non zero or flags are too small! major_version={}, flags={}",
major_version, flags); major_version, flags);
return ERR_INVALID_CAPABILITY_DESCRIPTOR; return ResultInvalidCapabilityDescriptor;
} }
kernel_version = flags; kernel_version = flags;
@ -365,7 +365,7 @@ ResultCode ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
const u32 reserved = flags >> 26; const u32 reserved = flags >> 26;
if (reserved != 0) { if (reserved != 0) {
LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved); LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
return ERR_RESERVED_VALUE; return ResultReservedValue;
} }
handle_table_size = static_cast<s32>((flags >> 16) & 0x3FF); handle_table_size = static_cast<s32>((flags >> 16) & 0x3FF);
@ -376,7 +376,7 @@ ResultCode ProcessCapabilities::HandleDebugFlags(u32 flags) {
const u32 reserved = flags >> 19; const u32 reserved = flags >> 19;
if (reserved != 0) { if (reserved != 0) {
LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved); LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
return ERR_RESERVED_VALUE; return ResultReservedValue;
} }
is_debuggable = (flags & 0x20000) != 0; is_debuggable = (flags & 0x20000) != 0;

4
src/core/hle/kernel/server_port.cpp
View File

@ -5,11 +5,11 @@
#include <tuple> #include <tuple>
#include "common/assert.h" #include "common/assert.h"
#include "core/hle/kernel/client_port.h" #include "core/hle/kernel/client_port.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/k_thread.h"
#include "core/hle/kernel/object.h" #include "core/hle/kernel/object.h"
#include "core/hle/kernel/server_port.h" #include "core/hle/kernel/server_port.h"
#include "core/hle/kernel/server_session.h" #include "core/hle/kernel/server_session.h"
#include "core/hle/kernel/svc_results.h"
namespace Kernel { namespace Kernel {
@ -18,7 +18,7 @@ ServerPort::~ServerPort() = default;
ResultVal<std::shared_ptr<ServerSession>> ServerPort::Accept() { ResultVal<std::shared_ptr<ServerSession>> ServerPort::Accept() {
if (pending_sessions.empty()) { if (pending_sessions.empty()) {
return ERR_NOT_FOUND; return ResultNotFound;
} }
auto session = std::move(pending_sessions.back()); auto session = std::move(pending_sessions.back());

196
src/core/hle/kernel/svc.cpp
View File

@ -23,7 +23,6 @@
#include "core/cpu_manager.h" #include "core/cpu_manager.h"
#include "core/hle/kernel/client_port.h" #include "core/hle/kernel/client_port.h"
#include "core/hle/kernel/client_session.h" #include "core/hle/kernel/client_session.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/handle_table.h"
#include "core/hle/kernel/k_address_arbiter.h" #include "core/hle/kernel/k_address_arbiter.h"
#include "core/hle/kernel/k_condition_variable.h" #include "core/hle/kernel/k_condition_variable.h"
@ -71,49 +70,49 @@ ResultCode MapUnmapMemorySanityChecks(const Memory::PageTable& manager, VAddr ds
VAddr src_addr, u64 size) { VAddr src_addr, u64 size) {
if (!Common::Is4KBAligned(dst_addr)) { if (!Common::Is4KBAligned(dst_addr)) {
LOG_ERROR(Kernel_SVC, "Destination address is not aligned to 4KB, 0x{:016X}", dst_addr); LOG_ERROR(Kernel_SVC, "Destination address is not aligned to 4KB, 0x{:016X}", dst_addr);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (!Common::Is4KBAligned(src_addr)) { if (!Common::Is4KBAligned(src_addr)) {
LOG_ERROR(Kernel_SVC, "Source address is not aligned to 4KB, 0x{:016X}", src_addr); LOG_ERROR(Kernel_SVC, "Source address is not aligned to 4KB, 0x{:016X}", src_addr);
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (size == 0) { if (size == 0) {
LOG_ERROR(Kernel_SVC, "Size is 0"); LOG_ERROR(Kernel_SVC, "Size is 0");
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (!Common::Is4KBAligned(size)) { if (!Common::Is4KBAligned(size)) {
LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:016X}", size); LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:016X}", size);
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (!IsValidAddressRange(dst_addr, size)) { if (!IsValidAddressRange(dst_addr, size)) {
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Destination is not a valid address range, addr=0x{:016X}, size=0x{:016X}", "Destination is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
dst_addr, size); dst_addr, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (!IsValidAddressRange(src_addr, size)) { if (!IsValidAddressRange(src_addr, size)) {
LOG_ERROR(Kernel_SVC, "Source is not a valid address range, addr=0x{:016X}, size=0x{:016X}", LOG_ERROR(Kernel_SVC, "Source is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
src_addr, size); src_addr, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (!manager.IsInsideAddressSpace(src_addr, size)) { if (!manager.IsInsideAddressSpace(src_addr, size)) {
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Source is not within the address space, addr=0x{:016X}, size=0x{:016X}", "Source is not within the address space, addr=0x{:016X}, size=0x{:016X}",
src_addr, size); src_addr, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (manager.IsOutsideStackRegion(dst_addr, size)) { if (manager.IsOutsideStackRegion(dst_addr, size)) {
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Destination is not within the stack region, addr=0x{:016X}, size=0x{:016X}", "Destination is not within the stack region, addr=0x{:016X}, size=0x{:016X}",
dst_addr, size); dst_addr, size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
if (manager.IsInsideHeapRegion(dst_addr, size)) { if (manager.IsInsideHeapRegion(dst_addr, size)) {
@ -121,7 +120,7 @@ ResultCode MapUnmapMemorySanityChecks(const Memory::PageTable& manager, VAddr ds
"Destination does not fit within the heap region, addr=0x{:016X}, " "Destination does not fit within the heap region, addr=0x{:016X}, "
"size=0x{:016X}", "size=0x{:016X}",
dst_addr, size); dst_addr, size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
if (manager.IsInsideAliasRegion(dst_addr, size)) { if (manager.IsInsideAliasRegion(dst_addr, size)) {
@ -129,7 +128,7 @@ ResultCode MapUnmapMemorySanityChecks(const Memory::PageTable& manager, VAddr ds
"Destination does not fit within the map region, addr=0x{:016X}, " "Destination does not fit within the map region, addr=0x{:016X}, "
"size=0x{:016X}", "size=0x{:016X}",
dst_addr, size); dst_addr, size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
return RESULT_SUCCESS; return RESULT_SUCCESS;
@ -146,7 +145,7 @@ ResultVal<s64> RetrieveResourceLimitValue(Core::System& system, Handle resource_
const auto type = static_cast<LimitableResource>(resource_type); const auto type = static_cast<LimitableResource>(resource_type);
if (!IsValidResourceType(type)) { if (!IsValidResourceType(type)) {
LOG_ERROR(Kernel_SVC, "Invalid resource limit type: '{}'", resource_type); LOG_ERROR(Kernel_SVC, "Invalid resource limit type: '{}'", resource_type);
return ERR_INVALID_ENUM_VALUE; return ResultInvalidEnumValue;
} }
const auto* const current_process = system.Kernel().CurrentProcess(); const auto* const current_process = system.Kernel().CurrentProcess();
@ -157,7 +156,7 @@ ResultVal<s64> RetrieveResourceLimitValue(Core::System& system, Handle resource_
if (!resource_limit_object) { if (!resource_limit_object) {
LOG_ERROR(Kernel_SVC, "Handle to non-existent resource limit instance used. Handle={:08X}", LOG_ERROR(Kernel_SVC, "Handle to non-existent resource limit instance used. Handle={:08X}",
resource_limit); resource_limit);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
if (value_type == ResourceLimitValueType::CurrentValue) { if (value_type == ResourceLimitValueType::CurrentValue) {
@ -177,12 +176,12 @@ static ResultCode SetHeapSize(Core::System& system, VAddr* heap_addr, u64 heap_s
if ((heap_size % 0x200000) != 0) { if ((heap_size % 0x200000) != 0) {
LOG_ERROR(Kernel_SVC, "The heap size is not a multiple of 2MB, heap_size=0x{:016X}", LOG_ERROR(Kernel_SVC, "The heap size is not a multiple of 2MB, heap_size=0x{:016X}",
heap_size); heap_size);
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (heap_size >= 0x200000000) { if (heap_size >= 0x200000000) {
LOG_ERROR(Kernel_SVC, "The heap size is not less than 8GB, heap_size=0x{:016X}", heap_size); LOG_ERROR(Kernel_SVC, "The heap size is not less than 8GB, heap_size=0x{:016X}", heap_size);
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
auto& page_table{system.Kernel().CurrentProcess()->PageTable()}; auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
@ -208,19 +207,19 @@ static ResultCode SetMemoryAttribute(Core::System& system, VAddr address, u64 si
if (!Common::Is4KBAligned(address)) { if (!Common::Is4KBAligned(address)) {
LOG_ERROR(Kernel_SVC, "Address not page aligned (0x{:016X})", address); LOG_ERROR(Kernel_SVC, "Address not page aligned (0x{:016X})", address);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (size == 0 || !Common::Is4KBAligned(size)) { if (size == 0 || !Common::Is4KBAligned(size)) {
LOG_ERROR(Kernel_SVC, "Invalid size (0x{:X}). Size must be non-zero and page aligned.", LOG_ERROR(Kernel_SVC, "Invalid size (0x{:X}). Size must be non-zero and page aligned.",
size); size);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (!IsValidAddressRange(address, size)) { if (!IsValidAddressRange(address, size)) {
LOG_ERROR(Kernel_SVC, "Address range overflowed (Address: 0x{:016X}, Size: 0x{:016X})", LOG_ERROR(Kernel_SVC, "Address range overflowed (Address: 0x{:016X}, Size: 0x{:016X})",
address, size); address, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
const auto attributes{static_cast<Memory::MemoryAttribute>(mask | attribute)}; const auto attributes{static_cast<Memory::MemoryAttribute>(mask | attribute)};
@ -229,7 +228,7 @@ static ResultCode SetMemoryAttribute(Core::System& system, VAddr address, u64 si
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Memory attribute doesn't match the given mask (Attribute: 0x{:X}, Mask: {:X}", "Memory attribute doesn't match the given mask (Attribute: 0x{:X}, Mask: {:X}",
attribute, mask); attribute, mask);
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
auto& page_table{system.Kernel().CurrentProcess()->PageTable()}; auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
@ -293,7 +292,7 @@ static ResultCode ConnectToNamedPort(Core::System& system, Handle* out_handle,
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Port Name Address is not a valid virtual address, port_name_address=0x{:016X}", "Port Name Address is not a valid virtual address, port_name_address=0x{:016X}",
port_name_address); port_name_address);
return ERR_NOT_FOUND; return ResultNotFound;
} }
static constexpr std::size_t PortNameMaxLength = 11; static constexpr std::size_t PortNameMaxLength = 11;
@ -302,7 +301,7 @@ static ResultCode ConnectToNamedPort(Core::System& system, Handle* out_handle,
if (port_name.size() > PortNameMaxLength) { if (port_name.size() > PortNameMaxLength) {
LOG_ERROR(Kernel_SVC, "Port name is too long, expected {} but got {}", PortNameMaxLength, LOG_ERROR(Kernel_SVC, "Port name is too long, expected {} but got {}", PortNameMaxLength,
port_name.size()); port_name.size());
return ERR_OUT_OF_RANGE; return ResultOutOfRange;
} }
LOG_TRACE(Kernel_SVC, "called port_name={}", port_name); LOG_TRACE(Kernel_SVC, "called port_name={}", port_name);
@ -311,7 +310,7 @@ static ResultCode ConnectToNamedPort(Core::System& system, Handle* out_handle,
const auto it = kernel.FindNamedPort(port_name); const auto it = kernel.FindNamedPort(port_name);
if (!kernel.IsValidNamedPort(it)) { if (!kernel.IsValidNamedPort(it)) {
LOG_WARNING(Kernel_SVC, "tried to connect to unknown port: {}", port_name); LOG_WARNING(Kernel_SVC, "tried to connect to unknown port: {}", port_name);
return ERR_NOT_FOUND; return ResultNotFound;
} }
ASSERT(kernel.CurrentProcess()->GetResourceLimit()->Reserve(LimitableResource::Sessions, 1)); ASSERT(kernel.CurrentProcess()->GetResourceLimit()->Reserve(LimitableResource::Sessions, 1));
@ -340,7 +339,7 @@ static ResultCode SendSyncRequest(Core::System& system, Handle handle) {
std::shared_ptr<ClientSession> session = handle_table.Get<ClientSession>(handle); std::shared_ptr<ClientSession> session = handle_table.Get<ClientSession>(handle);
if (!session) { if (!session) {
LOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle); LOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
LOG_TRACE(Kernel_SVC, "called handle=0x{:08X}({})", handle, session->GetName()); LOG_TRACE(Kernel_SVC, "called handle=0x{:08X}({})", handle, session->GetName());
@ -405,7 +404,7 @@ static ResultCode GetProcessId(Core::System& system, u64* process_id, Handle han
const Process* const owner_process = thread->GetOwnerProcess(); const Process* const owner_process = thread->GetOwnerProcess();
if (!owner_process) { if (!owner_process) {
LOG_ERROR(Kernel_SVC, "Non-existent owning process encountered."); LOG_ERROR(Kernel_SVC, "Non-existent owning process encountered.");
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
*process_id = owner_process->GetProcessID(); *process_id = owner_process->GetProcessID();
@ -415,7 +414,7 @@ static ResultCode GetProcessId(Core::System& system, u64* process_id, Handle han
// NOTE: This should also handle debug objects before returning. // NOTE: This should also handle debug objects before returning.
LOG_ERROR(Kernel_SVC, "Handle does not exist, handle=0x{:08X}", handle); LOG_ERROR(Kernel_SVC, "Handle does not exist, handle=0x{:08X}", handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
static ResultCode GetProcessId32(Core::System& system, u32* process_id_low, u32* process_id_high, static ResultCode GetProcessId32(Core::System& system, u32* process_id_low, u32* process_id_high,
@ -438,7 +437,7 @@ static ResultCode WaitSynchronization(Core::System& system, s32* index, VAddr ha
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Handle address is not a valid virtual address, handle_address=0x{:016X}", "Handle address is not a valid virtual address, handle_address=0x{:016X}",
handles_address); handles_address);
return ERR_INVALID_POINTER; return ResultInvalidPointer;
} }
static constexpr u64 MaxHandles = 0x40; static constexpr u64 MaxHandles = 0x40;
@ -446,7 +445,7 @@ static ResultCode WaitSynchronization(Core::System& system, s32* index, VAddr ha
if (handle_count > MaxHandles) { if (handle_count > MaxHandles) {
LOG_ERROR(Kernel_SVC, "Handle count specified is too large, expected {} but got {}", LOG_ERROR(Kernel_SVC, "Handle count specified is too large, expected {} but got {}",
MaxHandles, handle_count); MaxHandles, handle_count);
return ERR_OUT_OF_RANGE; return ResultOutOfRange;
} }
auto& kernel = system.Kernel(); auto& kernel = system.Kernel();
@ -459,7 +458,7 @@ static ResultCode WaitSynchronization(Core::System& system, s32* index, VAddr ha
if (object == nullptr) { if (object == nullptr) {
LOG_ERROR(Kernel_SVC, "Object is a nullptr"); LOG_ERROR(Kernel_SVC, "Object is a nullptr");
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
objects[i] = object.get(); objects[i] = object.get();
@ -481,6 +480,7 @@ static ResultCode CancelSynchronization(Core::System& system, Handle thread_hand
// Get the thread from its handle. // Get the thread from its handle.
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable(); const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
std::shared_ptr<KThread> thread = handle_table.Get<KThread>(thread_handle); std::shared_ptr<KThread> thread = handle_table.Get<KThread>(thread_handle);
if (!thread) { if (!thread) {
LOG_ERROR(Kernel_SVC, "Invalid thread handle provided (handle={:08X})", thread_handle); LOG_ERROR(Kernel_SVC, "Invalid thread handle provided (handle={:08X})", thread_handle);
return ResultInvalidHandle; return ResultInvalidHandle;
@ -525,6 +525,7 @@ static ResultCode ArbitrateUnlock(Core::System& system, VAddr address) {
LOG_TRACE(Kernel_SVC, "called address=0x{:X}", address); LOG_TRACE(Kernel_SVC, "called address=0x{:X}", address);
// Validate the input address. // Validate the input address.
if (Memory::IsKernelAddress(address)) { if (Memory::IsKernelAddress(address)) {
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Attempting to arbitrate an unlock on a kernel address (address={:08X})", "Attempting to arbitrate an unlock on a kernel address (address={:08X})",
@ -735,7 +736,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
if (info_sub_id != 0) { if (info_sub_id != 0) {
LOG_ERROR(Kernel_SVC, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id, LOG_ERROR(Kernel_SVC, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id,
info_sub_id); info_sub_id);
return ERR_INVALID_ENUM_VALUE; return ResultInvalidEnumValue;
} }
const auto& current_process_handle_table = const auto& current_process_handle_table =
@ -744,7 +745,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
if (!process) { if (!process) {
LOG_ERROR(Kernel_SVC, "Process is not valid! info_id={}, info_sub_id={}, handle={:08X}", LOG_ERROR(Kernel_SVC, "Process is not valid! info_id={}, info_sub_id={}, handle={:08X}",
info_id, info_sub_id, handle); info_id, info_sub_id, handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
switch (info_id_type) { switch (info_id_type) {
@ -826,7 +827,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
} }
LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id=0x{:016X}", info_id); LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id=0x{:016X}", info_id);
return ERR_INVALID_ENUM_VALUE; return ResultInvalidEnumValue;
} }
case GetInfoType::IsCurrentProcessBeingDebugged: case GetInfoType::IsCurrentProcessBeingDebugged:
@ -836,13 +837,13 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
case GetInfoType::RegisterResourceLimit: { case GetInfoType::RegisterResourceLimit: {
if (handle != 0) { if (handle != 0) {
LOG_ERROR(Kernel, "Handle is non zero! handle={:08X}", handle); LOG_ERROR(Kernel, "Handle is non zero! handle={:08X}", handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
if (info_sub_id != 0) { if (info_sub_id != 0) {
LOG_ERROR(Kernel, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id, LOG_ERROR(Kernel, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id,
info_sub_id); info_sub_id);
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
Process* const current_process = system.Kernel().CurrentProcess(); Process* const current_process = system.Kernel().CurrentProcess();
@ -867,13 +868,13 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
if (handle != 0) { if (handle != 0) {
LOG_ERROR(Kernel_SVC, "Process Handle is non zero, expected 0 result but got {:016X}", LOG_ERROR(Kernel_SVC, "Process Handle is non zero, expected 0 result but got {:016X}",
handle); handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
if (info_sub_id >= Process::RANDOM_ENTROPY_SIZE) { if (info_sub_id >= Process::RANDOM_ENTROPY_SIZE) {
LOG_ERROR(Kernel_SVC, "Entropy size is out of range, expected {} but got {}", LOG_ERROR(Kernel_SVC, "Entropy size is out of range, expected {} but got {}",
Process::RANDOM_ENTROPY_SIZE, info_sub_id); Process::RANDOM_ENTROPY_SIZE, info_sub_id);
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
*result = system.Kernel().CurrentProcess()->GetRandomEntropy(info_sub_id); *result = system.Kernel().CurrentProcess()->GetRandomEntropy(info_sub_id);
@ -890,7 +891,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) { if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
LOG_ERROR(Kernel_SVC, "Core count is out of range, expected {} but got {}", num_cpus, LOG_ERROR(Kernel_SVC, "Core count is out of range, expected {} but got {}", num_cpus,
info_sub_id); info_sub_id);
return ERR_INVALID_COMBINATION; return ResultInvalidCombination;
} }
const auto thread = system.Kernel().CurrentProcess()->GetHandleTable().Get<KThread>( const auto thread = system.Kernel().CurrentProcess()->GetHandleTable().Get<KThread>(
@ -898,7 +899,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
if (!thread) { if (!thread) {
LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}",
static_cast<Handle>(handle)); static_cast<Handle>(handle));
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
const auto& core_timing = system.CoreTiming(); const auto& core_timing = system.CoreTiming();
@ -922,7 +923,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
default: default:
LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id=0x{:016X}", info_id); LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id=0x{:016X}", info_id);
return ERR_INVALID_ENUM_VALUE; return ResultInvalidEnumValue;
} }
} }
@ -945,22 +946,22 @@ static ResultCode MapPhysicalMemory(Core::System& system, VAddr addr, u64 size)
if (!Common::Is4KBAligned(addr)) { if (!Common::Is4KBAligned(addr)) {
LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr); LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (!Common::Is4KBAligned(size)) { if (!Common::Is4KBAligned(size)) {
LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size); LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size);
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (size == 0) { if (size == 0) {
LOG_ERROR(Kernel_SVC, "Size is zero"); LOG_ERROR(Kernel_SVC, "Size is zero");
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (!(addr < addr + size)) { if (!(addr < addr + size)) {
LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address"); LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address");
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
Process* const current_process{system.Kernel().CurrentProcess()}; Process* const current_process{system.Kernel().CurrentProcess()};
@ -968,21 +969,21 @@ static ResultCode MapPhysicalMemory(Core::System& system, VAddr addr, u64 size)
if (current_process->GetSystemResourceSize() == 0) { if (current_process->GetSystemResourceSize() == 0) {
LOG_ERROR(Kernel_SVC, "System Resource Size is zero"); LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
return ERR_INVALID_STATE; return ResultInvalidState;
} }
if (!page_table.IsInsideAddressSpace(addr, size)) { if (!page_table.IsInsideAddressSpace(addr, size)) {
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Address is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr, "Address is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr,
size); size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
if (page_table.IsOutsideAliasRegion(addr, size)) { if (page_table.IsOutsideAliasRegion(addr, size)) {
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Address is not within the alias region, addr=0x{:016X}, size=0x{:016X}", addr, "Address is not within the alias region, addr=0x{:016X}, size=0x{:016X}", addr,
size); size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
return page_table.MapPhysicalMemory(addr, size); return page_table.MapPhysicalMemory(addr, size);
@ -999,22 +1000,22 @@ static ResultCode UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size
if (!Common::Is4KBAligned(addr)) { if (!Common::Is4KBAligned(addr)) {
LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr); LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (!Common::Is4KBAligned(size)) { if (!Common::Is4KBAligned(size)) {
LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size); LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size);
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (size == 0) { if (size == 0) {
LOG_ERROR(Kernel_SVC, "Size is zero"); LOG_ERROR(Kernel_SVC, "Size is zero");
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (!(addr < addr + size)) { if (!(addr < addr + size)) {
LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address"); LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address");
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
Process* const current_process{system.Kernel().CurrentProcess()}; Process* const current_process{system.Kernel().CurrentProcess()};
@ -1022,21 +1023,21 @@ static ResultCode UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size
if (current_process->GetSystemResourceSize() == 0) { if (current_process->GetSystemResourceSize() == 0) {
LOG_ERROR(Kernel_SVC, "System Resource Size is zero"); LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
return ERR_INVALID_STATE; return ResultInvalidState;
} }
if (!page_table.IsInsideAddressSpace(addr, size)) { if (!page_table.IsInsideAddressSpace(addr, size)) {
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Address is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr, "Address is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr,
size); size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
if (page_table.IsOutsideAliasRegion(addr, size)) { if (page_table.IsOutsideAliasRegion(addr, size)) {
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Address is not within the alias region, addr=0x{:016X}, size=0x{:016X}", addr, "Address is not within the alias region, addr=0x{:016X}, size=0x{:016X}", addr,
size); size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
return page_table.UnmapPhysicalMemory(addr, size); return page_table.UnmapPhysicalMemory(addr, size);
@ -1206,23 +1207,23 @@ static ResultCode MapSharedMemory(Core::System& system, Handle shared_memory_han
if (!Common::Is4KBAligned(addr)) { if (!Common::Is4KBAligned(addr)) {
LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, addr=0x{:016X}", addr); LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, addr=0x{:016X}", addr);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (size == 0) { if (size == 0) {
LOG_ERROR(Kernel_SVC, "Size is 0"); LOG_ERROR(Kernel_SVC, "Size is 0");
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (!Common::Is4KBAligned(size)) { if (!Common::Is4KBAligned(size)) {
LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, size=0x{:016X}", size); LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, size=0x{:016X}", size);
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (!IsValidAddressRange(addr, size)) { if (!IsValidAddressRange(addr, size)) {
LOG_ERROR(Kernel_SVC, "Region is not a valid address range, addr=0x{:016X}, size=0x{:016X}", LOG_ERROR(Kernel_SVC, "Region is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
addr, size); addr, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
const auto permission_type = static_cast<Memory::MemoryPermission>(permissions); const auto permission_type = static_cast<Memory::MemoryPermission>(permissions);
@ -1230,7 +1231,7 @@ static ResultCode MapSharedMemory(Core::System& system, Handle shared_memory_han
Memory::MemoryPermission::ReadAndWrite) { Memory::MemoryPermission::ReadAndWrite) {
LOG_ERROR(Kernel_SVC, "Expected Read or ReadWrite permission but got permissions=0x{:08X}", LOG_ERROR(Kernel_SVC, "Expected Read or ReadWrite permission but got permissions=0x{:08X}",
permissions); permissions);
return ERR_INVALID_MEMORY_PERMISSIONS; return ResultInvalidMemoryPermissions;
} }
auto* const current_process{system.Kernel().CurrentProcess()}; auto* const current_process{system.Kernel().CurrentProcess()};
@ -1241,7 +1242,7 @@ static ResultCode MapSharedMemory(Core::System& system, Handle shared_memory_han
"Addr does not fit within the valid region, addr=0x{:016X}, " "Addr does not fit within the valid region, addr=0x{:016X}, "
"size=0x{:016X}", "size=0x{:016X}",
addr, size); addr, size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
if (page_table.IsInsideHeapRegion(addr, size)) { if (page_table.IsInsideHeapRegion(addr, size)) {
@ -1249,7 +1250,7 @@ static ResultCode MapSharedMemory(Core::System& system, Handle shared_memory_han
"Addr does not fit within the heap region, addr=0x{:016X}, " "Addr does not fit within the heap region, addr=0x{:016X}, "
"size=0x{:016X}", "size=0x{:016X}",
addr, size); addr, size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
if (page_table.IsInsideAliasRegion(addr, size)) { if (page_table.IsInsideAliasRegion(addr, size)) {
@ -1257,14 +1258,14 @@ static ResultCode MapSharedMemory(Core::System& system, Handle shared_memory_han
"Address does not fit within the map region, addr=0x{:016X}, " "Address does not fit within the map region, addr=0x{:016X}, "
"size=0x{:016X}", "size=0x{:016X}",
addr, size); addr, size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
auto shared_memory{current_process->GetHandleTable().Get<SharedMemory>(shared_memory_handle)}; auto shared_memory{current_process->GetHandleTable().Get<SharedMemory>(shared_memory_handle)};
if (!shared_memory) { if (!shared_memory) {
LOG_ERROR(Kernel_SVC, "Shared memory does not exist, shared_memory_handle=0x{:08X}", LOG_ERROR(Kernel_SVC, "Shared memory does not exist, shared_memory_handle=0x{:08X}",
shared_memory_handle); shared_memory_handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
return shared_memory->Map(*current_process, addr, size, permission_type); return shared_memory->Map(*current_process, addr, size, permission_type);
@ -1285,7 +1286,7 @@ static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_add
if (!process) { if (!process) {
LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}", LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
process_handle); process_handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
auto& memory{system.Memory()}; auto& memory{system.Memory()};
@ -1332,18 +1333,18 @@ static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_hand
if (!Common::Is4KBAligned(src_address)) { if (!Common::Is4KBAligned(src_address)) {
LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).", LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).",
src_address); src_address);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (!Common::Is4KBAligned(dst_address)) { if (!Common::Is4KBAligned(dst_address)) {
LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).", LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).",
dst_address); dst_address);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (size == 0 || !Common::Is4KBAligned(size)) { if (size == 0 || !Common::Is4KBAligned(size)) {
LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X})", size); LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X})", size);
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (!IsValidAddressRange(dst_address, size)) { if (!IsValidAddressRange(dst_address, size)) {
@ -1351,7 +1352,7 @@ static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_hand
"Destination address range overflows the address space (dst_address=0x{:016X}, " "Destination address range overflows the address space (dst_address=0x{:016X}, "
"size=0x{:016X}).", "size=0x{:016X}).",
dst_address, size); dst_address, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (!IsValidAddressRange(src_address, size)) { if (!IsValidAddressRange(src_address, size)) {
@ -1359,7 +1360,7 @@ static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_hand
"Source address range overflows the address space (src_address=0x{:016X}, " "Source address range overflows the address space (src_address=0x{:016X}, "
"size=0x{:016X}).", "size=0x{:016X}).",
src_address, size); src_address, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable(); const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
@ -1367,7 +1368,7 @@ static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_hand
if (!process) { if (!process) {
LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).", LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).",
process_handle); process_handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
auto& page_table = process->PageTable(); auto& page_table = process->PageTable();
@ -1376,7 +1377,7 @@ static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_hand
"Source address range is not within the address space (src_address=0x{:016X}, " "Source address range is not within the address space (src_address=0x{:016X}, "
"size=0x{:016X}).", "size=0x{:016X}).",
src_address, size); src_address, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (!page_table.IsInsideASLRRegion(dst_address, size)) { if (!page_table.IsInsideASLRRegion(dst_address, size)) {
@ -1384,7 +1385,7 @@ static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_hand
"Destination address range is not within the ASLR region (dst_address=0x{:016X}, " "Destination address range is not within the ASLR region (dst_address=0x{:016X}, "
"size=0x{:016X}).", "size=0x{:016X}).",
dst_address, size); dst_address, size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
return page_table.MapProcessCodeMemory(dst_address, src_address, size); return page_table.MapProcessCodeMemory(dst_address, src_address, size);
@ -1400,18 +1401,18 @@ static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_ha
if (!Common::Is4KBAligned(dst_address)) { if (!Common::Is4KBAligned(dst_address)) {
LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).", LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).",
dst_address); dst_address);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (!Common::Is4KBAligned(src_address)) { if (!Common::Is4KBAligned(src_address)) {
LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).", LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).",
src_address); src_address);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (size == 0 || Common::Is4KBAligned(size)) { if (size == 0 || Common::Is4KBAligned(size)) {
LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X}).", size); LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X}).", size);
return ERR_INVALID_SIZE; return ResultInvalidSize;
} }
if (!IsValidAddressRange(dst_address, size)) { if (!IsValidAddressRange(dst_address, size)) {
@ -1419,7 +1420,7 @@ static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_ha
"Destination address range overflows the address space (dst_address=0x{:016X}, " "Destination address range overflows the address space (dst_address=0x{:016X}, "
"size=0x{:016X}).", "size=0x{:016X}).",
dst_address, size); dst_address, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (!IsValidAddressRange(src_address, size)) { if (!IsValidAddressRange(src_address, size)) {
@ -1427,7 +1428,7 @@ static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_ha
"Source address range overflows the address space (src_address=0x{:016X}, " "Source address range overflows the address space (src_address=0x{:016X}, "
"size=0x{:016X}).", "size=0x{:016X}).",
src_address, size); src_address, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable(); const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
@ -1435,7 +1436,7 @@ static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_ha
if (!process) { if (!process) {
LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).", LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).",
process_handle); process_handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
auto& page_table = process->PageTable(); auto& page_table = process->PageTable();
@ -1444,7 +1445,7 @@ static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_ha
"Source address range is not within the address space (src_address=0x{:016X}, " "Source address range is not within the address space (src_address=0x{:016X}, "
"size=0x{:016X}).", "size=0x{:016X}).",
src_address, size); src_address, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
if (!page_table.IsInsideASLRRegion(dst_address, size)) { if (!page_table.IsInsideASLRRegion(dst_address, size)) {
@ -1452,7 +1453,7 @@ static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_ha
"Destination address range is not within the ASLR region (dst_address=0x{:016X}, " "Destination address range is not within the ASLR region (dst_address=0x{:016X}, "
"size=0x{:016X}).", "size=0x{:016X}).",
dst_address, size); dst_address, size);
return ERR_INVALID_MEMORY_RANGE; return ResultInvalidMemoryRange;
} }
return page_table.UnmapProcessCodeMemory(dst_address, src_address, size); return page_table.UnmapProcessCodeMemory(dst_address, src_address, size);
@ -1844,7 +1845,7 @@ static ResultCode ResetSignal(Core::System& system, Handle handle) {
LOG_ERROR(Kernel_SVC, "invalid handle (0x{:08X})", handle); LOG_ERROR(Kernel_SVC, "invalid handle (0x{:08X})", handle);
return Svc::ResultInvalidHandle; return ResultInvalidHandle;
} }
static ResultCode ResetSignal32(Core::System& system, Handle handle) { static ResultCode ResetSignal32(Core::System& system, Handle handle) {
@ -1860,18 +1861,18 @@ static ResultCode CreateTransferMemory(Core::System& system, Handle* handle, VAd
if (!Common::Is4KBAligned(addr)) { if (!Common::Is4KBAligned(addr)) {
LOG_ERROR(Kernel_SVC, "Address ({:016X}) is not page aligned!", addr); LOG_ERROR(Kernel_SVC, "Address ({:016X}) is not page aligned!", addr);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (!Common::Is4KBAligned(size) || size == 0) { if (!Common::Is4KBAligned(size) || size == 0) {
LOG_ERROR(Kernel_SVC, "Size ({:016X}) is not page aligned or equal to zero!", size); LOG_ERROR(Kernel_SVC, "Size ({:016X}) is not page aligned or equal to zero!", size);
return ERR_INVALID_ADDRESS; return ResultInvalidAddress;
} }
if (!IsValidAddressRange(addr, size)) { if (!IsValidAddressRange(addr, size)) {
LOG_ERROR(Kernel_SVC, "Address and size cause overflow! (address={:016X}, size={:016X})", LOG_ERROR(Kernel_SVC, "Address and size cause overflow! (address={:016X}, size={:016X})",
addr, size); addr, size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
const auto perms{static_cast<Memory::MemoryPermission>(permissions)}; const auto perms{static_cast<Memory::MemoryPermission>(permissions)};
@ -1879,7 +1880,7 @@ static ResultCode CreateTransferMemory(Core::System& system, Handle* handle, VAd
perms == Memory::MemoryPermission::Write) { perms == Memory::MemoryPermission::Write) {
LOG_ERROR(Kernel_SVC, "Invalid memory permissions for transfer memory! (perms={:08X})", LOG_ERROR(Kernel_SVC, "Invalid memory permissions for transfer memory! (perms={:08X})",
permissions); permissions);
return ERR_INVALID_MEMORY_PERMISSIONS; return ResultInvalidMemoryPermissions;
} }
auto& kernel = system.Kernel(); auto& kernel = system.Kernel();
@ -1989,7 +1990,6 @@ static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle,
LOG_ERROR(Kernel_SVC, "Unable to successfully set core mask (result={})", set_result.raw); LOG_ERROR(Kernel_SVC, "Unable to successfully set core mask (result={})", set_result.raw);
return set_result; return set_result;
} }
return RESULT_SUCCESS; return RESULT_SUCCESS;
} }
@ -2043,7 +2043,7 @@ static ResultCode ClearEvent(Core::System& system, Handle event_handle) {
LOG_ERROR(Kernel_SVC, "Event handle does not exist, event_handle=0x{:08X}", event_handle); LOG_ERROR(Kernel_SVC, "Event handle does not exist, event_handle=0x{:08X}", event_handle);
return Svc::ResultInvalidHandle; return ResultInvalidHandle;
} }
static ResultCode ClearEvent32(Core::System& system, Handle event_handle) { static ResultCode ClearEvent32(Core::System& system, Handle event_handle) {
@ -2106,13 +2106,13 @@ static ResultCode GetProcessInfo(Core::System& system, u64* out, Handle process_
if (!process) { if (!process) {
LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}", LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
process_handle); process_handle);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
const auto info_type = static_cast<InfoType>(type); const auto info_type = static_cast<InfoType>(type);
if (info_type != InfoType::Status) { if (info_type != InfoType::Status) {
LOG_ERROR(Kernel_SVC, "Expected info_type to be Status but got {} instead", type); LOG_ERROR(Kernel_SVC, "Expected info_type to be Status but got {} instead", type);
return ERR_INVALID_ENUM_VALUE; return ResultInvalidEnumValue;
} }
*out = static_cast<u64>(process->GetStatus()); *out = static_cast<u64>(process->GetStatus());
@ -2174,7 +2174,7 @@ static ResultCode SetResourceLimitLimitValue(Core::System& system, Handle resour
const auto type = static_cast<LimitableResource>(resource_type); const auto type = static_cast<LimitableResource>(resource_type);
if (!IsValidResourceType(type)) { if (!IsValidResourceType(type)) {
LOG_ERROR(Kernel_SVC, "Invalid resource limit type: '{}'", resource_type); LOG_ERROR(Kernel_SVC, "Invalid resource limit type: '{}'", resource_type);
return ERR_INVALID_ENUM_VALUE; return ResultInvalidEnumValue;
} }
auto* const current_process = system.Kernel().CurrentProcess(); auto* const current_process = system.Kernel().CurrentProcess();
@ -2185,16 +2185,16 @@ static ResultCode SetResourceLimitLimitValue(Core::System& system, Handle resour
if (!resource_limit_object) { if (!resource_limit_object) {
LOG_ERROR(Kernel_SVC, "Handle to non-existent resource limit instance used. Handle={:08X}", LOG_ERROR(Kernel_SVC, "Handle to non-existent resource limit instance used. Handle={:08X}",
resource_limit); resource_limit);
return ERR_INVALID_HANDLE; return ResultInvalidHandle;
} }
const auto set_result = resource_limit_object->SetLimitValue(type, static_cast<s64>(value)); const auto set_result = resource_limit_object->SetLimitValue(type, static_cast<s64>(value));
if (set_result.IsError()) { if (set_result.IsError()) {
LOG_ERROR( LOG_ERROR(Kernel_SVC,
Kernel_SVC, "Attempted to lower resource limit ({}) for category '{}' below its current "
"Attempted to lower resource limit ({}) for category '{}' below its current value ({})", "value ({})",
resource_limit_object->GetLimitValue(type), resource_type, resource_limit_object->GetLimitValue(type), resource_type,
resource_limit_object->GetCurrentValue(type)); resource_limit_object->GetCurrentValue(type));
return set_result; return set_result;
} }
@ -2211,7 +2211,7 @@ static ResultCode GetProcessList(Core::System& system, u32* out_num_processes,
LOG_ERROR(Kernel_SVC, LOG_ERROR(Kernel_SVC,
"Supplied size outside [0, 0x0FFFFFFF] range. out_process_ids_size={}", "Supplied size outside [0, 0x0FFFFFFF] range. out_process_ids_size={}",
out_process_ids_size); out_process_ids_size);
return ERR_OUT_OF_RANGE; return ResultOutOfRange;
} }
const auto& kernel = system.Kernel(); const auto& kernel = system.Kernel();
@ -2221,7 +2221,7 @@ static ResultCode GetProcessList(Core::System& system, u32* out_num_processes,
out_process_ids, total_copy_size)) { out_process_ids, total_copy_size)) {
LOG_ERROR(Kernel_SVC, "Address range outside address space. begin=0x{:016X}, end=0x{:016X}", LOG_ERROR(Kernel_SVC, "Address range outside address space. begin=0x{:016X}, end=0x{:016X}",
out_process_ids, out_process_ids + total_copy_size); out_process_ids, out_process_ids + total_copy_size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
auto& memory = system.Memory(); auto& memory = system.Memory();
@ -2250,7 +2250,7 @@ static ResultCode GetThreadList(Core::System& system, u32* out_num_threads, VAdd
if ((out_thread_ids_size & 0xF0000000) != 0) { if ((out_thread_ids_size & 0xF0000000) != 0) {
LOG_ERROR(Kernel_SVC, "Supplied size outside [0, 0x0FFFFFFF] range. size={}", LOG_ERROR(Kernel_SVC, "Supplied size outside [0, 0x0FFFFFFF] range. size={}",
out_thread_ids_size); out_thread_ids_size);
return ERR_OUT_OF_RANGE; return ResultOutOfRange;
} }
const auto* const current_process = system.Kernel().CurrentProcess(); const auto* const current_process = system.Kernel().CurrentProcess();
@ -2260,7 +2260,7 @@ static ResultCode GetThreadList(Core::System& system, u32* out_num_threads, VAdd
!current_process->PageTable().IsInsideAddressSpace(out_thread_ids, total_copy_size)) { !current_process->PageTable().IsInsideAddressSpace(out_thread_ids, total_copy_size)) {
LOG_ERROR(Kernel_SVC, "Address range outside address space. begin=0x{:016X}, end=0x{:016X}", LOG_ERROR(Kernel_SVC, "Address range outside address space. begin=0x{:016X}, end=0x{:016X}",
out_thread_ids, out_thread_ids + total_copy_size); out_thread_ids, out_thread_ids + total_copy_size);
return ERR_INVALID_ADDRESS_STATE; return ResultInvalidCurrentMemory;
} }
auto& memory = system.Memory(); auto& memory = system.Memory();

21
src/core/hle/kernel/svc_results.h
View File

@ -1,4 +1,4 @@
// Copyright 2020 yuzu emulator team // Copyright 2018 yuzu emulator team
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
@ -6,21 +6,36 @@
#include "core/hle/result.h" #include "core/hle/result.h"
namespace Kernel::Svc { namespace Kernel {
// Confirmed Switch kernel error codes
constexpr ResultCode ResultMaxConnectionsReached{ErrorModule::Kernel, 7};
constexpr ResultCode ResultInvalidCapabilityDescriptor{ErrorModule::Kernel, 14};
constexpr ResultCode ResultNoSynchronizationObject{ErrorModule::Kernel, 57}; constexpr ResultCode ResultNoSynchronizationObject{ErrorModule::Kernel, 57};
constexpr ResultCode ResultTerminationRequested{ErrorModule::Kernel, 59}; constexpr ResultCode ResultTerminationRequested{ErrorModule::Kernel, 59};
constexpr ResultCode ResultInvalidSize{ErrorModule::Kernel, 101};
constexpr ResultCode ResultInvalidAddress{ErrorModule::Kernel, 102}; constexpr ResultCode ResultInvalidAddress{ErrorModule::Kernel, 102};
constexpr ResultCode ResultOutOfResource{ErrorModule::Kernel, 103}; constexpr ResultCode ResultOutOfResource{ErrorModule::Kernel, 103};
constexpr ResultCode ResultOutOfMemory{ErrorModule::Kernel, 104};
constexpr ResultCode ResultHandleTableFull{ErrorModule::Kernel, 105};
constexpr ResultCode ResultInvalidCurrentMemory{ErrorModule::Kernel, 106}; constexpr ResultCode ResultInvalidCurrentMemory{ErrorModule::Kernel, 106};
constexpr ResultCode ResultInvalidMemoryPermissions{ErrorModule::Kernel, 108};
constexpr ResultCode ResultInvalidMemoryRange{ErrorModule::Kernel, 110};
constexpr ResultCode ResultInvalidPriority{ErrorModule::Kernel, 112}; constexpr ResultCode ResultInvalidPriority{ErrorModule::Kernel, 112};
constexpr ResultCode ResultInvalidCoreId{ErrorModule::Kernel, 113}; constexpr ResultCode ResultInvalidCoreId{ErrorModule::Kernel, 113};
constexpr ResultCode ResultInvalidHandle{ErrorModule::Kernel, 114}; constexpr ResultCode ResultInvalidHandle{ErrorModule::Kernel, 114};
constexpr ResultCode ResultInvalidPointer{ErrorModule::Kernel, 115};
constexpr ResultCode ResultInvalidCombination{ErrorModule::Kernel, 116}; constexpr ResultCode ResultInvalidCombination{ErrorModule::Kernel, 116};
constexpr ResultCode ResultTimedOut{ErrorModule::Kernel, 117}; constexpr ResultCode ResultTimedOut{ErrorModule::Kernel, 117};
constexpr ResultCode ResultCancelled{ErrorModule::Kernel, 118}; constexpr ResultCode ResultCancelled{ErrorModule::Kernel, 118};
constexpr ResultCode ResultOutOfRange{ErrorModule::Kernel, 119};
constexpr ResultCode ResultInvalidEnumValue{ErrorModule::Kernel, 120}; constexpr ResultCode ResultInvalidEnumValue{ErrorModule::Kernel, 120};
constexpr ResultCode ResultNotFound{ErrorModule::Kernel, 121};
constexpr ResultCode ResultBusy{ErrorModule::Kernel, 122}; constexpr ResultCode ResultBusy{ErrorModule::Kernel, 122};
constexpr ResultCode ResultSessionClosedByRemote{ErrorModule::Kernel, 123};
constexpr ResultCode ResultInvalidState{ErrorModule::Kernel, 125}; constexpr ResultCode ResultInvalidState{ErrorModule::Kernel, 125};
constexpr ResultCode ResultReservedValue{ErrorModule::Kernel, 126};
constexpr ResultCode ResultResourceLimitedExceeded{ErrorModule::Kernel, 132};
} // namespace Kernel::Svc } // namespace Kernel

6
src/core/hle/service/ldr/ldr.cpp
View File

@ -11,10 +11,10 @@
#include "common/scope_exit.h" #include "common/scope_exit.h"
#include "core/core.h" #include "core/core.h"
#include "core/hle/ipc_helpers.h" #include "core/hle/ipc_helpers.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/memory/page_table.h" #include "core/hle/kernel/memory/page_table.h"
#include "core/hle/kernel/memory/system_control.h" #include "core/hle/kernel/memory/system_control.h"
#include "core/hle/kernel/process.h" #include "core/hle/kernel/process.h"
#include "core/hle/kernel/svc_results.h"
#include "core/hle/service/ldr/ldr.h" #include "core/hle/service/ldr/ldr.h"
#include "core/hle/service/service.h" #include "core/hle/service/service.h"
#include "core/loader/nro.h" #include "core/loader/nro.h"
@ -330,7 +330,7 @@ public:
const VAddr addr{GetRandomMapRegion(page_table, size)}; const VAddr addr{GetRandomMapRegion(page_table, size)};
const ResultCode result{page_table.MapProcessCodeMemory(addr, baseAddress, size)}; const ResultCode result{page_table.MapProcessCodeMemory(addr, baseAddress, size)};
if (result == Kernel::ERR_INVALID_ADDRESS_STATE) { if (result == Kernel::ResultInvalidCurrentMemory) {
continue; continue;
} }
@ -361,7 +361,7 @@ public:
const ResultCode result{ const ResultCode result{
page_table.MapProcessCodeMemory(addr + nro_size, bss_addr, bss_size)}; page_table.MapProcessCodeMemory(addr + nro_size, bss_addr, bss_size)};
if (result == Kernel::ERR_INVALID_ADDRESS_STATE) { if (result == Kernel::ResultInvalidCurrentMemory) {
continue; continue;
} }