Kernel: Centralize error definitions in errors.h

13 files changed, 133 insertions, 46 deletions

diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp
index 01fab123e..776d342f0 100644
--- a/src/core/hle/kernel/address_arbiter.cpp
+++ b/src/core/hle/kernel/address_arbiter.cpp
@@ -5,6 +5,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/hle/kernel/address_arbiter.h"
+#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/thread.h"
 #include "core/memory.h"
 
@@ -74,8 +75,7 @@ ResultCode AddressArbiter::ArbitrateAddress(ArbitrationType type, VAddr address,
 
     default:
         LOG_ERROR(Kernel, "unknown type=%d", type);
-        return ResultCode(ErrorDescription::InvalidEnumValue, ErrorModule::Kernel,
-                          ErrorSummary::WrongArgument, ErrorLevel::Usage);
+        return ERR_INVALID_ENUM_VALUE_FND;
     }
 
     // The calls that use a timeout seem to always return a Timeout error even if they did not put
@@ -83,8 +83,7 @@ ResultCode AddressArbiter::ArbitrateAddress(ArbitrationType type, VAddr address,
     if (type == ArbitrationType::WaitIfLessThanWithTimeout ||
         type == ArbitrationType::DecrementAndWaitIfLessThanWithTimeout) {
 
-        return ResultCode(ErrorDescription::Timeout, ErrorModule::OS, ErrorSummary::StatusChanged,
-                          ErrorLevel::Info);
+        return RESULT_TIMEOUT;
     }
     return RESULT_SUCCESS;
 }
diff --git a/src/core/hle/kernel/client_port.cpp b/src/core/hle/kernel/client_port.cpp
index ddcf4c916..03ffdece1 100644
--- a/src/core/hle/kernel/client_port.cpp
+++ b/src/core/hle/kernel/client_port.cpp
@@ -5,6 +5,7 @@
 #include "common/assert.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_port.h"
 #include "core/hle/kernel/server_session.h"
@@ -19,8 +20,7 @@ ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     // AcceptSession before returning from this call.
 
     if (active_sessions >= max_sessions) {
-        return ResultCode(ErrorDescription::MaxConnectionsReached, ErrorModule::OS,
-                          ErrorSummary::WouldBlock, ErrorLevel::Temporary);
+        return ERR_MAX_CONNECTIONS_REACHED;
     }
     active_sessions++;
 
diff --git a/src/core/hle/kernel/client_session.cpp b/src/core/hle/kernel/client_session.cpp
index e297b7464..783b1c061 100644
--- a/src/core/hle/kernel/client_session.cpp
+++ b/src/core/hle/kernel/client_session.cpp
@@ -30,8 +30,7 @@ ResultCode ClientSession::SendSyncRequest() {
     if (parent->server)
         return parent->server->HandleSyncRequest();
 
-    return ResultCode(ErrorDescription::SessionClosedByRemote, ErrorModule::OS,
-                      ErrorSummary::Canceled, ErrorLevel::Status);
+    return ERR_SESSION_CLOSED_BY_REMOTE;
 }
 
 } // namespace
