hle: Move SVC code to kernel namespace.

1 files changed, 612 insertions, 0 deletions

diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
new file mode 100644
index 000000000..3dae8b38b
--- /dev/null
+++ b/src/core/hle/kernel/svc.cpp
@@ -0,0 +1,612 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "common/microprofile.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/client_port.h"
+#include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/handle_table.h"
+#include "core/hle/kernel/mutex.h"
+#include "core/hle/kernel/object_address_table.h"
+#include "core/hle/kernel/process.h"
+#include "core/hle/kernel/resource_limit.h"
+#include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_wrap.h"
+#include "core/hle/kernel/sync_object.h"
+#include "core/hle/kernel/thread.h"
+#include "core/hle/lock.h"
+#include "core/hle/result.h"
+#include "core/hle/service/service.h"
+
+namespace Kernel {
+
+/// Set the process heap to a given Size. It can both extend and shrink the heap.
+static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
+    LOG_TRACE(Kernel_SVC, "called, heap_size=0x%llx", heap_size);
+    auto& process = *g_current_process;
+    CASCADE_RESULT(*heap_addr, process.HeapAllocate(Memory::HEAP_VADDR, heap_size,
+                                                    VMAPermission::ReadWrite));
+    return RESULT_SUCCESS;
+}
+
+/// Maps a memory range into a different range.
+static ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
+    LOG_TRACE(Kernel_SVC, "called, dst_addr=0x%llx, src_addr=0x%llx, size=0x%llx", dst_addr,
+              src_addr, size);
+    return g_current_process->MirrorMemory(dst_addr, src_addr, size);
+}
+
+/// Unmaps a region that was previously mapped with svcMapMemory
+static ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
+    LOG_TRACE(Kernel_SVC, "called, dst_addr=0x%llx, src_addr=0x%llx, size=0x%llx", dst_addr,
+              src_addr, size);
+    return g_current_process->UnmapMemory(dst_addr, src_addr, size);
+}
+
+/// Connect to an OS service given the port name, returns the handle to the port to out
+static ResultCode ConnectToPort(Handle* out_handle, VAddr port_name_address) {
+    if (!Memory::IsValidVirtualAddress(port_name_address))
+        return ERR_NOT_FOUND;
+
+    static constexpr std::size_t PortNameMaxLength = 11;
+    // Read 1 char beyond the max allowed port name to detect names that are too long.
+    std::string port_name = Memory::ReadCString(port_name_address, PortNameMaxLength + 1);
+    if (port_name.size() > PortNameMaxLength)
+        return ERR_PORT_NAME_TOO_LONG;
+
+    LOG_TRACE(Kernel_SVC, "called port_name=%s", port_name.c_str());
+
+    auto it = Service::g_kernel_named_ports.find(port_name);
+    if (it == Service::g_kernel_named_ports.end()) {
+        LOG_WARNING(Kernel_SVC, "tried to connect to unknown port: %s", port_name.c_str());
+        return ERR_NOT_FOUND;
+    }
+
+    auto client_port = it->second;
+
+    SharedPtr<ClientSession> client_session;
+    CASCADE_RESULT(client_session, client_port->Connect());
+
+    // Return the client session
+    CASCADE_RESULT(*out_handle, g_handle_table.Create(client_session));
+    return RESULT_SUCCESS;
+}
+
+/// Makes a blocking IPC call to an OS service.
+static ResultCode SendSyncRequest(Handle handle) {
+    SharedPtr<SyncObject> session = g_handle_table.Get<SyncObject>(handle);
+    if (!session) {
+        LOG_ERROR(Kernel_SVC, "called with invalid handle=0x%08X", handle);
+        return ERR_INVALID_HANDLE;
+    }
+
+    LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s)", handle, session->GetName().c_str());
+
+    Core::System::GetInstance().PrepareReschedule();
+
+    // TODO(Subv): svcSendSyncRequest should put the caller thread to sleep while the server
+    // responds and cause a reschedule.
+    return session->SendSyncRequest(GetCurrentThread());
+}
+
+/// Get the ID for the specified thread.
+static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
+    LOG_TRACE(Kernel_SVC, "called thread=0x%08X", thread_handle);
+
+    const SharedPtr<Thread> thread =
+        g_handle_table.Get<Thread>(thread_handle);
+    if (!thread) {
+        return ERR_INVALID_HANDLE;
+    }
+
+    *thread_id = thread->GetThreadId();
+    return RESULT_SUCCESS;
+}
+
+/// Get the ID of the specified process
+static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
+    LOG_TRACE(Kernel_SVC, "called process=0x%08X", process_handle);
+
+    const SharedPtr<Process> process =
+        g_handle_table.Get<Process>(process_handle);
+    if (!process) {
+        return ERR_INVALID_HANDLE;
+    }
+
+    *process_id = process->process_id;
+    return RESULT_SUCCESS;
+}
+
+/// Wait for the given handles to synchronize, timeout after the specified nanoseconds
+static ResultCode WaitSynchronization(VAddr handles_address, u64 handle_count, s64 nano_seconds) {
+    LOG_WARNING(Kernel_SVC,
+                "(STUBBED) called handles_address=0x%llx, handle_count=%d, nano_seconds=%d",
+                handles_address, handle_count, nano_seconds);
+    return RESULT_SUCCESS;
+}
+
+/// Attempts to locks a mutex, creating it if it does not already exist
+static ResultCode LockMutex(Handle holding_thread_handle, VAddr mutex_addr,
+                            Handle requesting_thread_handle) {
+    LOG_TRACE(Kernel_SVC,
+              "called holding_thread_handle=0x%08X, mutex_addr=0x%llx, "
+              "requesting_current_thread_handle=0x%08X",
+              holding_thread_handle, mutex_addr, requesting_thread_handle);
+
+    SharedPtr<Thread> holding_thread =
+        g_handle_table.Get<Thread>(holding_thread_handle);
+    SharedPtr<Thread> requesting_thread =
+        g_handle_table.Get<Thread>(requesting_thread_handle);
+
+    ASSERT(holding_thread);
+    ASSERT(requesting_thread);
+
+    SharedPtr<Mutex> mutex = g_object_address_table.Get<Mutex>(mutex_addr);
+    if (!mutex) {
+        // Create a new mutex for the specified address if one does not already exist
+        mutex = Mutex::Create(holding_thread, mutex_addr);
+        mutex->name = Common::StringFromFormat("mutex-%llx", mutex_addr);
+    }
+
+    if (mutex->ShouldWait(requesting_thread.get())) {
+        // If we cannot lock the mutex, then put the thread too sleep and trigger a reschedule
+        requesting_thread->wait_objects = {mutex};
+        mutex->AddWaitingThread(requesting_thread);
+        requesting_thread->status = THREADSTATUS_WAIT_SYNCH_ANY;
+
+        Core::System::GetInstance().PrepareReschedule();
+    } else {
+        // The mutex is available, lock it
+        mutex->Acquire(requesting_thread.get());
+    }
+
+    return RESULT_SUCCESS;
+}
+
+/// Unlock a mutex
+static ResultCode UnlockMutex(VAddr mutex_addr) {
+    LOG_TRACE(Kernel_SVC, "called mutex_addr=0x%llx", mutex_addr);
+
+    SharedPtr<Mutex> mutex = g_object_address_table.Get<Mutex>(mutex_addr);
+    ASSERT(mutex);
+
+    return mutex->Release(GetCurrentThread());
+}
+
+/// Break program execution
+static void Break(u64 unk_0, u64 unk_1, u64 unk_2) {
+    LOG_CRITICAL(Debug_Emulated, "Emulated program broke execution!");
+    ASSERT(false);
+}
+
+/// Used to output a message on a debug hardware unit - does nothing on a retail unit
+static void OutputDebugString(VAddr address, s32 len) {
+    std::vector<char> string(len);
+    Memory::ReadBlock(address, string.data(), len);
+    LOG_DEBUG(Debug_Emulated, "%.*s", len, string.data());
+}
+
+/// Gets system/memory information for the current process
+static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id) {
+    LOG_TRACE(Kernel_SVC, "called info_id=0x%X, info_sub_id=0x%X, handle=0x%08X", info_id,
+              info_sub_id, handle);
+
+    auto& vm_manager = g_current_process->vm_manager;
+    switch (static_cast<GetInfoType>(info_id)) {
+    case GetInfoType::TotalMemoryUsage:
+        *result = vm_manager.GetTotalMemoryUsage();
+        break;
+    case GetInfoType::TotalHeapUsage:
+        *result = vm_manager.GetTotalHeapUsage();
+        break;
+    case GetInfoType::RandomEntropy:
+        *result = 0;
+        break;
+    case GetInfoType::AddressSpaceBaseAddr:
+        *result = vm_manager.GetAddressSpaceBaseAddr();
+        break;
+    case GetInfoType::AddressSpaceSize:
+        *result = vm_manager.GetAddressSpaceSize();
+        break;
+    case GetInfoType::NewMapRegionBaseAddr:
+        *result = vm_manager.GetNewMapRegionBaseAddr();
+        break;
+    case GetInfoType::NewMapRegionSize:
+        *result = vm_manager.GetNewMapRegionSize();
+        break;
+    default:
+        UNIMPLEMENTED();
+    }
+
+    return RESULT_SUCCESS;
+}
+
+/// Gets the priority for the specified thread
+static ResultCode GetThreadPriority(u32* priority, Handle handle) {
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(handle);
+    if (!thread)
+        return ERR_INVALID_HANDLE;
+
+    *priority = thread->GetPriority();
+    return RESULT_SUCCESS;
+}
+
+/// Sets the priority for the specified thread
+static ResultCode SetThreadPriority(Handle handle, u32 priority) {
+    if (priority > THREADPRIO_LOWEST) {
+        return ERR_OUT_OF_RANGE;
+    }
+
+    SharedPtr<Thread> thread = g_handle_table.Get<Thread>(handle);
+    if (!thread)
+        return ERR_INVALID_HANDLE;
+
+    // Note: The kernel uses the current process's resource limit instead of
+    // the one from the thread owner's resource limit.
+    SharedPtr<ResourceLimit>& resource_limit = g_current_process->resource_limit;
+    if (resource_limit->GetMaxResourceValue(ResourceTypes::PRIORITY) > priority) {
+        return ERR_NOT_AUTHORIZED;
+    }
+
+    thread->SetPriority(priority);
+    thread->UpdatePriority();
+
+    // Update the mutexes that this thread is waiting for
+    for (auto& mutex : thread->pending_mutexes)
+        mutex->UpdatePriority();
+
+    Core::System::GetInstance().PrepareReschedule();
+    return RESULT_SUCCESS;
+}
+
+/// Get which CPU core is executing the current thread
+static u32 GetCurrentProcessorNumber() {
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called, defaulting to processor 0");
+    return 0;
+}
+
+/// Query process memory
+static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
+                                     Handle process_handle, u64 addr) {
+    SharedPtr<Process> process = g_handle_table.Get<Process>(process_handle);
+    if (!process) {
+        return ERR_INVALID_HANDLE;
+    }
+    auto vma = process->vm_manager.FindVMA(addr);
+    memory_info->attributes = 0;
+    if (vma == g_current_process->vm_manager.vma_map.end()) {
+        memory_info->base_address = 0;
+        memory_info->permission = static_cast<u32>(VMAPermission::None);
+        memory_info->size = 0;
+        memory_info->type = static_cast<u32>(MemoryState::Free);
+    } else {
+        memory_info->base_address = vma->second.base;
+        memory_info->permission = static_cast<u32>(vma->second.permissions);
+        memory_info->size = vma->second.size;
+        memory_info->type = static_cast<u32>(vma->second.meminfo_state);
+    }
+
+    LOG_TRACE(Kernel_SVC, "called process=0x%08X addr=%llx", process_handle, addr);
+    return RESULT_SUCCESS;
+}
+
+/// Query memory
+static ResultCode QueryMemory(MemoryInfo* memory_info, PageInfo* page_info, VAddr addr) {
+    LOG_TRACE(Kernel_SVC, "called, addr=%llx", addr);
+    return QueryProcessMemory(memory_info, page_info, CurrentProcess, addr);
+}
+
+/// Exits the current process
+static void ExitProcess() {
+    LOG_INFO(Kernel_SVC, "Process %u exiting", g_current_process->process_id);
+
+    ASSERT_MSG(g_current_process->status == ProcessStatus::Running,
+               "Process has already exited");
+
+    g_current_process->status = ProcessStatus::Exited;
+
+    // Stop all the process threads that are currently waiting for objects.
+    auto& thread_list = GetThreadList();
+    for (auto& thread : thread_list) {
+        if (thread->owner_process != g_current_process)
+            continue;
+
+        if (thread == GetCurrentThread())
+            continue;
+
+        // TODO(Subv): When are the other running/ready threads terminated?
+        ASSERT_MSG(thread->status == THREADSTATUS_WAIT_SYNCH_ANY ||
+                       thread->status == THREADSTATUS_WAIT_SYNCH_ALL,
+                   "Exiting processes with non-waiting threads is currently unimplemented");
+
+        thread->Stop();
+    }
+
+    // Kill the current thread
+    GetCurrentThread()->Stop();
+
+    Core::System::GetInstance().PrepareReschedule();
+}
+
+/// Creates a new thread
+static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, VAddr stack_top,
+                               u32 priority, s32 processor_id) {
+    std::string name = Common::StringFromFormat("unknown-%llx", entry_point);
+
+    if (priority > THREADPRIO_LOWEST) {
+        return ERR_OUT_OF_RANGE;
+    }
+
+    SharedPtr<ResourceLimit>& resource_limit = g_current_process->resource_limit;
+    if (resource_limit->GetMaxResourceValue(ResourceTypes::PRIORITY) > priority) {
+        return ERR_NOT_AUTHORIZED;
+    }
+
+    if (processor_id == THREADPROCESSORID_DEFAULT) {
+        // Set the target CPU to the one specified in the process' exheader.
+        processor_id = g_current_process->ideal_processor;
+        ASSERT(processor_id != THREADPROCESSORID_DEFAULT);
+    }
+
+    switch (processor_id) {
+    case THREADPROCESSORID_0:
+        break;
+    case THREADPROCESSORID_ALL:
+        LOG_INFO(Kernel_SVC,
+                 "Newly created thread is allowed to be run in any Core, unimplemented.");
+        break;
+    case THREADPROCESSORID_1:
+        LOG_ERROR(Kernel_SVC,
+                  "Newly created thread must run in the SysCore (Core1), unimplemented.");
+        break;
+    default:
+        // TODO(bunnei): Implement support for other processor IDs
+        ASSERT_MSG(false, "Unsupported thread processor ID: %d", processor_id);
+        break;
+    }
+
+    CASCADE_RESULT(SharedPtr<Thread> thread,
+                   Thread::Create(name, entry_point, priority, arg, processor_id, stack_top,
+                                          g_current_process));
+
+    thread->context.fpscr =
+        FPSCR_DEFAULT_NAN | FPSCR_FLUSH_TO_ZERO | FPSCR_ROUND_TOZERO; // 0x03C00000
+
+    CASCADE_RESULT(thread->guest_handle, g_handle_table.Create(thread));
+    *out_handle = thread->guest_handle;
+
+    Core::System::GetInstance().PrepareReschedule();
+
+    LOG_TRACE(Kernel_SVC,
+              "called entrypoint=0x%08X (%s), arg=0x%08X, stacktop=0x%08X, "
+              "threadpriority=0x%08X, processorid=0x%08X : created handle=0x%08X",
+              entry_point, name.c_str(), arg, stack_top, priority, processor_id, *out_handle);
+
+    return RESULT_SUCCESS;
+}
+
+/// Starts the thread for the provided handle
+static ResultCode StartThread(Handle thread_handle) {
+    LOG_TRACE(Kernel_SVC, "called thread=0x%08X", thread_handle);
+
+    const SharedPtr<Thread> thread =
+        g_handle_table.Get<Thread>(thread_handle);
+    if (!thread) {
+        return ERR_INVALID_HANDLE;
+    }
+
+    thread->ResumeFromWait();
+
+    return RESULT_SUCCESS;
+}
+
+/// Called when a thread exits
+static void ExitThread() {
+    LOG_TRACE(Kernel_SVC, "called, pc=0x%08X", Core::CPU().GetPC());
+
+    ExitCurrentThread();
+    Core::System::GetInstance().PrepareReschedule();
+}
+
+/// Sleep the current thread
+static void SleepThread(s64 nanoseconds) {
+    LOG_TRACE(Kernel_SVC, "called nanoseconds=%lld", nanoseconds);
+
+    // Don't attempt to yield execution if there are no available threads to run,
+    // this way we avoid a useless reschedule to the idle thread.
+    if (nanoseconds == 0 && !HaveReadyThreads())
+        return;
+
+    // Sleep current thread and check for next thread to schedule
+    WaitCurrentThread_Sleep();
+
+    // Create an event to wake the thread up after the specified nanosecond delay has passed
+    GetCurrentThread()->WakeAfterDelay(nanoseconds);
+
+    Core::System::GetInstance().PrepareReschedule();
+}
+
+/// Signal process wide key
+static ResultCode SignalProcessWideKey(VAddr addr, u32 target) {
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called, address=0x%llx, target=0x%08x", addr, target);
+    return RESULT_SUCCESS;
+}
+
+/// Close a handle
+static ResultCode CloseHandle(Handle handle) {
+    LOG_TRACE(Kernel_SVC, "Closing handle 0x%08X", handle);
+    return g_handle_table.Close(handle);
+}
+
+namespace {
+struct FunctionDef {
+    using Func = void();
+
+    u32 id;
+    Func* func;
+    const char* name;
+};
+} // namespace
+
+static const FunctionDef SVC_Table[] = {
+    {0x00, nullptr, "Unknown"},
+    {0x01, SvcWrap<SetHeapSize>, "svcSetHeapSize"},
+    {0x02, nullptr, "svcSetMemoryPermission"},
+    {0x03, nullptr, "svcSetMemoryAttribute"},
+    {0x04, SvcWrap<MapMemory>, "svcMapMemory"},
+    {0x05, SvcWrap<UnmapMemory>, "svcUnmapMemory"},
+    {0x06, SvcWrap<QueryMemory>, "svcQueryMemory"},
+    {0x07, SvcWrap<ExitProcess>, "svcExitProcess"},
+    {0x08, SvcWrap<CreateThread>, "svcCreateThread"},
+    {0x09, SvcWrap<StartThread>, "svcStartThread"},
+    {0x0A, SvcWrap<ExitThread>, "svcExitThread"},
+    {0x0B, SvcWrap<SleepThread>, "svcSleepThread"},
+    {0x0C, SvcWrap<GetThreadPriority>, "svcGetThreadPriority"},
+    {0x0D, SvcWrap<SetThreadPriority>, "svcSetThreadPriority"},
+    {0x0E, nullptr, "svcGetThreadCoreMask"},
+    {0x0F, nullptr, "svcSetThreadCoreMask"},
+    {0x10, SvcWrap<GetCurrentProcessorNumber>, "svcGetCurrentProcessorNumber"},
+    {0x11, nullptr, "svcSignalEvent"},
+    {0x12, nullptr, "svcClearEvent"},
+    {0x13, nullptr, "svcMapSharedMemory"},
+    {0x14, nullptr, "svcUnmapSharedMemory"},
+    {0x15, nullptr, "svcCreateTransferMemory"},
+    {0x16, SvcWrap<CloseHandle>, "svcCloseHandle"},
+    {0x17, nullptr, "svcResetSignal"},
+    {0x18, SvcWrap<WaitSynchronization>, "svcWaitSynchronization"},
+    {0x19, nullptr, "svcCancelSynchronization"},
+    {0x1A, SvcWrap<LockMutex>, "svcLockMutex"},
+    {0x1B, SvcWrap<UnlockMutex>, "svcUnlockMutex"},
+    {0x1C, nullptr, "svcWaitProcessWideKeyAtomic"},
+    {0x1D, SvcWrap<SignalProcessWideKey>, "svcSignalProcessWideKey"},
+    {0x1E, nullptr, "svcGetSystemTick"},
+    {0x1F, SvcWrap<ConnectToPort>, "svcConnectToPort"},
+    {0x20, nullptr, "svcSendSyncRequestLight"},
+    {0x21, SvcWrap<SendSyncRequest>, "svcSendSyncRequest"},
+    {0x22, nullptr, "svcSendSyncRequestWithUserBuffer"},
+    {0x23, nullptr, "svcSendAsyncRequestWithUserBuffer"},
+    {0x24, SvcWrap<GetProcessId>, "svcGetProcessId"},
+    {0x25, SvcWrap<GetThreadId>, "svcGetThreadId"},
+    {0x26, SvcWrap<Break>, "svcBreak"},
+    {0x27, SvcWrap<OutputDebugString>, "svcOutputDebugString"},
+    {0x28, nullptr, "svcReturnFromException"},
+    {0x29, SvcWrap<GetInfo>, "svcGetInfo"},
+    {0x2A, nullptr, "svcFlushEntireDataCache"},
+    {0x2B, nullptr, "svcFlushDataCache"},
+    {0x2C, nullptr, "svcMapPhysicalMemory"},
+    {0x2D, nullptr, "svcUnmapPhysicalMemory"},
+    {0x2E, nullptr, "Unknown"},
+    {0x2F, nullptr, "svcGetLastThreadInfo"},
+    {0x30, nullptr, "svcGetResourceLimitLimitValue"},
+    {0x31, nullptr, "svcGetResourceLimitCurrentValue"},
+    {0x32, nullptr, "svcSetThreadActivity"},
+    {0x33, nullptr, "svcGetThreadContext"},
+    {0x34, nullptr, "Unknown"},
+    {0x35, nullptr, "Unknown"},
+    {0x36, nullptr, "Unknown"},
+    {0x37, nullptr, "Unknown"},
+    {0x38, nullptr, "Unknown"},
+    {0x39, nullptr, "Unknown"},
+    {0x3A, nullptr, "Unknown"},
+    {0x3B, nullptr, "Unknown"},
+    {0x3C, nullptr, "svcDumpInfo"},
+    {0x3D, nullptr, "Unknown"},
+    {0x3E, nullptr, "Unknown"},
+    {0x3F, nullptr, "Unknown"},
+    {0x40, nullptr, "svcCreateSession"},
+    {0x41, nullptr, "svcAcceptSession"},
+    {0x42, nullptr, "svcReplyAndReceiveLight"},
+    {0x43, nullptr, "svcReplyAndReceive"},
+    {0x44, nullptr, "svcReplyAndReceiveWithUserBuffer"},
+    {0x45, nullptr, "svcCreateEvent"},
+    {0x46, nullptr, "Unknown"},
+    {0x47, nullptr, "Unknown"},
+    {0x48, nullptr, "Unknown"},
+    {0x49, nullptr, "Unknown"},
+    {0x4A, nullptr, "Unknown"},
+    {0x4B, nullptr, "Unknown"},
+    {0x4C, nullptr, "Unknown"},
+    {0x4D, nullptr, "svcSleepSystem"},
+    {0x4E, nullptr, "svcReadWriteRegister"},
+    {0x4F, nullptr, "svcSetProcessActivity"},
+    {0x50, nullptr, "svcCreateSharedMemory"},
+    {0x51, nullptr, "svcMapTransferMemory"},
+    {0x52, nullptr, "svcUnmapTransferMemory"},
+    {0x53, nullptr, "svcCreateInterruptEvent"},
+    {0x54, nullptr, "svcQueryPhysicalAddress"},
+    {0x55, nullptr, "svcQueryIoMapping"},
+    {0x56, nullptr, "svcCreateDeviceAddressSpace"},
+    {0x57, nullptr, "svcAttachDeviceAddressSpace"},
+    {0x58, nullptr, "svcDetachDeviceAddressSpace"},
+    {0x59, nullptr, "svcMapDeviceAddressSpaceByForce"},
+    {0x5A, nullptr, "svcMapDeviceAddressSpaceAligned"},
+    {0x5B, nullptr, "svcMapDeviceAddressSpace"},
+    {0x5C, nullptr, "svcUnmapDeviceAddressSpace"},
+    {0x5D, nullptr, "svcInvalidateProcessDataCache"},
+    {0x5E, nullptr, "svcStoreProcessDataCache"},
+    {0x5F, nullptr, "svcFlushProcessDataCache"},
+    {0x60, nullptr, "svcDebugActiveProcess"},
+    {0x61, nullptr, "svcBreakDebugProcess"},
+    {0x62, nullptr, "svcTerminateDebugProcess"},
+    {0x63, nullptr, "svcGetDebugEvent"},
+    {0x64, nullptr, "svcContinueDebugEvent"},
+    {0x65, nullptr, "svcGetProcessList"},
+    {0x66, nullptr, "svcGetThreadList"},
+    {0x67, nullptr, "svcGetDebugThreadContext"},
+    {0x68, nullptr, "svcSetDebugThreadContext"},
+    {0x69, nullptr, "svcQueryDebugProcessMemory"},
+    {0x6A, nullptr, "svcReadDebugProcessMemory"},
+    {0x6B, nullptr, "svcWriteDebugProcessMemory"},
+    {0x6C, nullptr, "svcSetHardwareBreakPoint"},
+    {0x6D, nullptr, "svcGetDebugThreadParam"},
+    {0x6E, nullptr, "Unknown"},
+    {0x6F, nullptr, "Unknown"},
+    {0x70, nullptr, "svcCreatePort"},
+    {0x71, nullptr, "svcManageNamedPort"},
+    {0x72, nullptr, "svcConnectToPort"},
+    {0x73, nullptr, "svcSetProcessMemoryPermission"},
+    {0x74, nullptr, "svcMapProcessMemory"},
+    {0x75, nullptr, "svcUnmapProcessMemory"},
+    {0x76, nullptr, "svcQueryProcessMemory"},
+    {0x77, nullptr, "svcMapProcessCodeMemory"},
+    {0x78, nullptr, "svcUnmapProcessCodeMemory"},
+    {0x79, nullptr, "svcCreateProcess"},
+    {0x7A, nullptr, "svcStartProcess"},
+    {0x7B, nullptr, "svcTerminateProcess"},
+    {0x7C, nullptr, "svcGetProcessInfo"},
+    {0x7D, nullptr, "svcCreateResourceLimit"},
+    {0x7E, nullptr, "svcSetResourceLimitLimitValue"},
+    {0x7F, nullptr, "svcCallSecureMonitor"},
+};
+
+static const FunctionDef* GetSVCInfo(u32 func_num) {
+    if (func_num >= ARRAY_SIZE(SVC_Table)) {
+        LOG_ERROR(Kernel_SVC, "unknown svc=0x%02X", func_num);
+        return nullptr;
+    }
+    return &SVC_Table[func_num];
+}
+
+MICROPROFILE_DEFINE(Kernel_SVC, "Kernel", "SVC", MP_RGB(70, 200, 70));
+
+void CallSVC(u32 immediate) {
+    MICROPROFILE_SCOPE(Kernel_SVC);
+
+    // Lock the global kernel mutex when we enter the kernel HLE.
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+
+    const FunctionDef* info = GetSVCInfo(immediate);
+    if (info) {
+        if (info->func) {
+            info->func();
+        } else {
+            LOG_CRITICAL(Kernel_SVC, "unimplemented SVC function %s(..)", info->name);
+        }
+    } else {
+        LOG_CRITICAL(Kernel_SVC, "unknown SVC function 0x%x", immediate);
+    }
+}
+
+} // namespace Kernel