diff --git a/src/core/hle/kernel/errors.h b/src/core/hle/kernel/errors.h
new file mode 100644
index 000000000..b3b60e7df
--- /dev/null
+++ b/src/core/hle/kernel/errors.h
@@ -0,0 +1,98 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/result.h"
+
+namespace Kernel {
+
+namespace ErrCodes {
+enum {
+    OutOfHandles = 19,
+    SessionClosedByRemote = 26,
+    PortNameTooLong = 30,
+    WrongPermission = 46,
+    InvalidBufferDescriptor = 48,
+    MaxConnectionsReached = 52,
+};
+}
+
+// WARNING: The kernel is quite inconsistent in it's usage of errors code. Make sure to always
+// double check that the code matches before re-using the constant.
+
+constexpr ResultCode ERR_OUT_OF_HANDLES(ErrCodes::OutOfHandles, ErrorModule::Kernel,
+                                        ErrorSummary::OutOfResource,
+                                        ErrorLevel::Permanent); // 0xD8600413
+constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE(ErrCodes::SessionClosedByRemote, ErrorModule::OS,
+                                                  ErrorSummary::Canceled,
+                                                  ErrorLevel::Status); // 0xC920181A
+constexpr ResultCode ERR_PORT_NAME_TOO_LONG(ErrCodes::PortNameTooLong, ErrorModule::OS,
+                                            ErrorSummary::InvalidArgument,
+                                            ErrorLevel::Usage); // 0xE0E0181E
+constexpr ResultCode ERR_WRONG_PERMISSION(ErrCodes::WrongPermission, ErrorModule::OS,
+                                          ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+constexpr ResultCode ERR_INVALID_BUFFER_DESCRIPTOR(ErrCodes::InvalidBufferDescriptor,
+                                                   ErrorModule::OS, ErrorSummary::WrongArgument,
+                                                   ErrorLevel::Permanent);
+constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED(ErrCodes::MaxConnectionsReached, ErrorModule::OS,
+                                                 ErrorSummary::WouldBlock,
+                                                 ErrorLevel::Temporary); // 0xD0401834
+
+constexpr ResultCode ERR_NOT_AUTHORIZED(ErrorDescription::NotAuthorized, ErrorModule::OS,
+                                        ErrorSummary::WrongArgument,
+                                        ErrorLevel::Permanent); // 0xD9001BEA
+constexpr ResultCode ERR_INVALID_ENUM_VALUE(ErrorDescription::InvalidEnumValue, ErrorModule::Kernel,
+                                            ErrorSummary::InvalidArgument,
+                                            ErrorLevel::Permanent); // 0xD8E007ED
+constexpr ResultCode ERR_INVALID_ENUM_VALUE_FND(ErrorDescription::InvalidEnumValue,
+                                                ErrorModule::FND, ErrorSummary::InvalidArgument,
+                                                ErrorLevel::Permanent); // 0xD8E093ED
+constexpr ResultCode ERR_INVALID_COMBINATION(ErrorDescription::InvalidCombination, ErrorModule::OS,
+                                             ErrorSummary::InvalidArgument,
+                                             ErrorLevel::Usage); // 0xE0E01BEE
+constexpr ResultCode ERR_INVALID_COMBINATION_KERNEL(ErrorDescription::InvalidCombination,
+                                                    ErrorModule::Kernel,
+                                                    ErrorSummary::WrongArgument,
+                                                    ErrorLevel::Permanent); // 0xD90007EE
+constexpr ResultCode ERR_MISALIGNED_ADDRESS(ErrorDescription::MisalignedAddress, ErrorModule::OS,
+                                            ErrorSummary::InvalidArgument,
+                                            ErrorLevel::Usage); // 0xE0E01BF1
+constexpr ResultCode ERR_MISALIGNED_SIZE(ErrorDescription::MisalignedSize, ErrorModule::OS,
+                                         ErrorSummary::InvalidArgument,
+                                         ErrorLevel::Usage); // 0xE0E01BF2
+constexpr ResultCode ERR_OUT_OF_MEMORY(ErrorDescription::OutOfMemory, ErrorModule::Kernel,
+                                       ErrorSummary::OutOfResource,
+                                       ErrorLevel::Permanent); // 0xD86007F3
+constexpr ResultCode ERR_NOT_IMPLEMENTED(ErrorDescription::NotImplemented, ErrorModule::OS,
+                                         ErrorSummary::InvalidArgument,
+                                         ErrorLevel::Usage); // 0xE0E01BF4
+constexpr ResultCode ERR_INVALID_ADDRESS(ErrorDescription::InvalidAddress, ErrorModule::OS,
+                                         ErrorSummary::InvalidArgument,
+                                         ErrorLevel::Usage); // 0xE0E01BF5
+constexpr ResultCode ERR_INVALID_ADDRESS_STATE(ErrorDescription::InvalidAddress, ErrorModule::OS,
+                                               ErrorSummary::InvalidState,
+                                               ErrorLevel::Usage); // 0xE0A01BF5
+constexpr ResultCode ERR_INVALID_POINTER(ErrorDescription::InvalidPointer, ErrorModule::Kernel,
+                                         ErrorSummary::InvalidArgument,
+                                         ErrorLevel::Permanent); // 0xD8E007F6
+constexpr ResultCode ERR_INVALID_HANDLE(ErrorDescription::InvalidHandle, ErrorModule::Kernel,
+                                        ErrorSummary::InvalidArgument,
+                                        ErrorLevel::Permanent); // 0xD8E007F7
+/// Alternate code returned instead of ERR_INVALID_HANDLE in some code paths.
+constexpr ResultCode ERR_INVALID_HANDLE_OS(ErrorDescription::InvalidHandle, ErrorModule::OS,
+                                           ErrorSummary::WrongArgument,
+                                           ErrorLevel::Permanent); // 0xD9001BF7
+constexpr ResultCode ERR_NOT_FOUND(ErrorDescription::NotFound, ErrorModule::Kernel,
+                                   ErrorSummary::NotFound, ErrorLevel::Permanent); // 0xD88007FA
+constexpr ResultCode ERR_OUT_OF_RANGE(ErrorDescription::OutOfRange, ErrorModule::OS,
+                                      ErrorSummary::InvalidArgument,
+                                      ErrorLevel::Usage); // 0xE0E01BFD
+constexpr ResultCode ERR_OUT_OF_RANGE_KERNEL(ErrorDescription::OutOfRange, ErrorModule::Kernel,
+                                             ErrorSummary::InvalidArgument,
+                                             ErrorLevel::Permanent); // 0xD8E007FD
+constexpr ResultCode RESULT_TIMEOUT(ErrorDescription::Timeout, ErrorModule::OS,
+                                    ErrorSummary::StatusChanged, ErrorLevel::Info);
+
+} // namespace Kernel
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index f599916f0..7f84e01aa 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/hle/config_mem.h"
+#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/process.h"
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index bb8b99bb5..94f2025a0 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -19,13 +19,6 @@ using Handle = u32;
 
 class Thread;
 
-// TODO: Verify code
-const ResultCode ERR_OUT_OF_HANDLES(ErrorDescription::OutOfMemory, ErrorModule::Kernel,
-                                    ErrorSummary::OutOfResource, ErrorLevel::Temporary);
-// TOOD: Verify code
-const ResultCode ERR_INVALID_HANDLE(ErrorDescription::InvalidHandle, ErrorModule::Kernel,
-                                    ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
-
 enum KernelHandle : Handle {
     CurrentThread = 0xFFFF8000,
     CurrentProcess = 0xFFFF8001,
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index 32cb25fb7..1c31ec950 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
+#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
diff --git a/src/core/hle/kernel/semaphore.cpp b/src/core/hle/kernel/semaphore.cpp
index 8bda2f75d..fcf586728 100644
--- a/src/core/hle/kernel/semaphore.cpp
+++ b/src/core/hle/kernel/semaphore.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "common/assert.h"
+#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/semaphore.h"
 #include "core/hle/kernel/thread.h"
@@ -16,8 +17,7 @@ ResultVal<SharedPtr<Semaphore>> Semaphore::Create(s32 initial_count, s32 max_cou
                                                   std::string name) {
 
     if (initial_count > max_count)
-        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::Kernel,
-                          ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+        return ERR_INVALID_COMBINATION_KERNEL;
 
     SharedPtr<Semaphore> semaphore(new Semaphore);
 
@@ -42,8 +42,7 @@ void Semaphore::Acquire(Thread* thread) {
 
 ResultVal<s32> Semaphore::Release(s32 release_count) {
     if (max_count - available_count < release_count)
-        return ResultCode(ErrorDescription::OutOfRange, ErrorModule::Kernel,
-                          ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
+        return ERR_OUT_OF_RANGE_KERNEL;
 
     s32 previous_count = available_count;
     available_count += release_count;
diff --git a/src/core/hle/kernel/shared_memory.cpp b/src/core/hle/kernel/shared_memory.cpp
index bc1560d12..922e5ab58 100644
--- a/src/core/hle/kernel/shared_memory.cpp
+++ b/src/core/hle/kernel/shared_memory.cpp
@@ -4,6 +4,7 @@
 
 #include <cstring>
 #include "common/logging/log.h"
+#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/memory.h"
@@ -102,24 +103,21 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
 
     // Automatically allocated memory blocks can only be mapped with other_permissions = DontCare
     if (base_address == 0 && other_permissions != MemoryPermission::DontCare) {
-        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
-                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ERR_INVALID_COMBINATION;
     }
 
     // Error out if the requested permissions don't match what the creator process allows.
     if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
         LOG_ERROR(Kernel, "cannot map id=%u, address=0x%08X name=%s, permissions don't match",
                   GetObjectId(), address, name.c_str());
-        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
-                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ERR_INVALID_COMBINATION;
     }
 
     // Heap-backed memory blocks can not be mapped with other_permissions = DontCare
     if (base_address != 0 && other_permissions == MemoryPermission::DontCare) {
         LOG_ERROR(Kernel, "cannot map id=%u, address=0x%08X name=%s, permissions don't match",
                   GetObjectId(), address, name.c_str());
-        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
-                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ERR_INVALID_COMBINATION;
     }
 
     // Error out if the provided permissions are not compatible with what the creator process needs.
@@ -127,8 +125,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
         static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
         LOG_ERROR(Kernel, "cannot map id=%u, address=0x%08X name=%s, permissions don't match",
                   GetObjectId(), address, name.c_str());
-        return ResultCode(ErrorDescription::WrongPermission, ErrorModule::OS,
-                          ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+        return ERR_WRONG_PERMISSION;
     }
 
     // TODO(Subv): Check for the Shared Device Mem flag in the creator process.
@@ -144,8 +141,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
         if (address < Memory::HEAP_VADDR || address + size >= Memory::SHARED_MEMORY_VADDR_END) {
             LOG_ERROR(Kernel, "cannot map id=%u, address=0x%08X name=%s, invalid address",
                       GetObjectId(), address, name.c_str());
-            return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::OS,
-                              ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+            return ERR_INVALID_ADDRESS;
         }
     }
 
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index 3b7555d87..519ff51a8 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -14,6 +14,7 @@
 #include "core/arm/skyeye_common/armstate.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/mutex.h"
@@ -241,9 +242,7 @@ static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
         for (auto& object : thread->wait_objects)
             object->RemoveWaitingThread(thread.get());
         thread->wait_objects.clear();
-        thread->SetWaitSynchronizationResult(ResultCode(ErrorDescription::Timeout, ErrorModule::OS,
-                                                        ErrorSummary::StatusChanged,
-                                                        ErrorLevel::Info));
+        thread->SetWaitSynchronizationResult(RESULT_TIMEOUT);
     }
 
     thread->ResumeFromWait();
@@ -351,10 +350,20 @@ static void ResetThreadContext(ARM_Interface::ThreadContext& context, u32 stack_
     context.cpsr = USER32MODE | ((entry_point & 1) << 5); // Usermode and THUMB mode
 }
 
-ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point, s32 priority,
+ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point, u32 priority,
                                             u32 arg, s32 processor_id, VAddr stack_top) {
-    ASSERT_MSG(priority >= THREADPRIO_HIGHEST && priority <= THREADPRIO_LOWEST,
-               "Invalid thread priority");
+    // Check if priority is in ranged. Lowest priority -> highest priority id.
+    if (priority > THREADPRIO_LOWEST) {
+        LOG_ERROR(Kernel_SVC, "Invalid thread priority: %d", priority);
+        return ERR_OUT_OF_RANGE;
+    }
+
+    if (processor_id > THREADPROCESSORID_MAX) {
+        LOG_ERROR(Kernel_SVC, "Invalid processor id: %d", processor_id);
+        return ERR_OUT_OF_RANGE_KERNEL;
+    }
+
+    // TODO(yuriks): Other checks, returning 0xD9001BEA
 
     if (!Memory::IsValidVirtualAddress(entry_point)) {
         LOG_ERROR(Kernel_SVC, "(name=%s): invalid entry %08x", name.c_str(), entry_point);
@@ -399,8 +408,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
         if (linheap_memory->size() + Memory::PAGE_SIZE > memory_region->size) {
             LOG_ERROR(Kernel_SVC,
                       "Not enough space in region to allocate a new TLS page for thread");
-            return ResultCode(ErrorDescription::OutOfMemory, ErrorModule::Kernel,
-                              ErrorSummary::OutOfResource, ErrorLevel::Permanent);
+            return ERR_OUT_OF_MEMORY;
         }
 
         u32 offset = linheap_memory->size();
diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h
index 6ab31c70b..7b5169cfc 100644
--- a/src/core/hle/kernel/thread.h
+++ b/src/core/hle/kernel/thread.h
@@ -57,7 +57,7 @@ public:
      * @param stack_top The address of the thread's stack top
      * @return A shared pointer to the newly created thread
      */
-    static ResultVal<SharedPtr<Thread>> Create(std::string name, VAddr entry_point, s32 priority,
+    static ResultVal<SharedPtr<Thread>> Create(std::string name, VAddr entry_point, u32 priority,
                                                u32 arg, s32 processor_id, VAddr stack_top);
 
     std::string GetName() const override {
diff --git a/src/core/hle/kernel/vm_manager.cpp b/src/core/hle/kernel/vm_manager.cpp
index 6dd24f846..cef1f7fa8 100644
--- a/src/core/hle/kernel/vm_manager.cpp
+++ b/src/core/hle/kernel/vm_manager.cpp
@@ -4,6 +4,7 @@
 
 #include <iterator>
 #include "common/assert.h"
+#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
diff --git a/src/core/hle/kernel/vm_manager.h b/src/core/hle/kernel/vm_manager.h
index 9055664b2..38e0d74d0 100644
--- a/src/core/hle/kernel/vm_manager.h
+++ b/src/core/hle/kernel/vm_manager.h
@@ -13,14 +13,6 @@
 
 namespace Kernel {
 
-const ResultCode ERR_INVALID_ADDRESS{// 0xE0E01BF5
-                                     ErrorDescription::InvalidAddress, ErrorModule::OS,
-                                     ErrorSummary::InvalidArgument, ErrorLevel::Usage};
-
-const ResultCode ERR_INVALID_ADDRESS_STATE{// 0xE0A01BF5
-                                           ErrorDescription::InvalidAddress, ErrorModule::OS,
-                                           ErrorSummary::InvalidState, ErrorLevel::Usage};
-
 enum class VMAType : u8 {
     /// VMA represents an unmapped region of the address space.
     Free,