early-access version 3378
This commit is contained in:
pineappleEA
parent
9533c29326
commit
2e03ea5d50
73 changed files with 10408 additions and 3120 deletions
|
|
@ -1,7 +1,7 @@
|
|||
yuzu emulator early access
|
||||
=============
|
||||
|
||||
This is the source code for early-access 3365.
|
||||
This is the source code for early-access 3378.
|
||||
|
||||
## Legal Notice
|
||||
|
||||
|
|
|
|||
|
|
@ -298,7 +298,43 @@ add_library(core STATIC
|
|||
hle/kernel/svc.h
|
||||
hle/kernel/svc_common.h
|
||||
hle/kernel/svc_types.h
|
||||
hle/kernel/svc_wrap.h
|
||||
hle/kernel/svc/svc_activity.cpp
|
||||
hle/kernel/svc/svc_address_arbiter.cpp
|
||||
hle/kernel/svc/svc_address_translation.cpp
|
||||
hle/kernel/svc/svc_cache.cpp
|
||||
hle/kernel/svc/svc_code_memory.cpp
|
||||
hle/kernel/svc/svc_condition_variable.cpp
|
||||
hle/kernel/svc/svc_debug.cpp
|
||||
hle/kernel/svc/svc_debug_string.cpp
|
||||
hle/kernel/svc/svc_device_address_space.cpp
|
||||
hle/kernel/svc/svc_event.cpp
|
||||
hle/kernel/svc/svc_exception.cpp
|
||||
hle/kernel/svc/svc_info.cpp
|
||||
hle/kernel/svc/svc_insecure_memory.cpp
|
||||
hle/kernel/svc/svc_interrupt_event.cpp
|
||||
hle/kernel/svc/svc_io_pool.cpp
|
||||
hle/kernel/svc/svc_ipc.cpp
|
||||
hle/kernel/svc/svc_kernel_debug.cpp
|
||||
hle/kernel/svc/svc_light_ipc.cpp
|
||||
hle/kernel/svc/svc_lock.cpp
|
||||
hle/kernel/svc/svc_memory.cpp
|
||||
hle/kernel/svc/svc_physical_memory.cpp
|
||||
hle/kernel/svc/svc_port.cpp
|
||||
hle/kernel/svc/svc_power_management.cpp
|
||||
hle/kernel/svc/svc_process.cpp
|
||||
hle/kernel/svc/svc_process_memory.cpp
|
||||
hle/kernel/svc/svc_processor.cpp
|
||||
hle/kernel/svc/svc_query_memory.cpp
|
||||
hle/kernel/svc/svc_register.cpp
|
||||
hle/kernel/svc/svc_resource_limit.cpp
|
||||
hle/kernel/svc/svc_secure_monitor_call.cpp
|
||||
hle/kernel/svc/svc_session.cpp
|
||||
hle/kernel/svc/svc_shared_memory.cpp
|
||||
hle/kernel/svc/svc_synchronization.cpp
|
||||
hle/kernel/svc/svc_thread.cpp
|
||||
hle/kernel/svc/svc_thread_profiler.cpp
|
||||
hle/kernel/svc/svc_tick.cpp
|
||||
hle/kernel/svc/svc_transfer_memory.cpp
|
||||
hle/result.h
|
||||
hle/service/acc/acc.cpp
|
||||
hle/service/acc/acc.h
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
|
||||
#include <array>
|
||||
#include <span>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <dynarmic/interface/halt_reason.h>
|
||||
|
|
|
|||
|
|
@ -203,23 +203,23 @@ Result KCapabilities::ProcessMapRegionCapability(const u32 cap, F f) {
|
|||
|
||||
Result KCapabilities::MapRegion_(const u32 cap, KPageTable* page_table) {
|
||||
// Map each region into the process's page table.
|
||||
R_RETURN(ProcessMapRegionCapability(
|
||||
return ProcessMapRegionCapability(
|
||||
cap, [](KMemoryRegionType region_type, KMemoryPermission perm) -> Result {
|
||||
// R_RETURN(page_table->MapRegion(region_type, perm));
|
||||
UNIMPLEMENTED();
|
||||
R_SUCCEED();
|
||||
}));
|
||||
});
|
||||
}
|
||||
|
||||
Result KCapabilities::CheckMapRegion(KernelCore& kernel, const u32 cap) {
|
||||
// Check that each region has a physical backing store.
|
||||
R_RETURN(ProcessMapRegionCapability(
|
||||
return ProcessMapRegionCapability(
|
||||
cap, [&](KMemoryRegionType region_type, KMemoryPermission perm) -> Result {
|
||||
R_UNLESS(kernel.MemoryLayout().GetPhysicalMemoryRegionTree().FindFirstDerived(
|
||||
region_type) != nullptr,
|
||||
ResultOutOfRange);
|
||||
R_SUCCEED();
|
||||
}));
|
||||
});
|
||||
}
|
||||
|
||||
Result KCapabilities::SetInterruptPairCapability(const u32 cap) {
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include <condition_variable>
|
||||
#include <cstddef>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,16 +1,536 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
||||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#pragma once
|
||||
// This file is automatically generated using svc_generator.py.
|
||||
|
||||
#include "common/common_types.h"
|
||||
#pragma once
|
||||
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
#include "common/common_types.h"
|
||||
#include "core/hle/kernel/svc_types.h"
|
||||
#include "core/hle/result.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
void Call(Core::System& system, u32 immediate);
|
||||
// clang-format off
|
||||
Result SetHeapSize(Core::System& system, uintptr_t* out_address, uint64_t size);
|
||||
Result SetMemoryPermission(Core::System& system, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
Result SetMemoryAttribute(Core::System& system, uint64_t address, uint64_t size, uint32_t mask, uint32_t attr);
|
||||
Result MapMemory(Core::System& system, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result UnmapMemory(Core::System& system, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result QueryMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, uint64_t address);
|
||||
void ExitProcess(Core::System& system);
|
||||
Result CreateThread(Core::System& system, Handle* out_handle, uint64_t func, uint64_t arg, uint64_t stack_bottom, int32_t priority, int32_t core_id);
|
||||
Result StartThread(Core::System& system, Handle thread_handle);
|
||||
void ExitThread(Core::System& system);
|
||||
void SleepThread(Core::System& system, int64_t ns);
|
||||
Result GetThreadPriority(Core::System& system, int32_t* out_priority, Handle thread_handle);
|
||||
Result SetThreadPriority(Core::System& system, Handle thread_handle, int32_t priority);
|
||||
Result GetThreadCoreMask(Core::System& system, int32_t* out_core_id, uint64_t* out_affinity_mask, Handle thread_handle);
|
||||
Result SetThreadCoreMask(Core::System& system, Handle thread_handle, int32_t core_id, uint64_t affinity_mask);
|
||||
int32_t GetCurrentProcessorNumber(Core::System& system);
|
||||
Result SignalEvent(Core::System& system, Handle event_handle);
|
||||
Result ClearEvent(Core::System& system, Handle event_handle);
|
||||
Result MapSharedMemory(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size, MemoryPermission map_perm);
|
||||
Result UnmapSharedMemory(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size);
|
||||
Result CreateTransferMemory(Core::System& system, Handle* out_handle, uint64_t address, uint64_t size, MemoryPermission map_perm);
|
||||
Result CloseHandle(Core::System& system, Handle handle);
|
||||
Result ResetSignal(Core::System& system, Handle handle);
|
||||
Result WaitSynchronization(Core::System& system, int32_t* out_index, uint64_t handles, int32_t num_handles, int64_t timeout_ns);
|
||||
Result CancelSynchronization(Core::System& system, Handle handle);
|
||||
Result ArbitrateLock(Core::System& system, Handle thread_handle, uint64_t address, uint32_t tag);
|
||||
Result ArbitrateUnlock(Core::System& system, uint64_t address);
|
||||
Result WaitProcessWideKeyAtomic(Core::System& system, uint64_t address, uint64_t cv_key, uint32_t tag, int64_t timeout_ns);
|
||||
void SignalProcessWideKey(Core::System& system, uint64_t cv_key, int32_t count);
|
||||
int64_t GetSystemTick(Core::System& system);
|
||||
Result ConnectToNamedPort(Core::System& system, Handle* out_handle, uint64_t name);
|
||||
Result SendSyncRequest(Core::System& system, Handle session_handle);
|
||||
Result SendSyncRequestWithUserBuffer(Core::System& system, uint64_t message_buffer, uint64_t message_buffer_size, Handle session_handle);
|
||||
Result SendAsyncRequestWithUserBuffer(Core::System& system, Handle* out_event_handle, uint64_t message_buffer, uint64_t message_buffer_size, Handle session_handle);
|
||||
Result GetProcessId(Core::System& system, uint64_t* out_process_id, Handle process_handle);
|
||||
Result GetThreadId(Core::System& system, uint64_t* out_thread_id, Handle thread_handle);
|
||||
void Break(Core::System& system, BreakReason break_reason, uint64_t arg, uint64_t size);
|
||||
Result OutputDebugString(Core::System& system, uint64_t debug_str, uint64_t len);
|
||||
void ReturnFromException(Core::System& system, Result result);
|
||||
Result GetInfo(Core::System& system, uint64_t* out, InfoType info_type, Handle handle, uint64_t info_subtype);
|
||||
void FlushEntireDataCache(Core::System& system);
|
||||
Result FlushDataCache(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result MapPhysicalMemory(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result UnmapPhysicalMemory(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result GetDebugFutureThreadInfo(Core::System& system, lp64::LastThreadContext* out_context, uint64_t* out_thread_id, Handle debug_handle, int64_t ns);
|
||||
Result GetLastThreadInfo(Core::System& system, lp64::LastThreadContext* out_context, uintptr_t* out_tls_address, uint32_t* out_flags);
|
||||
Result GetResourceLimitLimitValue(Core::System& system, int64_t* out_limit_value, Handle resource_limit_handle, LimitableResource which);
|
||||
Result GetResourceLimitCurrentValue(Core::System& system, int64_t* out_current_value, Handle resource_limit_handle, LimitableResource which);
|
||||
Result SetThreadActivity(Core::System& system, Handle thread_handle, ThreadActivity thread_activity);
|
||||
Result GetThreadContext3(Core::System& system, uint64_t out_context, Handle thread_handle);
|
||||
Result WaitForAddress(Core::System& system, uint64_t address, ArbitrationType arb_type, int32_t value, int64_t timeout_ns);
|
||||
Result SignalToAddress(Core::System& system, uint64_t address, SignalType signal_type, int32_t value, int32_t count);
|
||||
void SynchronizePreemptionState(Core::System& system);
|
||||
Result GetResourceLimitPeakValue(Core::System& system, int64_t* out_peak_value, Handle resource_limit_handle, LimitableResource which);
|
||||
Result CreateIoPool(Core::System& system, Handle* out_handle, IoPoolType which);
|
||||
Result CreateIoRegion(Core::System& system, Handle* out_handle, Handle io_pool, uint64_t physical_address, uint64_t size, MemoryMapping mapping, MemoryPermission perm);
|
||||
void KernelDebug(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2);
|
||||
void ChangeKernelTraceState(Core::System& system, KernelTraceState kern_trace_state);
|
||||
Result CreateSession(Core::System& system, Handle* out_server_session_handle, Handle* out_client_session_handle, bool is_light, uint64_t name);
|
||||
Result AcceptSession(Core::System& system, Handle* out_handle, Handle port);
|
||||
Result ReplyAndReceive(Core::System& system, int32_t* out_index, uint64_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
|
||||
Result ReplyAndReceiveWithUserBuffer(Core::System& system, int32_t* out_index, uint64_t message_buffer, uint64_t message_buffer_size, uint64_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
|
||||
Result CreateEvent(Core::System& system, Handle* out_write_handle, Handle* out_read_handle);
|
||||
Result MapIoRegion(Core::System& system, Handle io_region, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
Result UnmapIoRegion(Core::System& system, Handle io_region, uint64_t address, uint64_t size);
|
||||
Result MapPhysicalMemoryUnsafe(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result UnmapPhysicalMemoryUnsafe(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result SetUnsafeLimit(Core::System& system, uint64_t limit);
|
||||
Result CreateCodeMemory(Core::System& system, Handle* out_handle, uint64_t address, uint64_t size);
|
||||
Result ControlCodeMemory(Core::System& system, Handle code_memory_handle, CodeMemoryOperation operation, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
void SleepSystem(Core::System& system);
|
||||
Result ReadWriteRegister(Core::System& system, uint32_t* out_value, uint64_t address, uint32_t mask, uint32_t value);
|
||||
Result SetProcessActivity(Core::System& system, Handle process_handle, ProcessActivity process_activity);
|
||||
Result CreateSharedMemory(Core::System& system, Handle* out_handle, uint64_t size, MemoryPermission owner_perm, MemoryPermission remote_perm);
|
||||
Result MapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size, MemoryPermission owner_perm);
|
||||
Result UnmapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size);
|
||||
Result CreateInterruptEvent(Core::System& system, Handle* out_read_handle, int32_t interrupt_id, InterruptType interrupt_type);
|
||||
Result QueryPhysicalAddress(Core::System& system, lp64::PhysicalMemoryInfo* out_info, uint64_t address);
|
||||
Result QueryIoMapping(Core::System& system, uintptr_t* out_address, uintptr_t* out_size, uint64_t physical_address, uint64_t size);
|
||||
Result CreateDeviceAddressSpace(Core::System& system, Handle* out_handle, uint64_t das_address, uint64_t das_size);
|
||||
Result AttachDeviceAddressSpace(Core::System& system, DeviceName device_name, Handle das_handle);
|
||||
Result DetachDeviceAddressSpace(Core::System& system, DeviceName device_name, Handle das_handle);
|
||||
Result MapDeviceAddressSpaceByForce(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address, uint32_t option);
|
||||
Result MapDeviceAddressSpaceAligned(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address, uint32_t option);
|
||||
Result UnmapDeviceAddressSpace(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address);
|
||||
Result InvalidateProcessDataCache(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
|
||||
Result StoreProcessDataCache(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
|
||||
Result FlushProcessDataCache(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
|
||||
Result DebugActiveProcess(Core::System& system, Handle* out_handle, uint64_t process_id);
|
||||
Result BreakDebugProcess(Core::System& system, Handle debug_handle);
|
||||
Result TerminateDebugProcess(Core::System& system, Handle debug_handle);
|
||||
Result GetDebugEvent(Core::System& system, uint64_t out_info, Handle debug_handle);
|
||||
Result ContinueDebugEvent(Core::System& system, Handle debug_handle, uint32_t flags, uint64_t thread_ids, int32_t num_thread_ids);
|
||||
Result GetProcessList(Core::System& system, int32_t* out_num_processes, uint64_t out_process_ids, int32_t max_out_count);
|
||||
Result GetThreadList(Core::System& system, int32_t* out_num_threads, uint64_t out_thread_ids, int32_t max_out_count, Handle debug_handle);
|
||||
Result GetDebugThreadContext(Core::System& system, uint64_t out_context, Handle debug_handle, uint64_t thread_id, uint32_t context_flags);
|
||||
Result SetDebugThreadContext(Core::System& system, Handle debug_handle, uint64_t thread_id, uint64_t context, uint32_t context_flags);
|
||||
Result QueryDebugProcessMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
|
||||
Result ReadDebugProcessMemory(Core::System& system, uint64_t buffer, Handle debug_handle, uint64_t address, uint64_t size);
|
||||
Result WriteDebugProcessMemory(Core::System& system, Handle debug_handle, uint64_t buffer, uint64_t address, uint64_t size);
|
||||
Result SetHardwareBreakPoint(Core::System& system, HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value);
|
||||
Result GetDebugThreadParam(Core::System& system, uint64_t* out_64, uint32_t* out_32, Handle debug_handle, uint64_t thread_id, DebugThreadParam param);
|
||||
Result GetSystemInfo(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle, uint64_t info_subtype);
|
||||
Result CreatePort(Core::System& system, Handle* out_server_handle, Handle* out_client_handle, int32_t max_sessions, bool is_light, uint64_t name);
|
||||
Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t name, int32_t max_sessions);
|
||||
Result ConnectToPort(Core::System& system, Handle* out_handle, Handle port);
|
||||
Result SetProcessMemoryPermission(Core::System& system, Handle process_handle, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
Result MapProcessMemory(Core::System& system, uint64_t dst_address, Handle process_handle, uint64_t src_address, uint64_t size);
|
||||
Result UnmapProcessMemory(Core::System& system, uint64_t dst_address, Handle process_handle, uint64_t src_address, uint64_t size);
|
||||
Result QueryProcessMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
|
||||
Result MapProcessCodeMemory(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result CreateProcess(Core::System& system, Handle* out_handle, uint64_t parameters, uint64_t caps, int32_t num_caps);
|
||||
Result StartProcess(Core::System& system, Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size);
|
||||
Result TerminateProcess(Core::System& system, Handle process_handle);
|
||||
Result GetProcessInfo(Core::System& system, int64_t* out_info, Handle process_handle, ProcessInfoType info_type);
|
||||
Result CreateResourceLimit(Core::System& system, Handle* out_handle);
|
||||
Result SetResourceLimitLimitValue(Core::System& system, Handle resource_limit_handle, LimitableResource which, int64_t limit_value);
|
||||
Result MapInsecureMemory(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result UnmapInsecureMemory(Core::System& system, uint64_t address, uint64_t size);
|
||||
|
||||
Result SetHeapSize64From32(Core::System& system, uintptr_t* out_address, uint32_t size);
|
||||
Result SetMemoryPermission64From32(Core::System& system, uint32_t address, uint32_t size, MemoryPermission perm);
|
||||
Result SetMemoryAttribute64From32(Core::System& system, uint32_t address, uint32_t size, uint32_t mask, uint32_t attr);
|
||||
Result MapMemory64From32(Core::System& system, uint32_t dst_address, uint32_t src_address, uint32_t size);
|
||||
Result UnmapMemory64From32(Core::System& system, uint32_t dst_address, uint32_t src_address, uint32_t size);
|
||||
Result QueryMemory64From32(Core::System& system, uint32_t out_memory_info, PageInfo* out_page_info, uint32_t address);
|
||||
void ExitProcess64From32(Core::System& system);
|
||||
Result CreateThread64From32(Core::System& system, Handle* out_handle, uint32_t func, uint32_t arg, uint32_t stack_bottom, int32_t priority, int32_t core_id);
|
||||
Result StartThread64From32(Core::System& system, Handle thread_handle);
|
||||
void ExitThread64From32(Core::System& system);
|
||||
void SleepThread64From32(Core::System& system, int64_t ns);
|
||||
Result GetThreadPriority64From32(Core::System& system, int32_t* out_priority, Handle thread_handle);
|
||||
Result SetThreadPriority64From32(Core::System& system, Handle thread_handle, int32_t priority);
|
||||
Result GetThreadCoreMask64From32(Core::System& system, int32_t* out_core_id, uint64_t* out_affinity_mask, Handle thread_handle);
|
||||
Result SetThreadCoreMask64From32(Core::System& system, Handle thread_handle, int32_t core_id, uint64_t affinity_mask);
|
||||
int32_t GetCurrentProcessorNumber64From32(Core::System& system);
|
||||
Result SignalEvent64From32(Core::System& system, Handle event_handle);
|
||||
Result ClearEvent64From32(Core::System& system, Handle event_handle);
|
||||
Result MapSharedMemory64From32(Core::System& system, Handle shmem_handle, uint32_t address, uint32_t size, MemoryPermission map_perm);
|
||||
Result UnmapSharedMemory64From32(Core::System& system, Handle shmem_handle, uint32_t address, uint32_t size);
|
||||
Result CreateTransferMemory64From32(Core::System& system, Handle* out_handle, uint32_t address, uint32_t size, MemoryPermission map_perm);
|
||||
Result CloseHandle64From32(Core::System& system, Handle handle);
|
||||
Result ResetSignal64From32(Core::System& system, Handle handle);
|
||||
Result WaitSynchronization64From32(Core::System& system, int32_t* out_index, uint32_t handles, int32_t num_handles, int64_t timeout_ns);
|
||||
Result CancelSynchronization64From32(Core::System& system, Handle handle);
|
||||
Result ArbitrateLock64From32(Core::System& system, Handle thread_handle, uint32_t address, uint32_t tag);
|
||||
Result ArbitrateUnlock64From32(Core::System& system, uint32_t address);
|
||||
Result WaitProcessWideKeyAtomic64From32(Core::System& system, uint32_t address, uint32_t cv_key, uint32_t tag, int64_t timeout_ns);
|
||||
void SignalProcessWideKey64From32(Core::System& system, uint32_t cv_key, int32_t count);
|
||||
int64_t GetSystemTick64From32(Core::System& system);
|
||||
Result ConnectToNamedPort64From32(Core::System& system, Handle* out_handle, uint32_t name);
|
||||
Result SendSyncRequest64From32(Core::System& system, Handle session_handle);
|
||||
Result SendSyncRequestWithUserBuffer64From32(Core::System& system, uint32_t message_buffer, uint32_t message_buffer_size, Handle session_handle);
|
||||
Result SendAsyncRequestWithUserBuffer64From32(Core::System& system, Handle* out_event_handle, uint32_t message_buffer, uint32_t message_buffer_size, Handle session_handle);
|
||||
Result GetProcessId64From32(Core::System& system, uint64_t* out_process_id, Handle process_handle);
|
||||
Result GetThreadId64From32(Core::System& system, uint64_t* out_thread_id, Handle thread_handle);
|
||||
void Break64From32(Core::System& system, BreakReason break_reason, uint32_t arg, uint32_t size);
|
||||
Result OutputDebugString64From32(Core::System& system, uint32_t debug_str, uint32_t len);
|
||||
void ReturnFromException64From32(Core::System& system, Result result);
|
||||
Result GetInfo64From32(Core::System& system, uint64_t* out, InfoType info_type, Handle handle, uint64_t info_subtype);
|
||||
void FlushEntireDataCache64From32(Core::System& system);
|
||||
Result FlushDataCache64From32(Core::System& system, uint32_t address, uint32_t size);
|
||||
Result MapPhysicalMemory64From32(Core::System& system, uint32_t address, uint32_t size);
|
||||
Result UnmapPhysicalMemory64From32(Core::System& system, uint32_t address, uint32_t size);
|
||||
Result GetDebugFutureThreadInfo64From32(Core::System& system, ilp32::LastThreadContext* out_context, uint64_t* out_thread_id, Handle debug_handle, int64_t ns);
|
||||
Result GetLastThreadInfo64From32(Core::System& system, ilp32::LastThreadContext* out_context, uintptr_t* out_tls_address, uint32_t* out_flags);
|
||||
Result GetResourceLimitLimitValue64From32(Core::System& system, int64_t* out_limit_value, Handle resource_limit_handle, LimitableResource which);
|
||||
Result GetResourceLimitCurrentValue64From32(Core::System& system, int64_t* out_current_value, Handle resource_limit_handle, LimitableResource which);
|
||||
Result SetThreadActivity64From32(Core::System& system, Handle thread_handle, ThreadActivity thread_activity);
|
||||
Result GetThreadContext364From32(Core::System& system, uint32_t out_context, Handle thread_handle);
|
||||
Result WaitForAddress64From32(Core::System& system, uint32_t address, ArbitrationType arb_type, int32_t value, int64_t timeout_ns);
|
||||
Result SignalToAddress64From32(Core::System& system, uint32_t address, SignalType signal_type, int32_t value, int32_t count);
|
||||
void SynchronizePreemptionState64From32(Core::System& system);
|
||||
Result GetResourceLimitPeakValue64From32(Core::System& system, int64_t* out_peak_value, Handle resource_limit_handle, LimitableResource which);
|
||||
Result CreateIoPool64From32(Core::System& system, Handle* out_handle, IoPoolType which);
|
||||
Result CreateIoRegion64From32(Core::System& system, Handle* out_handle, Handle io_pool, uint64_t physical_address, uint32_t size, MemoryMapping mapping, MemoryPermission perm);
|
||||
void KernelDebug64From32(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2);
|
||||
void ChangeKernelTraceState64From32(Core::System& system, KernelTraceState kern_trace_state);
|
||||
Result CreateSession64From32(Core::System& system, Handle* out_server_session_handle, Handle* out_client_session_handle, bool is_light, uint32_t name);
|
||||
Result AcceptSession64From32(Core::System& system, Handle* out_handle, Handle port);
|
||||
Result ReplyAndReceive64From32(Core::System& system, int32_t* out_index, uint32_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
|
||||
Result ReplyAndReceiveWithUserBuffer64From32(Core::System& system, int32_t* out_index, uint32_t message_buffer, uint32_t message_buffer_size, uint32_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
|
||||
Result CreateEvent64From32(Core::System& system, Handle* out_write_handle, Handle* out_read_handle);
|
||||
Result MapIoRegion64From32(Core::System& system, Handle io_region, uint32_t address, uint32_t size, MemoryPermission perm);
|
||||
Result UnmapIoRegion64From32(Core::System& system, Handle io_region, uint32_t address, uint32_t size);
|
||||
Result MapPhysicalMemoryUnsafe64From32(Core::System& system, uint32_t address, uint32_t size);
|
||||
Result UnmapPhysicalMemoryUnsafe64From32(Core::System& system, uint32_t address, uint32_t size);
|
||||
Result SetUnsafeLimit64From32(Core::System& system, uint32_t limit);
|
||||
Result CreateCodeMemory64From32(Core::System& system, Handle* out_handle, uint32_t address, uint32_t size);
|
||||
Result ControlCodeMemory64From32(Core::System& system, Handle code_memory_handle, CodeMemoryOperation operation, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
void SleepSystem64From32(Core::System& system);
|
||||
Result ReadWriteRegister64From32(Core::System& system, uint32_t* out_value, uint64_t address, uint32_t mask, uint32_t value);
|
||||
Result SetProcessActivity64From32(Core::System& system, Handle process_handle, ProcessActivity process_activity);
|
||||
Result CreateSharedMemory64From32(Core::System& system, Handle* out_handle, uint32_t size, MemoryPermission owner_perm, MemoryPermission remote_perm);
|
||||
Result MapTransferMemory64From32(Core::System& system, Handle trmem_handle, uint32_t address, uint32_t size, MemoryPermission owner_perm);
|
||||
Result UnmapTransferMemory64From32(Core::System& system, Handle trmem_handle, uint32_t address, uint32_t size);
|
||||
Result CreateInterruptEvent64From32(Core::System& system, Handle* out_read_handle, int32_t interrupt_id, InterruptType interrupt_type);
|
||||
Result QueryPhysicalAddress64From32(Core::System& system, ilp32::PhysicalMemoryInfo* out_info, uint32_t address);
|
||||
Result QueryIoMapping64From32(Core::System& system, uintptr_t* out_address, uintptr_t* out_size, uint64_t physical_address, uint32_t size);
|
||||
Result CreateDeviceAddressSpace64From32(Core::System& system, Handle* out_handle, uint64_t das_address, uint64_t das_size);
|
||||
Result AttachDeviceAddressSpace64From32(Core::System& system, DeviceName device_name, Handle das_handle);
|
||||
Result DetachDeviceAddressSpace64From32(Core::System& system, DeviceName device_name, Handle das_handle);
|
||||
Result MapDeviceAddressSpaceByForce64From32(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint32_t size, uint64_t device_address, uint32_t option);
|
||||
Result MapDeviceAddressSpaceAligned64From32(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint32_t size, uint64_t device_address, uint32_t option);
|
||||
Result UnmapDeviceAddressSpace64From32(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint32_t size, uint64_t device_address);
|
||||
Result InvalidateProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
|
||||
Result StoreProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
|
||||
Result FlushProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
|
||||
Result DebugActiveProcess64From32(Core::System& system, Handle* out_handle, uint64_t process_id);
|
||||
Result BreakDebugProcess64From32(Core::System& system, Handle debug_handle);
|
||||
Result TerminateDebugProcess64From32(Core::System& system, Handle debug_handle);
|
||||
Result GetDebugEvent64From32(Core::System& system, uint32_t out_info, Handle debug_handle);
|
||||
Result ContinueDebugEvent64From32(Core::System& system, Handle debug_handle, uint32_t flags, uint32_t thread_ids, int32_t num_thread_ids);
|
||||
Result GetProcessList64From32(Core::System& system, int32_t* out_num_processes, uint32_t out_process_ids, int32_t max_out_count);
|
||||
Result GetThreadList64From32(Core::System& system, int32_t* out_num_threads, uint32_t out_thread_ids, int32_t max_out_count, Handle debug_handle);
|
||||
Result GetDebugThreadContext64From32(Core::System& system, uint32_t out_context, Handle debug_handle, uint64_t thread_id, uint32_t context_flags);
|
||||
Result SetDebugThreadContext64From32(Core::System& system, Handle debug_handle, uint64_t thread_id, uint32_t context, uint32_t context_flags);
|
||||
Result QueryDebugProcessMemory64From32(Core::System& system, uint32_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint32_t address);
|
||||
Result ReadDebugProcessMemory64From32(Core::System& system, uint32_t buffer, Handle debug_handle, uint32_t address, uint32_t size);
|
||||
Result WriteDebugProcessMemory64From32(Core::System& system, Handle debug_handle, uint32_t buffer, uint32_t address, uint32_t size);
|
||||
Result SetHardwareBreakPoint64From32(Core::System& system, HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value);
|
||||
Result GetDebugThreadParam64From32(Core::System& system, uint64_t* out_64, uint32_t* out_32, Handle debug_handle, uint64_t thread_id, DebugThreadParam param);
|
||||
Result GetSystemInfo64From32(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle, uint64_t info_subtype);
|
||||
Result CreatePort64From32(Core::System& system, Handle* out_server_handle, Handle* out_client_handle, int32_t max_sessions, bool is_light, uint32_t name);
|
||||
Result ManageNamedPort64From32(Core::System& system, Handle* out_server_handle, uint32_t name, int32_t max_sessions);
|
||||
Result ConnectToPort64From32(Core::System& system, Handle* out_handle, Handle port);
|
||||
Result SetProcessMemoryPermission64From32(Core::System& system, Handle process_handle, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
Result MapProcessMemory64From32(Core::System& system, uint32_t dst_address, Handle process_handle, uint64_t src_address, uint32_t size);
|
||||
Result UnmapProcessMemory64From32(Core::System& system, uint32_t dst_address, Handle process_handle, uint64_t src_address, uint32_t size);
|
||||
Result QueryProcessMemory64From32(Core::System& system, uint32_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
|
||||
Result MapProcessCodeMemory64From32(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result UnmapProcessCodeMemory64From32(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result CreateProcess64From32(Core::System& system, Handle* out_handle, uint32_t parameters, uint32_t caps, int32_t num_caps);
|
||||
Result StartProcess64From32(Core::System& system, Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size);
|
||||
Result TerminateProcess64From32(Core::System& system, Handle process_handle);
|
||||
Result GetProcessInfo64From32(Core::System& system, int64_t* out_info, Handle process_handle, ProcessInfoType info_type);
|
||||
Result CreateResourceLimit64From32(Core::System& system, Handle* out_handle);
|
||||
Result SetResourceLimitLimitValue64From32(Core::System& system, Handle resource_limit_handle, LimitableResource which, int64_t limit_value);
|
||||
Result MapInsecureMemory64From32(Core::System& system, uint32_t address, uint32_t size);
|
||||
Result UnmapInsecureMemory64From32(Core::System& system, uint32_t address, uint32_t size);
|
||||
|
||||
Result SetHeapSize64(Core::System& system, uintptr_t* out_address, uint64_t size);
|
||||
Result SetMemoryPermission64(Core::System& system, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
Result SetMemoryAttribute64(Core::System& system, uint64_t address, uint64_t size, uint32_t mask, uint32_t attr);
|
||||
Result MapMemory64(Core::System& system, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result UnmapMemory64(Core::System& system, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result QueryMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, uint64_t address);
|
||||
void ExitProcess64(Core::System& system);
|
||||
Result CreateThread64(Core::System& system, Handle* out_handle, uint64_t func, uint64_t arg, uint64_t stack_bottom, int32_t priority, int32_t core_id);
|
||||
Result StartThread64(Core::System& system, Handle thread_handle);
|
||||
void ExitThread64(Core::System& system);
|
||||
void SleepThread64(Core::System& system, int64_t ns);
|
||||
Result GetThreadPriority64(Core::System& system, int32_t* out_priority, Handle thread_handle);
|
||||
Result SetThreadPriority64(Core::System& system, Handle thread_handle, int32_t priority);
|
||||
Result GetThreadCoreMask64(Core::System& system, int32_t* out_core_id, uint64_t* out_affinity_mask, Handle thread_handle);
|
||||
Result SetThreadCoreMask64(Core::System& system, Handle thread_handle, int32_t core_id, uint64_t affinity_mask);
|
||||
int32_t GetCurrentProcessorNumber64(Core::System& system);
|
||||
Result SignalEvent64(Core::System& system, Handle event_handle);
|
||||
Result ClearEvent64(Core::System& system, Handle event_handle);
|
||||
Result MapSharedMemory64(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size, MemoryPermission map_perm);
|
||||
Result UnmapSharedMemory64(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size);
|
||||
Result CreateTransferMemory64(Core::System& system, Handle* out_handle, uint64_t address, uint64_t size, MemoryPermission map_perm);
|
||||
Result CloseHandle64(Core::System& system, Handle handle);
|
||||
Result ResetSignal64(Core::System& system, Handle handle);
|
||||
Result WaitSynchronization64(Core::System& system, int32_t* out_index, uint64_t handles, int32_t num_handles, int64_t timeout_ns);
|
||||
Result CancelSynchronization64(Core::System& system, Handle handle);
|
||||
Result ArbitrateLock64(Core::System& system, Handle thread_handle, uint64_t address, uint32_t tag);
|
||||
Result ArbitrateUnlock64(Core::System& system, uint64_t address);
|
||||
Result WaitProcessWideKeyAtomic64(Core::System& system, uint64_t address, uint64_t cv_key, uint32_t tag, int64_t timeout_ns);
|
||||
void SignalProcessWideKey64(Core::System& system, uint64_t cv_key, int32_t count);
|
||||
int64_t GetSystemTick64(Core::System& system);
|
||||
Result ConnectToNamedPort64(Core::System& system, Handle* out_handle, uint64_t name);
|
||||
Result SendSyncRequest64(Core::System& system, Handle session_handle);
|
||||
Result SendSyncRequestWithUserBuffer64(Core::System& system, uint64_t message_buffer, uint64_t message_buffer_size, Handle session_handle);
|
||||
Result SendAsyncRequestWithUserBuffer64(Core::System& system, Handle* out_event_handle, uint64_t message_buffer, uint64_t message_buffer_size, Handle session_handle);
|
||||
Result GetProcessId64(Core::System& system, uint64_t* out_process_id, Handle process_handle);
|
||||
Result GetThreadId64(Core::System& system, uint64_t* out_thread_id, Handle thread_handle);
|
||||
void Break64(Core::System& system, BreakReason break_reason, uint64_t arg, uint64_t size);
|
||||
Result OutputDebugString64(Core::System& system, uint64_t debug_str, uint64_t len);
|
||||
void ReturnFromException64(Core::System& system, Result result);
|
||||
Result GetInfo64(Core::System& system, uint64_t* out, InfoType info_type, Handle handle, uint64_t info_subtype);
|
||||
void FlushEntireDataCache64(Core::System& system);
|
||||
Result FlushDataCache64(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result MapPhysicalMemory64(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result UnmapPhysicalMemory64(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result GetDebugFutureThreadInfo64(Core::System& system, lp64::LastThreadContext* out_context, uint64_t* out_thread_id, Handle debug_handle, int64_t ns);
|
||||
Result GetLastThreadInfo64(Core::System& system, lp64::LastThreadContext* out_context, uintptr_t* out_tls_address, uint32_t* out_flags);
|
||||
Result GetResourceLimitLimitValue64(Core::System& system, int64_t* out_limit_value, Handle resource_limit_handle, LimitableResource which);
|
||||
Result GetResourceLimitCurrentValue64(Core::System& system, int64_t* out_current_value, Handle resource_limit_handle, LimitableResource which);
|
||||
Result SetThreadActivity64(Core::System& system, Handle thread_handle, ThreadActivity thread_activity);
|
||||
Result GetThreadContext364(Core::System& system, uint64_t out_context, Handle thread_handle);
|
||||
Result WaitForAddress64(Core::System& system, uint64_t address, ArbitrationType arb_type, int32_t value, int64_t timeout_ns);
|
||||
Result SignalToAddress64(Core::System& system, uint64_t address, SignalType signal_type, int32_t value, int32_t count);
|
||||
void SynchronizePreemptionState64(Core::System& system);
|
||||
Result GetResourceLimitPeakValue64(Core::System& system, int64_t* out_peak_value, Handle resource_limit_handle, LimitableResource which);
|
||||
Result CreateIoPool64(Core::System& system, Handle* out_handle, IoPoolType which);
|
||||
Result CreateIoRegion64(Core::System& system, Handle* out_handle, Handle io_pool, uint64_t physical_address, uint64_t size, MemoryMapping mapping, MemoryPermission perm);
|
||||
void KernelDebug64(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2);
|
||||
void ChangeKernelTraceState64(Core::System& system, KernelTraceState kern_trace_state);
|
||||
Result CreateSession64(Core::System& system, Handle* out_server_session_handle, Handle* out_client_session_handle, bool is_light, uint64_t name);
|
||||
Result AcceptSession64(Core::System& system, Handle* out_handle, Handle port);
|
||||
Result ReplyAndReceive64(Core::System& system, int32_t* out_index, uint64_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
|
||||
Result ReplyAndReceiveWithUserBuffer64(Core::System& system, int32_t* out_index, uint64_t message_buffer, uint64_t message_buffer_size, uint64_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
|
||||
Result CreateEvent64(Core::System& system, Handle* out_write_handle, Handle* out_read_handle);
|
||||
Result MapIoRegion64(Core::System& system, Handle io_region, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
Result UnmapIoRegion64(Core::System& system, Handle io_region, uint64_t address, uint64_t size);
|
||||
Result MapPhysicalMemoryUnsafe64(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result UnmapPhysicalMemoryUnsafe64(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result SetUnsafeLimit64(Core::System& system, uint64_t limit);
|
||||
Result CreateCodeMemory64(Core::System& system, Handle* out_handle, uint64_t address, uint64_t size);
|
||||
Result ControlCodeMemory64(Core::System& system, Handle code_memory_handle, CodeMemoryOperation operation, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
void SleepSystem64(Core::System& system);
|
||||
Result ReadWriteRegister64(Core::System& system, uint32_t* out_value, uint64_t address, uint32_t mask, uint32_t value);
|
||||
Result SetProcessActivity64(Core::System& system, Handle process_handle, ProcessActivity process_activity);
|
||||
Result CreateSharedMemory64(Core::System& system, Handle* out_handle, uint64_t size, MemoryPermission owner_perm, MemoryPermission remote_perm);
|
||||
Result MapTransferMemory64(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size, MemoryPermission owner_perm);
|
||||
Result UnmapTransferMemory64(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size);
|
||||
Result CreateInterruptEvent64(Core::System& system, Handle* out_read_handle, int32_t interrupt_id, InterruptType interrupt_type);
|
||||
Result QueryPhysicalAddress64(Core::System& system, lp64::PhysicalMemoryInfo* out_info, uint64_t address);
|
||||
Result QueryIoMapping64(Core::System& system, uintptr_t* out_address, uintptr_t* out_size, uint64_t physical_address, uint64_t size);
|
||||
Result CreateDeviceAddressSpace64(Core::System& system, Handle* out_handle, uint64_t das_address, uint64_t das_size);
|
||||
Result AttachDeviceAddressSpace64(Core::System& system, DeviceName device_name, Handle das_handle);
|
||||
Result DetachDeviceAddressSpace64(Core::System& system, DeviceName device_name, Handle das_handle);
|
||||
Result MapDeviceAddressSpaceByForce64(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address, uint32_t option);
|
||||
Result MapDeviceAddressSpaceAligned64(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address, uint32_t option);
|
||||
Result UnmapDeviceAddressSpace64(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address);
|
||||
Result InvalidateProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
|
||||
Result StoreProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
|
||||
Result FlushProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
|
||||
Result DebugActiveProcess64(Core::System& system, Handle* out_handle, uint64_t process_id);
|
||||
Result BreakDebugProcess64(Core::System& system, Handle debug_handle);
|
||||
Result TerminateDebugProcess64(Core::System& system, Handle debug_handle);
|
||||
Result GetDebugEvent64(Core::System& system, uint64_t out_info, Handle debug_handle);
|
||||
Result ContinueDebugEvent64(Core::System& system, Handle debug_handle, uint32_t flags, uint64_t thread_ids, int32_t num_thread_ids);
|
||||
Result GetProcessList64(Core::System& system, int32_t* out_num_processes, uint64_t out_process_ids, int32_t max_out_count);
|
||||
Result GetThreadList64(Core::System& system, int32_t* out_num_threads, uint64_t out_thread_ids, int32_t max_out_count, Handle debug_handle);
|
||||
Result GetDebugThreadContext64(Core::System& system, uint64_t out_context, Handle debug_handle, uint64_t thread_id, uint32_t context_flags);
|
||||
Result SetDebugThreadContext64(Core::System& system, Handle debug_handle, uint64_t thread_id, uint64_t context, uint32_t context_flags);
|
||||
Result QueryDebugProcessMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
|
||||
Result ReadDebugProcessMemory64(Core::System& system, uint64_t buffer, Handle debug_handle, uint64_t address, uint64_t size);
|
||||
Result WriteDebugProcessMemory64(Core::System& system, Handle debug_handle, uint64_t buffer, uint64_t address, uint64_t size);
|
||||
Result SetHardwareBreakPoint64(Core::System& system, HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value);
|
||||
Result GetDebugThreadParam64(Core::System& system, uint64_t* out_64, uint32_t* out_32, Handle debug_handle, uint64_t thread_id, DebugThreadParam param);
|
||||
Result GetSystemInfo64(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle, uint64_t info_subtype);
|
||||
Result CreatePort64(Core::System& system, Handle* out_server_handle, Handle* out_client_handle, int32_t max_sessions, bool is_light, uint64_t name);
|
||||
Result ManageNamedPort64(Core::System& system, Handle* out_server_handle, uint64_t name, int32_t max_sessions);
|
||||
Result ConnectToPort64(Core::System& system, Handle* out_handle, Handle port);
|
||||
Result SetProcessMemoryPermission64(Core::System& system, Handle process_handle, uint64_t address, uint64_t size, MemoryPermission perm);
|
||||
Result MapProcessMemory64(Core::System& system, uint64_t dst_address, Handle process_handle, uint64_t src_address, uint64_t size);
|
||||
Result UnmapProcessMemory64(Core::System& system, uint64_t dst_address, Handle process_handle, uint64_t src_address, uint64_t size);
|
||||
Result QueryProcessMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
|
||||
Result MapProcessCodeMemory64(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result UnmapProcessCodeMemory64(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
|
||||
Result CreateProcess64(Core::System& system, Handle* out_handle, uint64_t parameters, uint64_t caps, int32_t num_caps);
|
||||
Result StartProcess64(Core::System& system, Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size);
|
||||
Result TerminateProcess64(Core::System& system, Handle process_handle);
|
||||
Result GetProcessInfo64(Core::System& system, int64_t* out_info, Handle process_handle, ProcessInfoType info_type);
|
||||
Result CreateResourceLimit64(Core::System& system, Handle* out_handle);
|
||||
Result SetResourceLimitLimitValue64(Core::System& system, Handle resource_limit_handle, LimitableResource which, int64_t limit_value);
|
||||
Result MapInsecureMemory64(Core::System& system, uint64_t address, uint64_t size);
|
||||
Result UnmapInsecureMemory64(Core::System& system, uint64_t address, uint64_t size);
|
||||
|
||||
enum class SvcId : u32 {
|
||||
SetHeapSize = 0x1,
|
||||
SetMemoryPermission = 0x2,
|
||||
SetMemoryAttribute = 0x3,
|
||||
MapMemory = 0x4,
|
||||
UnmapMemory = 0x5,
|
||||
QueryMemory = 0x6,
|
||||
ExitProcess = 0x7,
|
||||
CreateThread = 0x8,
|
||||
StartThread = 0x9,
|
||||
ExitThread = 0xa,
|
||||
SleepThread = 0xb,
|
||||
GetThreadPriority = 0xc,
|
||||
SetThreadPriority = 0xd,
|
||||
GetThreadCoreMask = 0xe,
|
||||
SetThreadCoreMask = 0xf,
|
||||
GetCurrentProcessorNumber = 0x10,
|
||||
SignalEvent = 0x11,
|
||||
ClearEvent = 0x12,
|
||||
MapSharedMemory = 0x13,
|
||||
UnmapSharedMemory = 0x14,
|
||||
CreateTransferMemory = 0x15,
|
||||
CloseHandle = 0x16,
|
||||
ResetSignal = 0x17,
|
||||
WaitSynchronization = 0x18,
|
||||
CancelSynchronization = 0x19,
|
||||
ArbitrateLock = 0x1a,
|
||||
ArbitrateUnlock = 0x1b,
|
||||
WaitProcessWideKeyAtomic = 0x1c,
|
||||
SignalProcessWideKey = 0x1d,
|
||||
GetSystemTick = 0x1e,
|
||||
ConnectToNamedPort = 0x1f,
|
||||
SendSyncRequestLight = 0x20,
|
||||
SendSyncRequest = 0x21,
|
||||
SendSyncRequestWithUserBuffer = 0x22,
|
||||
SendAsyncRequestWithUserBuffer = 0x23,
|
||||
GetProcessId = 0x24,
|
||||
GetThreadId = 0x25,
|
||||
Break = 0x26,
|
||||
OutputDebugString = 0x27,
|
||||
ReturnFromException = 0x28,
|
||||
GetInfo = 0x29,
|
||||
FlushEntireDataCache = 0x2a,
|
||||
FlushDataCache = 0x2b,
|
||||
MapPhysicalMemory = 0x2c,
|
||||
UnmapPhysicalMemory = 0x2d,
|
||||
GetDebugFutureThreadInfo = 0x2e,
|
||||
GetLastThreadInfo = 0x2f,
|
||||
GetResourceLimitLimitValue = 0x30,
|
||||
GetResourceLimitCurrentValue = 0x31,
|
||||
SetThreadActivity = 0x32,
|
||||
GetThreadContext3 = 0x33,
|
||||
WaitForAddress = 0x34,
|
||||
SignalToAddress = 0x35,
|
||||
SynchronizePreemptionState = 0x36,
|
||||
GetResourceLimitPeakValue = 0x37,
|
||||
CreateIoPool = 0x39,
|
||||
CreateIoRegion = 0x3a,
|
||||
KernelDebug = 0x3c,
|
||||
ChangeKernelTraceState = 0x3d,
|
||||
CreateSession = 0x40,
|
||||
AcceptSession = 0x41,
|
||||
ReplyAndReceiveLight = 0x42,
|
||||
ReplyAndReceive = 0x43,
|
||||
ReplyAndReceiveWithUserBuffer = 0x44,
|
||||
CreateEvent = 0x45,
|
||||
MapIoRegion = 0x46,
|
||||
UnmapIoRegion = 0x47,
|
||||
MapPhysicalMemoryUnsafe = 0x48,
|
||||
UnmapPhysicalMemoryUnsafe = 0x49,
|
||||
SetUnsafeLimit = 0x4a,
|
||||
CreateCodeMemory = 0x4b,
|
||||
ControlCodeMemory = 0x4c,
|
||||
SleepSystem = 0x4d,
|
||||
ReadWriteRegister = 0x4e,
|
||||
SetProcessActivity = 0x4f,
|
||||
CreateSharedMemory = 0x50,
|
||||
MapTransferMemory = 0x51,
|
||||
UnmapTransferMemory = 0x52,
|
||||
CreateInterruptEvent = 0x53,
|
||||
QueryPhysicalAddress = 0x54,
|
||||
QueryIoMapping = 0x55,
|
||||
CreateDeviceAddressSpace = 0x56,
|
||||
AttachDeviceAddressSpace = 0x57,
|
||||
DetachDeviceAddressSpace = 0x58,
|
||||
MapDeviceAddressSpaceByForce = 0x59,
|
||||
MapDeviceAddressSpaceAligned = 0x5a,
|
||||
UnmapDeviceAddressSpace = 0x5c,
|
||||
InvalidateProcessDataCache = 0x5d,
|
||||
StoreProcessDataCache = 0x5e,
|
||||
FlushProcessDataCache = 0x5f,
|
||||
DebugActiveProcess = 0x60,
|
||||
BreakDebugProcess = 0x61,
|
||||
TerminateDebugProcess = 0x62,
|
||||
GetDebugEvent = 0x63,
|
||||
ContinueDebugEvent = 0x64,
|
||||
GetProcessList = 0x65,
|
||||
GetThreadList = 0x66,
|
||||
GetDebugThreadContext = 0x67,
|
||||
SetDebugThreadContext = 0x68,
|
||||
QueryDebugProcessMemory = 0x69,
|
||||
ReadDebugProcessMemory = 0x6a,
|
||||
WriteDebugProcessMemory = 0x6b,
|
||||
SetHardwareBreakPoint = 0x6c,
|
||||
GetDebugThreadParam = 0x6d,
|
||||
GetSystemInfo = 0x6f,
|
||||
CreatePort = 0x70,
|
||||
ManageNamedPort = 0x71,
|
||||
ConnectToPort = 0x72,
|
||||
SetProcessMemoryPermission = 0x73,
|
||||
MapProcessMemory = 0x74,
|
||||
UnmapProcessMemory = 0x75,
|
||||
QueryProcessMemory = 0x76,
|
||||
MapProcessCodeMemory = 0x77,
|
||||
UnmapProcessCodeMemory = 0x78,
|
||||
CreateProcess = 0x79,
|
||||
StartProcess = 0x7a,
|
||||
TerminateProcess = 0x7b,
|
||||
GetProcessInfo = 0x7c,
|
||||
CreateResourceLimit = 0x7d,
|
||||
SetResourceLimitLimitValue = 0x7e,
|
||||
CallSecureMonitor = 0x7f,
|
||||
MapInsecureMemory = 0x90,
|
||||
UnmapInsecureMemory = 0x91,
|
||||
};
|
||||
// clang-format on
|
||||
|
||||
// Custom ABI.
|
||||
Result ReplyAndReceiveLight(Core::System& system, Handle handle, uint32_t* args);
|
||||
Result ReplyAndReceiveLight64From32(Core::System& system, Handle handle, uint32_t* args);
|
||||
Result ReplyAndReceiveLight64(Core::System& system, Handle handle, uint32_t* args);
|
||||
|
||||
Result SendSyncRequestLight(Core::System& system, Handle session_handle, uint32_t* args);
|
||||
Result SendSyncRequestLight64From32(Core::System& system, Handle session_handle, uint32_t* args);
|
||||
Result SendSyncRequestLight64(Core::System& system, Handle session_handle, uint32_t* args);
|
||||
|
||||
void CallSecureMonitor(Core::System& system, lp64::SecureMonitorArguments* args);
|
||||
void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArguments* args);
|
||||
void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args);
|
||||
|
||||
// Defined in svc_light_ipc.cpp.
|
||||
void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system);
|
||||
void SvcWrap_ReplyAndReceiveLight64(Core::System& system);
|
||||
|
||||
void SvcWrap_SendSyncRequestLight64From32(Core::System& system);
|
||||
void SvcWrap_SendSyncRequestLight64(Core::System& system);
|
||||
|
||||
// Defined in svc_secure_monitor_call.cpp.
|
||||
void SvcWrap_CallSecureMonitor64From32(Core::System& system);
|
||||
void SvcWrap_CallSecureMonitor64(Core::System& system);
|
||||
|
||||
// Perform a supervisor call by index.
|
||||
void Call(Core::System& system, u32 imm);
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
|
|
|
|||
65
src/core/hle/kernel/svc/svc_activity.cpp
Executable file
65
src/core/hle/kernel/svc/svc_activity.cpp
Executable file
|
|
@ -0,0 +1,65 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_thread.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Sets the thread activity
|
||||
Result SetThreadActivity(Core::System& system, Handle thread_handle,
|
||||
ThreadActivity thread_activity) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, activity=0x{:08X}", thread_handle,
|
||||
thread_activity);
|
||||
|
||||
// Validate the activity.
|
||||
constexpr auto IsValidThreadActivity = [](ThreadActivity activity) {
|
||||
return activity == ThreadActivity::Runnable || activity == ThreadActivity::Paused;
|
||||
};
|
||||
R_UNLESS(IsValidThreadActivity(thread_activity), ResultInvalidEnumValue);
|
||||
|
||||
// Get the thread from its handle.
|
||||
KScopedAutoObject thread =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
|
||||
R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Check that the activity is being set on a non-current thread for the current process.
|
||||
R_UNLESS(thread->GetOwnerProcess() == system.Kernel().CurrentProcess(), ResultInvalidHandle);
|
||||
R_UNLESS(thread.GetPointerUnsafe() != GetCurrentThreadPointer(system.Kernel()), ResultBusy);
|
||||
|
||||
// Set the activity.
|
||||
R_TRY(thread->SetActivity(thread_activity));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result SetProcessActivity(Core::System& system, Handle process_handle,
|
||||
ProcessActivity process_activity) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result SetThreadActivity64(Core::System& system, Handle thread_handle,
|
||||
ThreadActivity thread_activity) {
|
||||
return SetThreadActivity(system, thread_handle, thread_activity);
|
||||
}
|
||||
|
||||
Result SetProcessActivity64(Core::System& system, Handle process_handle,
|
||||
ProcessActivity process_activity) {
|
||||
return SetProcessActivity(system, process_handle, process_activity);
|
||||
}
|
||||
|
||||
Result SetThreadActivity64From32(Core::System& system, Handle thread_handle,
|
||||
ThreadActivity thread_activity) {
|
||||
return SetThreadActivity(system, thread_handle, thread_activity);
|
||||
}
|
||||
|
||||
Result SetProcessActivity64From32(Core::System& system, Handle process_handle,
|
||||
ProcessActivity process_activity) {
|
||||
return SetProcessActivity(system, process_handle, process_activity);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
122
src/core/hle/kernel/svc/svc_address_arbiter.cpp
Executable file
122
src/core/hle/kernel/svc/svc_address_arbiter.cpp
Executable file
|
|
@ -0,0 +1,122 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_memory_layout.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/kernel.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
#include "core/hle/kernel/svc_types.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
namespace {
|
||||
|
||||
constexpr bool IsValidSignalType(Svc::SignalType type) {
|
||||
switch (type) {
|
||||
case Svc::SignalType::Signal:
|
||||
case Svc::SignalType::SignalAndIncrementIfEqual:
|
||||
case Svc::SignalType::SignalAndModifyByWaitingCountIfEqual:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
constexpr bool IsValidArbitrationType(Svc::ArbitrationType type) {
|
||||
switch (type) {
|
||||
case Svc::ArbitrationType::WaitIfLessThan:
|
||||
case Svc::ArbitrationType::DecrementAndWaitIfLessThan:
|
||||
case Svc::ArbitrationType::WaitIfEqual:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// Wait for an address (via Address Arbiter)
|
||||
Result WaitForAddress(Core::System& system, VAddr address, ArbitrationType arb_type, s32 value,
|
||||
s64 timeout_ns) {
|
||||
LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, arb_type=0x{:X}, value=0x{:X}, timeout_ns={}",
|
||||
address, arb_type, value, timeout_ns);
|
||||
|
||||
// Validate input.
|
||||
if (IsKernelAddress(address)) {
|
||||
LOG_ERROR(Kernel_SVC, "Attempting to wait on kernel address (address={:08X})", address);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
if (!Common::IsAligned(address, sizeof(s32))) {
|
||||
LOG_ERROR(Kernel_SVC, "Wait address must be 4 byte aligned (address={:08X})", address);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
if (!IsValidArbitrationType(arb_type)) {
|
||||
LOG_ERROR(Kernel_SVC, "Invalid arbitration type specified (type={})", arb_type);
|
||||
return ResultInvalidEnumValue;
|
||||
}
|
||||
|
||||
// Convert timeout from nanoseconds to ticks.
|
||||
s64 timeout{};
|
||||
if (timeout_ns > 0) {
|
||||
const s64 offset_tick(timeout_ns);
|
||||
if (offset_tick > 0) {
|
||||
timeout = offset_tick + 2;
|
||||
if (timeout <= 0) {
|
||||
timeout = std::numeric_limits<s64>::max();
|
||||
}
|
||||
} else {
|
||||
timeout = std::numeric_limits<s64>::max();
|
||||
}
|
||||
} else {
|
||||
timeout = timeout_ns;
|
||||
}
|
||||
|
||||
return system.Kernel().CurrentProcess()->WaitAddressArbiter(address, arb_type, value, timeout);
|
||||
}
|
||||
|
||||
// Signals to an address (via Address Arbiter)
|
||||
Result SignalToAddress(Core::System& system, VAddr address, SignalType signal_type, s32 value,
|
||||
s32 count) {
|
||||
LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, signal_type=0x{:X}, value=0x{:X}, count=0x{:X}",
|
||||
address, signal_type, value, count);
|
||||
|
||||
// Validate input.
|
||||
if (IsKernelAddress(address)) {
|
||||
LOG_ERROR(Kernel_SVC, "Attempting to signal to a kernel address (address={:08X})", address);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
if (!Common::IsAligned(address, sizeof(s32))) {
|
||||
LOG_ERROR(Kernel_SVC, "Signaled address must be 4 byte aligned (address={:08X})", address);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
if (!IsValidSignalType(signal_type)) {
|
||||
LOG_ERROR(Kernel_SVC, "Invalid signal type specified (type={})", signal_type);
|
||||
return ResultInvalidEnumValue;
|
||||
}
|
||||
|
||||
return system.Kernel().CurrentProcess()->SignalAddressArbiter(address, signal_type, value,
|
||||
count);
|
||||
}
|
||||
|
||||
Result WaitForAddress64(Core::System& system, VAddr address, ArbitrationType arb_type, s32 value,
|
||||
s64 timeout_ns) {
|
||||
return WaitForAddress(system, address, arb_type, value, timeout_ns);
|
||||
}
|
||||
|
||||
Result SignalToAddress64(Core::System& system, VAddr address, SignalType signal_type, s32 value,
|
||||
s32 count) {
|
||||
return SignalToAddress(system, address, signal_type, value, count);
|
||||
}
|
||||
|
||||
Result WaitForAddress64From32(Core::System& system, u32 address, ArbitrationType arb_type,
|
||||
s32 value, s64 timeout_ns) {
|
||||
return WaitForAddress(system, address, arb_type, value, timeout_ns);
|
||||
}
|
||||
|
||||
Result SignalToAddress64From32(Core::System& system, u32 address, SignalType signal_type, s32 value,
|
||||
s32 count) {
|
||||
return SignalToAddress(system, address, signal_type, value, count);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
50
src/core/hle/kernel/svc/svc_address_translation.cpp
Executable file
50
src/core/hle/kernel/svc/svc_address_translation.cpp
Executable file
|
|
@ -0,0 +1,50 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result QueryPhysicalAddress(Core::System& system, lp64::PhysicalMemoryInfo* out_info,
|
||||
uint64_t address) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result QueryIoMapping(Core::System& system, uintptr_t* out_address, uintptr_t* out_size,
|
||||
uint64_t physical_address, uint64_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result QueryPhysicalAddress64(Core::System& system, lp64::PhysicalMemoryInfo* out_info,
|
||||
uint64_t address) {
|
||||
R_RETURN(QueryPhysicalAddress(system, out_info, address));
|
||||
}
|
||||
|
||||
Result QueryIoMapping64(Core::System& system, uintptr_t* out_address, uintptr_t* out_size,
|
||||
uint64_t physical_address, uint64_t size) {
|
||||
R_RETURN(QueryIoMapping(system, out_address, out_size, physical_address, size));
|
||||
}
|
||||
|
||||
Result QueryPhysicalAddress64From32(Core::System& system, ilp32::PhysicalMemoryInfo* out_info,
|
||||
uint32_t address) {
|
||||
lp64::PhysicalMemoryInfo info{};
|
||||
R_TRY(QueryPhysicalAddress(system, std::addressof(info), address));
|
||||
|
||||
*out_info = {
|
||||
.physical_address = info.physical_address,
|
||||
.virtual_address = static_cast<u32>(info.virtual_address),
|
||||
.size = static_cast<u32>(info.size),
|
||||
};
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result QueryIoMapping64From32(Core::System& system, uintptr_t* out_address, uintptr_t* out_size,
|
||||
uint64_t physical_address, uint32_t size) {
|
||||
R_RETURN(QueryIoMapping(system, reinterpret_cast<uintptr_t*>(out_address),
|
||||
reinterpret_cast<uintptr_t*>(out_size), physical_address, size));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
98
src/core/hle/kernel/svc/svc_cache.cpp
Executable file
98
src/core/hle/kernel/svc/svc_cache.cpp
Executable file
|
|
@ -0,0 +1,98 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
#include "core/hle/kernel/svc_types.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
void FlushEntireDataCache(Core::System& system) {
|
||||
UNIMPLEMENTED();
|
||||
}
|
||||
|
||||
Result FlushDataCache(Core::System& system, VAddr address, size_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result InvalidateProcessDataCache(Core::System& system, Handle process_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result StoreProcessDataCache(Core::System& system, Handle process_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result FlushProcessDataCache(Core::System& system, Handle process_handle, u64 address, u64 size) {
|
||||
// Validate address/size.
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS(address == static_cast<uintptr_t>(address), ResultInvalidCurrentMemory);
|
||||
R_UNLESS(size == static_cast<size_t>(size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Get the process from its handle.
|
||||
KScopedAutoObject process =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
|
||||
R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Verify the region is within range.
|
||||
auto& page_table = process->PageTable();
|
||||
R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Perform the operation.
|
||||
R_RETURN(system.Memory().FlushDataCache(*process, address, size));
|
||||
}
|
||||
|
||||
void FlushEntireDataCache64(Core::System& system) {
|
||||
FlushEntireDataCache(system);
|
||||
}
|
||||
|
||||
Result FlushDataCache64(Core::System& system, VAddr address, size_t size) {
|
||||
R_RETURN(FlushDataCache(system, address, size));
|
||||
}
|
||||
|
||||
Result InvalidateProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
R_RETURN(InvalidateProcessDataCache(system, process_handle, address, size));
|
||||
}
|
||||
|
||||
Result StoreProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
R_RETURN(StoreProcessDataCache(system, process_handle, address, size));
|
||||
}
|
||||
|
||||
Result FlushProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
R_RETURN(FlushProcessDataCache(system, process_handle, address, size));
|
||||
}
|
||||
|
||||
void FlushEntireDataCache64From32(Core::System& system) {
|
||||
return FlushEntireDataCache(system);
|
||||
}
|
||||
|
||||
Result FlushDataCache64From32(Core::System& system, uint32_t address, uint32_t size) {
|
||||
R_RETURN(FlushDataCache(system, address, size));
|
||||
}
|
||||
|
||||
Result InvalidateProcessDataCache64From32(Core::System& system, Handle process_handle,
|
||||
uint64_t address, uint64_t size) {
|
||||
R_RETURN(InvalidateProcessDataCache(system, process_handle, address, size));
|
||||
}
|
||||
|
||||
Result StoreProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
R_RETURN(StoreProcessDataCache(system, process_handle, address, size));
|
||||
}
|
||||
|
||||
Result FlushProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
R_RETURN(FlushProcessDataCache(system, process_handle, address, size));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
168
src/core/hle/kernel/svc/svc_code_memory.cpp
Executable file
168
src/core/hle/kernel/svc/svc_code_memory.cpp
Executable file
|
|
@ -0,0 +1,168 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_code_memory.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/kernel.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
namespace {
|
||||
|
||||
constexpr bool IsValidMapCodeMemoryPermission(MemoryPermission perm) {
|
||||
return perm == MemoryPermission::ReadWrite;
|
||||
}
|
||||
|
||||
constexpr bool IsValidMapToOwnerCodeMemoryPermission(MemoryPermission perm) {
|
||||
return perm == MemoryPermission::Read || perm == MemoryPermission::ReadExecute;
|
||||
}
|
||||
|
||||
constexpr bool IsValidUnmapCodeMemoryPermission(MemoryPermission perm) {
|
||||
return perm == MemoryPermission::None;
|
||||
}
|
||||
|
||||
constexpr bool IsValidUnmapFromOwnerCodeMemoryPermission(MemoryPermission perm) {
|
||||
return perm == MemoryPermission::None;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
Result CreateCodeMemory(Core::System& system, Handle* out, VAddr address, size_t size) {
|
||||
LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, size=0x{:X}", address, size);
|
||||
|
||||
// Get kernel instance.
|
||||
auto& kernel = system.Kernel();
|
||||
|
||||
// Validate address / size.
|
||||
R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Create the code memory.
|
||||
|
||||
KCodeMemory* code_mem = KCodeMemory::Create(kernel);
|
||||
R_UNLESS(code_mem != nullptr, ResultOutOfResource);
|
||||
|
||||
// Verify that the region is in range.
|
||||
R_UNLESS(system.CurrentProcess()->PageTable().Contains(address, size),
|
||||
ResultInvalidCurrentMemory);
|
||||
|
||||
// Initialize the code memory.
|
||||
R_TRY(code_mem->Initialize(system.DeviceMemory(), address, size));
|
||||
|
||||
// Register the code memory.
|
||||
KCodeMemory::Register(kernel, code_mem);
|
||||
|
||||
// Add the code memory to the handle table.
|
||||
R_TRY(system.CurrentProcess()->GetHandleTable().Add(out, code_mem));
|
||||
|
||||
code_mem->Close();
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result ControlCodeMemory(Core::System& system, Handle code_memory_handle,
|
||||
CodeMemoryOperation operation, VAddr address, size_t size,
|
||||
MemoryPermission perm) {
|
||||
|
||||
LOG_TRACE(Kernel_SVC,
|
||||
"called, code_memory_handle=0x{:X}, operation=0x{:X}, address=0x{:X}, size=0x{:X}, "
|
||||
"permission=0x{:X}",
|
||||
code_memory_handle, operation, address, size, perm);
|
||||
|
||||
// Validate the address / size.
|
||||
R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Get the code memory from its handle.
|
||||
KScopedAutoObject code_mem =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KCodeMemory>(code_memory_handle);
|
||||
R_UNLESS(code_mem.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// NOTE: Here, Atmosphere extends the SVC to allow code memory operations on one's own process.
|
||||
// This enables homebrew usage of these SVCs for JIT.
|
||||
|
||||
// Perform the operation.
|
||||
switch (operation) {
|
||||
case CodeMemoryOperation::Map: {
|
||||
// Check that the region is in range.
|
||||
R_UNLESS(
|
||||
system.CurrentProcess()->PageTable().CanContain(address, size, KMemoryState::CodeOut),
|
||||
ResultInvalidMemoryRegion);
|
||||
|
||||
// Check the memory permission.
|
||||
R_UNLESS(IsValidMapCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
|
||||
|
||||
// Map the memory.
|
||||
R_TRY(code_mem->Map(address, size));
|
||||
} break;
|
||||
case CodeMemoryOperation::Unmap: {
|
||||
// Check that the region is in range.
|
||||
R_UNLESS(
|
||||
system.CurrentProcess()->PageTable().CanContain(address, size, KMemoryState::CodeOut),
|
||||
ResultInvalidMemoryRegion);
|
||||
|
||||
// Check the memory permission.
|
||||
R_UNLESS(IsValidUnmapCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
|
||||
|
||||
// Unmap the memory.
|
||||
R_TRY(code_mem->Unmap(address, size));
|
||||
} break;
|
||||
case CodeMemoryOperation::MapToOwner: {
|
||||
// Check that the region is in range.
|
||||
R_UNLESS(code_mem->GetOwner()->PageTable().CanContain(address, size,
|
||||
KMemoryState::GeneratedCode),
|
||||
ResultInvalidMemoryRegion);
|
||||
|
||||
// Check the memory permission.
|
||||
R_UNLESS(IsValidMapToOwnerCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
|
||||
|
||||
// Map the memory to its owner.
|
||||
R_TRY(code_mem->MapToOwner(address, size, perm));
|
||||
} break;
|
||||
case CodeMemoryOperation::UnmapFromOwner: {
|
||||
// Check that the region is in range.
|
||||
R_UNLESS(code_mem->GetOwner()->PageTable().CanContain(address, size,
|
||||
KMemoryState::GeneratedCode),
|
||||
ResultInvalidMemoryRegion);
|
||||
|
||||
// Check the memory permission.
|
||||
R_UNLESS(IsValidUnmapFromOwnerCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
|
||||
|
||||
// Unmap the memory from its owner.
|
||||
R_TRY(code_mem->UnmapFromOwner(address, size));
|
||||
} break;
|
||||
default:
|
||||
return ResultInvalidEnumValue;
|
||||
}
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result CreateCodeMemory64(Core::System& system, Handle* out_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
R_RETURN(CreateCodeMemory(system, out_handle, address, size));
|
||||
}
|
||||
|
||||
Result ControlCodeMemory64(Core::System& system, Handle code_memory_handle,
|
||||
CodeMemoryOperation operation, uint64_t address, uint64_t size,
|
||||
MemoryPermission perm) {
|
||||
R_RETURN(ControlCodeMemory(system, code_memory_handle, operation, address, size, perm));
|
||||
}
|
||||
|
||||
Result CreateCodeMemory64From32(Core::System& system, Handle* out_handle, uint32_t address,
|
||||
uint32_t size) {
|
||||
R_RETURN(CreateCodeMemory(system, out_handle, address, size));
|
||||
}
|
||||
|
||||
Result ControlCodeMemory64From32(Core::System& system, Handle code_memory_handle,
|
||||
CodeMemoryOperation operation, uint64_t address, uint64_t size,
|
||||
MemoryPermission perm) {
|
||||
R_RETURN(ControlCodeMemory(system, code_memory_handle, operation, address, size, perm));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
77
src/core/hle/kernel/svc/svc_condition_variable.cpp
Executable file
77
src/core/hle/kernel/svc/svc_condition_variable.cpp
Executable file
|
|
@ -0,0 +1,77 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_memory_layout.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/kernel.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Wait process wide key atomic
|
||||
Result WaitProcessWideKeyAtomic(Core::System& system, VAddr address, VAddr cv_key, u32 tag,
|
||||
s64 timeout_ns) {
|
||||
LOG_TRACE(Kernel_SVC, "called address={:X}, cv_key={:X}, tag=0x{:08X}, timeout_ns={}", address,
|
||||
cv_key, tag, timeout_ns);
|
||||
|
||||
// Validate input.
|
||||
if (IsKernelAddress(address)) {
|
||||
LOG_ERROR(Kernel_SVC, "Attempted to wait on kernel address (address={:08X})", address);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
if (!Common::IsAligned(address, sizeof(s32))) {
|
||||
LOG_ERROR(Kernel_SVC, "Address must be 4 byte aligned (address={:08X})", address);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
// Convert timeout from nanoseconds to ticks.
|
||||
s64 timeout{};
|
||||
if (timeout_ns > 0) {
|
||||
const s64 offset_tick(timeout_ns);
|
||||
if (offset_tick > 0) {
|
||||
timeout = offset_tick + 2;
|
||||
if (timeout <= 0) {
|
||||
timeout = std::numeric_limits<s64>::max();
|
||||
}
|
||||
} else {
|
||||
timeout = std::numeric_limits<s64>::max();
|
||||
}
|
||||
} else {
|
||||
timeout = timeout_ns;
|
||||
}
|
||||
|
||||
// Wait on the condition variable.
|
||||
return system.Kernel().CurrentProcess()->WaitConditionVariable(
|
||||
address, Common::AlignDown(cv_key, sizeof(u32)), tag, timeout);
|
||||
}
|
||||
|
||||
/// Signal process wide key
|
||||
void SignalProcessWideKey(Core::System& system, VAddr cv_key, s32 count) {
|
||||
LOG_TRACE(Kernel_SVC, "called, cv_key=0x{:X}, count=0x{:08X}", cv_key, count);
|
||||
|
||||
// Signal the condition variable.
|
||||
return system.Kernel().CurrentProcess()->SignalConditionVariable(
|
||||
Common::AlignDown(cv_key, sizeof(u32)), count);
|
||||
}
|
||||
|
||||
Result WaitProcessWideKeyAtomic64(Core::System& system, uint64_t address, uint64_t cv_key,
|
||||
uint32_t tag, int64_t timeout_ns) {
|
||||
R_RETURN(WaitProcessWideKeyAtomic(system, address, cv_key, tag, timeout_ns));
|
||||
}
|
||||
|
||||
void SignalProcessWideKey64(Core::System& system, uint64_t cv_key, int32_t count) {
|
||||
SignalProcessWideKey(system, cv_key, count);
|
||||
}
|
||||
|
||||
Result WaitProcessWideKeyAtomic64From32(Core::System& system, uint32_t address, uint32_t cv_key,
|
||||
uint32_t tag, int64_t timeout_ns) {
|
||||
R_RETURN(WaitProcessWideKeyAtomic(system, address, cv_key, tag, timeout_ns));
|
||||
}
|
||||
|
||||
void SignalProcessWideKey64From32(Core::System& system, uint32_t cv_key, int32_t count) {
|
||||
SignalProcessWideKey(system, cv_key, count);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
194
src/core/hle/kernel/svc/svc_debug.cpp
Executable file
194
src/core/hle/kernel/svc/svc_debug.cpp
Executable file
|
|
@ -0,0 +1,194 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result DebugActiveProcess(Core::System& system, Handle* out_handle, uint64_t process_id) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result BreakDebugProcess(Core::System& system, Handle debug_handle) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result TerminateDebugProcess(Core::System& system, Handle debug_handle) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result GetDebugEvent(Core::System& system, uint64_t out_info, Handle debug_handle) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result ContinueDebugEvent(Core::System& system, Handle debug_handle, uint32_t flags,
|
||||
uint64_t user_thread_ids, int32_t num_thread_ids) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result GetDebugThreadContext(Core::System& system, uint64_t out_context, Handle debug_handle,
|
||||
uint64_t thread_id, uint32_t context_flags) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result SetDebugThreadContext(Core::System& system, Handle debug_handle, uint64_t thread_id,
|
||||
uint64_t user_context, uint32_t context_flags) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result QueryDebugProcessMemory(Core::System& system, uint64_t out_memory_info,
|
||||
PageInfo* out_page_info, Handle debug_handle, uintptr_t address) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result ReadDebugProcessMemory(Core::System& system, uintptr_t buffer, Handle debug_handle,
|
||||
uintptr_t address, size_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result WriteDebugProcessMemory(Core::System& system, Handle debug_handle, uintptr_t buffer,
|
||||
uintptr_t address, size_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result SetHardwareBreakPoint(Core::System& system, HardwareBreakPointRegisterName name,
|
||||
uint64_t flags, uint64_t value) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result GetDebugThreadParam(Core::System& system, uint64_t* out_64, uint32_t* out_32,
|
||||
Handle debug_handle, uint64_t thread_id, DebugThreadParam param) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result DebugActiveProcess64(Core::System& system, Handle* out_handle, uint64_t process_id) {
|
||||
R_RETURN(DebugActiveProcess(system, out_handle, process_id));
|
||||
}
|
||||
|
||||
Result BreakDebugProcess64(Core::System& system, Handle debug_handle) {
|
||||
R_RETURN(BreakDebugProcess(system, debug_handle));
|
||||
}
|
||||
|
||||
Result TerminateDebugProcess64(Core::System& system, Handle debug_handle) {
|
||||
R_RETURN(TerminateDebugProcess(system, debug_handle));
|
||||
}
|
||||
|
||||
Result GetDebugEvent64(Core::System& system, uint64_t out_info, Handle debug_handle) {
|
||||
R_RETURN(GetDebugEvent(system, out_info, debug_handle));
|
||||
}
|
||||
|
||||
Result ContinueDebugEvent64(Core::System& system, Handle debug_handle, uint32_t flags,
|
||||
uint64_t thread_ids, int32_t num_thread_ids) {
|
||||
R_RETURN(ContinueDebugEvent(system, debug_handle, flags, thread_ids, num_thread_ids));
|
||||
}
|
||||
|
||||
Result GetDebugThreadContext64(Core::System& system, uint64_t out_context, Handle debug_handle,
|
||||
uint64_t thread_id, uint32_t context_flags) {
|
||||
R_RETURN(GetDebugThreadContext(system, out_context, debug_handle, thread_id, context_flags));
|
||||
}
|
||||
|
||||
Result SetDebugThreadContext64(Core::System& system, Handle debug_handle, uint64_t thread_id,
|
||||
uint64_t context, uint32_t context_flags) {
|
||||
R_RETURN(SetDebugThreadContext(system, debug_handle, thread_id, context, context_flags));
|
||||
}
|
||||
|
||||
Result QueryDebugProcessMemory64(Core::System& system, uint64_t out_memory_info,
|
||||
PageInfo* out_page_info, Handle debug_handle, uint64_t address) {
|
||||
R_RETURN(
|
||||
QueryDebugProcessMemory(system, out_memory_info, out_page_info, debug_handle, address));
|
||||
}
|
||||
|
||||
Result ReadDebugProcessMemory64(Core::System& system, uint64_t buffer, Handle debug_handle,
|
||||
uint64_t address, uint64_t size) {
|
||||
R_RETURN(ReadDebugProcessMemory(system, buffer, debug_handle, address, size));
|
||||
}
|
||||
|
||||
Result WriteDebugProcessMemory64(Core::System& system, Handle debug_handle, uint64_t buffer,
|
||||
uint64_t address, uint64_t size) {
|
||||
R_RETURN(WriteDebugProcessMemory(system, debug_handle, buffer, address, size));
|
||||
}
|
||||
|
||||
Result SetHardwareBreakPoint64(Core::System& system, HardwareBreakPointRegisterName name,
|
||||
uint64_t flags, uint64_t value) {
|
||||
R_RETURN(SetHardwareBreakPoint(system, name, flags, value));
|
||||
}
|
||||
|
||||
Result GetDebugThreadParam64(Core::System& system, uint64_t* out_64, uint32_t* out_32,
|
||||
Handle debug_handle, uint64_t thread_id, DebugThreadParam param) {
|
||||
R_RETURN(GetDebugThreadParam(system, out_64, out_32, debug_handle, thread_id, param));
|
||||
}
|
||||
|
||||
Result DebugActiveProcess64From32(Core::System& system, Handle* out_handle, uint64_t process_id) {
|
||||
R_RETURN(DebugActiveProcess(system, out_handle, process_id));
|
||||
}
|
||||
|
||||
Result BreakDebugProcess64From32(Core::System& system, Handle debug_handle) {
|
||||
R_RETURN(BreakDebugProcess(system, debug_handle));
|
||||
}
|
||||
|
||||
Result TerminateDebugProcess64From32(Core::System& system, Handle debug_handle) {
|
||||
R_RETURN(TerminateDebugProcess(system, debug_handle));
|
||||
}
|
||||
|
||||
Result GetDebugEvent64From32(Core::System& system, uint32_t out_info, Handle debug_handle) {
|
||||
R_RETURN(GetDebugEvent(system, out_info, debug_handle));
|
||||
}
|
||||
|
||||
Result ContinueDebugEvent64From32(Core::System& system, Handle debug_handle, uint32_t flags,
|
||||
uint32_t thread_ids, int32_t num_thread_ids) {
|
||||
R_RETURN(ContinueDebugEvent(system, debug_handle, flags, thread_ids, num_thread_ids));
|
||||
}
|
||||
|
||||
Result GetDebugThreadContext64From32(Core::System& system, uint32_t out_context,
|
||||
Handle debug_handle, uint64_t thread_id,
|
||||
uint32_t context_flags) {
|
||||
R_RETURN(GetDebugThreadContext(system, out_context, debug_handle, thread_id, context_flags));
|
||||
}
|
||||
|
||||
Result SetDebugThreadContext64From32(Core::System& system, Handle debug_handle, uint64_t thread_id,
|
||||
uint32_t context, uint32_t context_flags) {
|
||||
R_RETURN(SetDebugThreadContext(system, debug_handle, thread_id, context, context_flags));
|
||||
}
|
||||
|
||||
Result QueryDebugProcessMemory64From32(Core::System& system, uint32_t out_memory_info,
|
||||
PageInfo* out_page_info, Handle debug_handle,
|
||||
uint32_t address) {
|
||||
R_RETURN(
|
||||
QueryDebugProcessMemory(system, out_memory_info, out_page_info, debug_handle, address));
|
||||
}
|
||||
|
||||
Result ReadDebugProcessMemory64From32(Core::System& system, uint32_t buffer, Handle debug_handle,
|
||||
uint32_t address, uint32_t size) {
|
||||
R_RETURN(ReadDebugProcessMemory(system, buffer, debug_handle, address, size));
|
||||
}
|
||||
|
||||
Result WriteDebugProcessMemory64From32(Core::System& system, Handle debug_handle, uint32_t buffer,
|
||||
uint32_t address, uint32_t size) {
|
||||
R_RETURN(WriteDebugProcessMemory(system, debug_handle, buffer, address, size));
|
||||
}
|
||||
|
||||
Result SetHardwareBreakPoint64From32(Core::System& system, HardwareBreakPointRegisterName name,
|
||||
uint64_t flags, uint64_t value) {
|
||||
R_RETURN(SetHardwareBreakPoint(system, name, flags, value));
|
||||
}
|
||||
|
||||
Result GetDebugThreadParam64From32(Core::System& system, uint64_t* out_64, uint32_t* out_32,
|
||||
Handle debug_handle, uint64_t thread_id,
|
||||
DebugThreadParam param) {
|
||||
R_RETURN(GetDebugThreadParam(system, out_64, out_32, debug_handle, thread_id, param));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
29
src/core/hle/kernel/svc/svc_debug_string.cpp
Executable file
29
src/core/hle/kernel/svc/svc_debug_string.cpp
Executable file
|
|
@ -0,0 +1,29 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/memory.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Used to output a message on a debug hardware unit - does nothing on a retail unit
|
||||
Result OutputDebugString(Core::System& system, VAddr address, u64 len) {
|
||||
R_SUCCEED_IF(len == 0);
|
||||
|
||||
std::string str(len, '\0');
|
||||
system.Memory().ReadBlock(address, str.data(), str.size());
|
||||
LOG_DEBUG(Debug_Emulated, "{}", str);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result OutputDebugString64(Core::System& system, uint64_t debug_str, uint64_t len) {
|
||||
R_RETURN(OutputDebugString(system, debug_str, len));
|
||||
}
|
||||
|
||||
Result OutputDebugString64From32(Core::System& system, uint32_t debug_str, uint32_t len) {
|
||||
R_RETURN(OutputDebugString(system, debug_str, len));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
253
src/core/hle/kernel/svc/svc_device_address_space.cpp
Executable file
253
src/core/hle/kernel/svc/svc_device_address_space.cpp
Executable file
|
|
@ -0,0 +1,253 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/alignment.h"
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_device_address_space.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
constexpr inline u64 DeviceAddressSpaceAlignMask = (1ULL << 22) - 1;
|
||||
|
||||
constexpr bool IsProcessAndDeviceAligned(uint64_t process_address, uint64_t device_address) {
|
||||
return (process_address & DeviceAddressSpaceAlignMask) ==
|
||||
(device_address & DeviceAddressSpaceAlignMask);
|
||||
}
|
||||
|
||||
Result CreateDeviceAddressSpace(Core::System& system, Handle* out, uint64_t das_address,
|
||||
uint64_t das_size) {
|
||||
// Validate input.
|
||||
R_UNLESS(Common::IsAligned(das_address, PageSize), ResultInvalidMemoryRegion);
|
||||
R_UNLESS(Common::IsAligned(das_size, PageSize), ResultInvalidMemoryRegion);
|
||||
R_UNLESS(das_size > 0, ResultInvalidMemoryRegion);
|
||||
R_UNLESS((das_address < das_address + das_size), ResultInvalidMemoryRegion);
|
||||
|
||||
// Create the device address space.
|
||||
KDeviceAddressSpace* das = KDeviceAddressSpace::Create(system.Kernel());
|
||||
R_UNLESS(das != nullptr, ResultOutOfResource);
|
||||
SCOPE_EXIT({ das->Close(); });
|
||||
|
||||
// Initialize the device address space.
|
||||
R_TRY(das->Initialize(das_address, das_size));
|
||||
|
||||
// Register the device address space.
|
||||
KDeviceAddressSpace::Register(system.Kernel(), das);
|
||||
|
||||
// Add to the handle table.
|
||||
R_TRY(system.CurrentProcess()->GetHandleTable().Add(out, das));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result AttachDeviceAddressSpace(Core::System& system, DeviceName device_name, Handle das_handle) {
|
||||
// Get the device address space.
|
||||
KScopedAutoObject das =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KDeviceAddressSpace>(das_handle);
|
||||
R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Attach.
|
||||
R_RETURN(das->Attach(device_name));
|
||||
}
|
||||
|
||||
Result DetachDeviceAddressSpace(Core::System& system, DeviceName device_name, Handle das_handle) {
|
||||
// Get the device address space.
|
||||
KScopedAutoObject das =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KDeviceAddressSpace>(das_handle);
|
||||
R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Detach.
|
||||
R_RETURN(das->Detach(device_name));
|
||||
}
|
||||
|
||||
constexpr bool IsValidDeviceMemoryPermission(MemoryPermission device_perm) {
|
||||
switch (device_perm) {
|
||||
case MemoryPermission::Read:
|
||||
case MemoryPermission::Write:
|
||||
case MemoryPermission::ReadWrite:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
Result MapDeviceAddressSpaceByForce(Core::System& system, Handle das_handle, Handle process_handle,
|
||||
uint64_t process_address, size_t size, uint64_t device_address,
|
||||
u32 option) {
|
||||
// Decode the option.
|
||||
const MapDeviceAddressSpaceOption option_pack{option};
|
||||
const auto device_perm = option_pack.permission;
|
||||
const auto reserved = option_pack.reserved;
|
||||
|
||||
// Validate input.
|
||||
R_UNLESS(Common::IsAligned(process_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(device_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((process_address < process_address + size), ResultInvalidCurrentMemory);
|
||||
R_UNLESS((device_address < device_address + size), ResultInvalidMemoryRegion);
|
||||
R_UNLESS((process_address == static_cast<uintptr_t>(process_address)),
|
||||
ResultInvalidCurrentMemory);
|
||||
R_UNLESS(IsValidDeviceMemoryPermission(device_perm), ResultInvalidNewMemoryPermission);
|
||||
R_UNLESS(reserved == 0, ResultInvalidEnumValue);
|
||||
|
||||
// Get the device address space.
|
||||
KScopedAutoObject das =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KDeviceAddressSpace>(das_handle);
|
||||
R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the process.
|
||||
KScopedAutoObject process =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
|
||||
R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Validate that the process address is within range.
|
||||
auto& page_table = process->PageTable();
|
||||
R_UNLESS(page_table.Contains(process_address, size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Map.
|
||||
R_RETURN(
|
||||
das->MapByForce(std::addressof(page_table), process_address, size, device_address, option));
|
||||
}
|
||||
|
||||
Result MapDeviceAddressSpaceAligned(Core::System& system, Handle das_handle, Handle process_handle,
|
||||
uint64_t process_address, size_t size, uint64_t device_address,
|
||||
u32 option) {
|
||||
// Decode the option.
|
||||
const MapDeviceAddressSpaceOption option_pack{option};
|
||||
const auto device_perm = option_pack.permission;
|
||||
const auto reserved = option_pack.reserved;
|
||||
|
||||
// Validate input.
|
||||
R_UNLESS(Common::IsAligned(process_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(device_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(IsProcessAndDeviceAligned(process_address, device_address), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((process_address < process_address + size), ResultInvalidCurrentMemory);
|
||||
R_UNLESS((device_address < device_address + size), ResultInvalidMemoryRegion);
|
||||
R_UNLESS((process_address == static_cast<uintptr_t>(process_address)),
|
||||
ResultInvalidCurrentMemory);
|
||||
R_UNLESS(IsValidDeviceMemoryPermission(device_perm), ResultInvalidNewMemoryPermission);
|
||||
R_UNLESS(reserved == 0, ResultInvalidEnumValue);
|
||||
|
||||
// Get the device address space.
|
||||
KScopedAutoObject das =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KDeviceAddressSpace>(das_handle);
|
||||
R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the process.
|
||||
KScopedAutoObject process =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
|
||||
R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Validate that the process address is within range.
|
||||
auto& page_table = process->PageTable();
|
||||
R_UNLESS(page_table.Contains(process_address, size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Map.
|
||||
R_RETURN(
|
||||
das->MapAligned(std::addressof(page_table), process_address, size, device_address, option));
|
||||
}
|
||||
|
||||
Result UnmapDeviceAddressSpace(Core::System& system, Handle das_handle, Handle process_handle,
|
||||
uint64_t process_address, size_t size, uint64_t device_address) {
|
||||
// Validate input.
|
||||
R_UNLESS(Common::IsAligned(process_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(device_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((process_address < process_address + size), ResultInvalidCurrentMemory);
|
||||
R_UNLESS((device_address < device_address + size), ResultInvalidMemoryRegion);
|
||||
R_UNLESS((process_address == static_cast<uintptr_t>(process_address)),
|
||||
ResultInvalidCurrentMemory);
|
||||
|
||||
// Get the device address space.
|
||||
KScopedAutoObject das =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KDeviceAddressSpace>(das_handle);
|
||||
R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the process.
|
||||
KScopedAutoObject process =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
|
||||
R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Validate that the process address is within range.
|
||||
auto& page_table = process->PageTable();
|
||||
R_UNLESS(page_table.Contains(process_address, size), ResultInvalidCurrentMemory);
|
||||
|
||||
R_RETURN(das->Unmap(std::addressof(page_table), process_address, size, device_address));
|
||||
}
|
||||
|
||||
Result CreateDeviceAddressSpace64(Core::System& system, Handle* out_handle, uint64_t das_address,
|
||||
uint64_t das_size) {
|
||||
R_RETURN(CreateDeviceAddressSpace(system, out_handle, das_address, das_size));
|
||||
}
|
||||
|
||||
Result AttachDeviceAddressSpace64(Core::System& system, DeviceName device_name, Handle das_handle) {
|
||||
R_RETURN(AttachDeviceAddressSpace(system, device_name, das_handle));
|
||||
}
|
||||
|
||||
Result DetachDeviceAddressSpace64(Core::System& system, DeviceName device_name, Handle das_handle) {
|
||||
R_RETURN(DetachDeviceAddressSpace(system, device_name, das_handle));
|
||||
}
|
||||
|
||||
Result MapDeviceAddressSpaceByForce64(Core::System& system, Handle das_handle,
|
||||
Handle process_handle, uint64_t process_address,
|
||||
uint64_t size, uint64_t device_address, u32 option) {
|
||||
R_RETURN(MapDeviceAddressSpaceByForce(system, das_handle, process_handle, process_address, size,
|
||||
device_address, option));
|
||||
}
|
||||
|
||||
Result MapDeviceAddressSpaceAligned64(Core::System& system, Handle das_handle,
|
||||
Handle process_handle, uint64_t process_address,
|
||||
uint64_t size, uint64_t device_address, u32 option) {
|
||||
R_RETURN(MapDeviceAddressSpaceAligned(system, das_handle, process_handle, process_address, size,
|
||||
device_address, option));
|
||||
}
|
||||
|
||||
Result UnmapDeviceAddressSpace64(Core::System& system, Handle das_handle, Handle process_handle,
|
||||
uint64_t process_address, uint64_t size, uint64_t device_address) {
|
||||
R_RETURN(UnmapDeviceAddressSpace(system, das_handle, process_handle, process_address, size,
|
||||
device_address));
|
||||
}
|
||||
|
||||
Result CreateDeviceAddressSpace64From32(Core::System& system, Handle* out_handle,
|
||||
uint64_t das_address, uint64_t das_size) {
|
||||
R_RETURN(CreateDeviceAddressSpace(system, out_handle, das_address, das_size));
|
||||
}
|
||||
|
||||
Result AttachDeviceAddressSpace64From32(Core::System& system, DeviceName device_name,
|
||||
Handle das_handle) {
|
||||
R_RETURN(AttachDeviceAddressSpace(system, device_name, das_handle));
|
||||
}
|
||||
|
||||
Result DetachDeviceAddressSpace64From32(Core::System& system, DeviceName device_name,
|
||||
Handle das_handle) {
|
||||
R_RETURN(DetachDeviceAddressSpace(system, device_name, das_handle));
|
||||
}
|
||||
|
||||
Result MapDeviceAddressSpaceByForce64From32(Core::System& system, Handle das_handle,
|
||||
Handle process_handle, uint64_t process_address,
|
||||
uint32_t size, uint64_t device_address, u32 option) {
|
||||
R_RETURN(MapDeviceAddressSpaceByForce(system, das_handle, process_handle, process_address, size,
|
||||
device_address, option));
|
||||
}
|
||||
|
||||
Result MapDeviceAddressSpaceAligned64From32(Core::System& system, Handle das_handle,
|
||||
Handle process_handle, uint64_t process_address,
|
||||
uint32_t size, uint64_t device_address, u32 option) {
|
||||
R_RETURN(MapDeviceAddressSpaceAligned(system, das_handle, process_handle, process_address, size,
|
||||
device_address, option));
|
||||
}
|
||||
|
||||
Result UnmapDeviceAddressSpace64From32(Core::System& system, Handle das_handle,
|
||||
Handle process_handle, uint64_t process_address,
|
||||
uint32_t size, uint64_t device_address) {
|
||||
R_RETURN(UnmapDeviceAddressSpace(system, das_handle, process_handle, process_address, size,
|
||||
device_address));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
124
src/core/hle/kernel/svc/svc_event.cpp
Executable file
124
src/core/hle/kernel/svc/svc_event.cpp
Executable file
|
|
@ -0,0 +1,124 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_event.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
||||
#include "core/hle/kernel/kernel.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result SignalEvent(Core::System& system, Handle event_handle) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, event_handle=0x{:08X}", event_handle);
|
||||
|
||||
// Get the current handle table.
|
||||
const KHandleTable& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
||||
|
||||
// Get the event.
|
||||
KScopedAutoObject event = handle_table.GetObject<KEvent>(event_handle);
|
||||
R_UNLESS(event.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
return event->Signal();
|
||||
}
|
||||
|
||||
Result ClearEvent(Core::System& system, Handle event_handle) {
|
||||
LOG_TRACE(Kernel_SVC, "called, event_handle=0x{:08X}", event_handle);
|
||||
|
||||
// Get the current handle table.
|
||||
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
||||
|
||||
// Try to clear the writable event.
|
||||
{
|
||||
KScopedAutoObject event = handle_table.GetObject<KEvent>(event_handle);
|
||||
if (event.IsNotNull()) {
|
||||
return event->Clear();
|
||||
}
|
||||
}
|
||||
|
||||
// Try to clear the readable event.
|
||||
{
|
||||
KScopedAutoObject readable_event = handle_table.GetObject<KReadableEvent>(event_handle);
|
||||
if (readable_event.IsNotNull()) {
|
||||
return readable_event->Clear();
|
||||
}
|
||||
}
|
||||
|
||||
LOG_ERROR(Kernel_SVC, "Event handle does not exist, event_handle=0x{:08X}", event_handle);
|
||||
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
Result CreateEvent(Core::System& system, Handle* out_write, Handle* out_read) {
|
||||
LOG_DEBUG(Kernel_SVC, "called");
|
||||
|
||||
// Get the kernel reference and handle table.
|
||||
auto& kernel = system.Kernel();
|
||||
auto& handle_table = kernel.CurrentProcess()->GetHandleTable();
|
||||
|
||||
// Reserve a new event from the process resource limit
|
||||
KScopedResourceReservation event_reservation(kernel.CurrentProcess(),
|
||||
LimitableResource::EventCountMax);
|
||||
R_UNLESS(event_reservation.Succeeded(), ResultLimitReached);
|
||||
|
||||
// Create a new event.
|
||||
KEvent* event = KEvent::Create(kernel);
|
||||
R_UNLESS(event != nullptr, ResultOutOfResource);
|
||||
|
||||
// Initialize the event.
|
||||
event->Initialize(kernel.CurrentProcess());
|
||||
|
||||
// Commit the thread reservation.
|
||||
event_reservation.Commit();
|
||||
|
||||
// Ensure that we clean up the event (and its only references are handle table) on function end.
|
||||
SCOPE_EXIT({
|
||||
event->GetReadableEvent().Close();
|
||||
event->Close();
|
||||
});
|
||||
|
||||
// Register the event.
|
||||
KEvent::Register(kernel, event);
|
||||
|
||||
// Add the event to the handle table.
|
||||
R_TRY(handle_table.Add(out_write, event));
|
||||
|
||||
// Ensure that we maintaing a clean handle state on exit.
|
||||
auto handle_guard = SCOPE_GUARD({ handle_table.Remove(*out_write); });
|
||||
|
||||
// Add the readable event to the handle table.
|
||||
R_TRY(handle_table.Add(out_read, std::addressof(event->GetReadableEvent())));
|
||||
|
||||
// We succeeded.
|
||||
handle_guard.Cancel();
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result SignalEvent64(Core::System& system, Handle event_handle) {
|
||||
R_RETURN(SignalEvent(system, event_handle));
|
||||
}
|
||||
|
||||
Result ClearEvent64(Core::System& system, Handle event_handle) {
|
||||
R_RETURN(ClearEvent(system, event_handle));
|
||||
}
|
||||
|
||||
Result CreateEvent64(Core::System& system, Handle* out_write_handle, Handle* out_read_handle) {
|
||||
R_RETURN(CreateEvent(system, out_write_handle, out_read_handle));
|
||||
}
|
||||
|
||||
Result SignalEvent64From32(Core::System& system, Handle event_handle) {
|
||||
R_RETURN(SignalEvent(system, event_handle));
|
||||
}
|
||||
|
||||
Result ClearEvent64From32(Core::System& system, Handle event_handle) {
|
||||
R_RETURN(ClearEvent(system, event_handle));
|
||||
}
|
||||
|
||||
Result CreateEvent64From32(Core::System& system, Handle* out_write_handle,
|
||||
Handle* out_read_handle) {
|
||||
R_RETURN(CreateEvent(system, out_write_handle, out_read_handle));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
137
src/core/hle/kernel/svc/svc_exception.cpp
Executable file
137
src/core/hle/kernel/svc/svc_exception.cpp
Executable file
|
|
@ -0,0 +1,137 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/debugger/debugger.h"
|
||||
#include "core/hle/kernel/k_thread.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_types.h"
|
||||
#include "core/memory.h"
|
||||
#include "core/reporter.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Break program execution
|
||||
void Break(Core::System& system, BreakReason reason, u64 info1, u64 info2) {
|
||||
BreakReason break_reason =
|
||||
reason & static_cast<BreakReason>(~BreakReason::NotificationOnlyFlag);
|
||||
bool notification_only = True(reason & BreakReason::NotificationOnlyFlag);
|
||||
|
||||
bool has_dumped_buffer{};
|
||||
std::vector<u8> debug_buffer;
|
||||
|
||||
const auto handle_debug_buffer = [&](VAddr addr, u64 sz) {
|
||||
if (sz == 0 || addr == 0 || has_dumped_buffer) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto& memory = system.Memory();
|
||||
|
||||
// This typically is an error code so we're going to assume this is the case
|
||||
if (sz == sizeof(u32)) {
|
||||
LOG_CRITICAL(Debug_Emulated, "debug_buffer_err_code={:X}", memory.Read32(addr));
|
||||
} else {
|
||||
// We don't know what's in here so we'll hexdump it
|
||||
debug_buffer.resize(sz);
|
||||
memory.ReadBlock(addr, debug_buffer.data(), sz);
|
||||
std::string hexdump;
|
||||
for (std::size_t i = 0; i < debug_buffer.size(); i++) {
|
||||
hexdump += fmt::format("{:02X} ", debug_buffer[i]);
|
||||
if (i != 0 && i % 16 == 0) {
|
||||
hexdump += '\n';
|
||||
}
|
||||
}
|
||||
LOG_CRITICAL(Debug_Emulated, "debug_buffer=\n{}", hexdump);
|
||||
}
|
||||
has_dumped_buffer = true;
|
||||
};
|
||||
switch (break_reason) {
|
||||
case BreakReason::Panic:
|
||||
LOG_CRITICAL(Debug_Emulated, "Userspace PANIC! info1=0x{:016X}, info2=0x{:016X}", info1,
|
||||
info2);
|
||||
handle_debug_buffer(info1, info2);
|
||||
break;
|
||||
case BreakReason::Assert:
|
||||
LOG_CRITICAL(Debug_Emulated, "Userspace Assertion failed! info1=0x{:016X}, info2=0x{:016X}",
|
||||
info1, info2);
|
||||
handle_debug_buffer(info1, info2);
|
||||
break;
|
||||
case BreakReason::User:
|
||||
LOG_WARNING(Debug_Emulated, "Userspace Break! 0x{:016X} with size 0x{:016X}", info1, info2);
|
||||
handle_debug_buffer(info1, info2);
|
||||
break;
|
||||
case BreakReason::PreLoadDll:
|
||||
LOG_INFO(Debug_Emulated,
|
||||
"Userspace Attempting to load an NRO at 0x{:016X} with size 0x{:016X}", info1,
|
||||
info2);
|
||||
break;
|
||||
case BreakReason::PostLoadDll:
|
||||
LOG_INFO(Debug_Emulated, "Userspace Loaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
|
||||
info2);
|
||||
break;
|
||||
case BreakReason::PreUnloadDll:
|
||||
LOG_INFO(Debug_Emulated,
|
||||
"Userspace Attempting to unload an NRO at 0x{:016X} with size 0x{:016X}", info1,
|
||||
info2);
|
||||
break;
|
||||
case BreakReason::PostUnloadDll:
|
||||
LOG_INFO(Debug_Emulated, "Userspace Unloaded an NRO at 0x{:016X} with size 0x{:016X}",
|
||||
info1, info2);
|
||||
break;
|
||||
case BreakReason::CppException:
|
||||
LOG_CRITICAL(Debug_Emulated, "Signalling debugger. Uncaught C++ exception encountered.");
|
||||
break;
|
||||
default:
|
||||
LOG_WARNING(
|
||||
Debug_Emulated,
|
||||
"Signalling debugger, Unknown break reason {:#X}, info1=0x{:016X}, info2=0x{:016X}",
|
||||
reason, info1, info2);
|
||||
handle_debug_buffer(info1, info2);
|
||||
break;
|
||||
}
|
||||
|
||||
system.GetReporter().SaveSvcBreakReport(
|
||||
static_cast<u32>(reason), notification_only, info1, info2,
|
||||
has_dumped_buffer ? std::make_optional(debug_buffer) : std::nullopt);
|
||||
|
||||
if (!notification_only) {
|
||||
LOG_CRITICAL(
|
||||
Debug_Emulated,
|
||||
"Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
|
||||
reason, info1, info2);
|
||||
|
||||
handle_debug_buffer(info1, info2);
|
||||
|
||||
auto* const current_thread = GetCurrentThreadPointer(system.Kernel());
|
||||
const auto thread_processor_id = current_thread->GetActiveCore();
|
||||
system.ArmInterface(static_cast<std::size_t>(thread_processor_id)).LogBacktrace();
|
||||
}
|
||||
|
||||
if (system.DebuggerEnabled()) {
|
||||
auto* thread = system.Kernel().GetCurrentEmuThread();
|
||||
system.GetDebugger().NotifyThreadStopped(thread);
|
||||
thread->RequestSuspend(Kernel::SuspendType::Debug);
|
||||
}
|
||||
}
|
||||
|
||||
void ReturnFromException(Core::System& system, Result result) {
|
||||
UNIMPLEMENTED();
|
||||
}
|
||||
|
||||
void Break64(Core::System& system, BreakReason break_reason, uint64_t arg, uint64_t size) {
|
||||
Break(system, break_reason, arg, size);
|
||||
}
|
||||
|
||||
void Break64From32(Core::System& system, BreakReason break_reason, uint32_t arg, uint32_t size) {
|
||||
Break(system, break_reason, arg, size);
|
||||
}
|
||||
|
||||
void ReturnFromException64(Core::System& system, Result result) {
|
||||
ReturnFromException(system, result);
|
||||
}
|
||||
|
||||
void ReturnFromException64From32(Core::System& system, Result result) {
|
||||
ReturnFromException(system, result);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
297
src/core/hle/kernel/svc/svc_info.cpp
Executable file
297
src/core/hle/kernel/svc/svc_info.cpp
Executable file
|
|
@ -0,0 +1,297 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/core_timing.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_resource_limit.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Gets system/memory information for the current process
|
||||
Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle 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);
|
||||
|
||||
u32 info_id = static_cast<u32>(info_id_type);
|
||||
|
||||
switch (info_id_type) {
|
||||
case InfoType::CoreMask:
|
||||
case InfoType::PriorityMask:
|
||||
case InfoType::AliasRegionAddress:
|
||||
case InfoType::AliasRegionSize:
|
||||
case InfoType::HeapRegionAddress:
|
||||
case InfoType::HeapRegionSize:
|
||||
case InfoType::AslrRegionAddress:
|
||||
case InfoType::AslrRegionSize:
|
||||
case InfoType::StackRegionAddress:
|
||||
case InfoType::StackRegionSize:
|
||||
case InfoType::TotalMemorySize:
|
||||
case InfoType::UsedMemorySize:
|
||||
case InfoType::SystemResourceSizeTotal:
|
||||
case InfoType::SystemResourceSizeUsed:
|
||||
case InfoType::ProgramId:
|
||||
case InfoType::UserExceptionContextAddress:
|
||||
case InfoType::TotalNonSystemMemorySize:
|
||||
case InfoType::UsedNonSystemMemorySize:
|
||||
case InfoType::IsApplication:
|
||||
case InfoType::FreeThreadCount: {
|
||||
if (info_sub_id != 0) {
|
||||
LOG_ERROR(Kernel_SVC, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id,
|
||||
info_sub_id);
|
||||
return ResultInvalidEnumValue;
|
||||
}
|
||||
|
||||
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
||||
KScopedAutoObject process = handle_table.GetObject<KProcess>(handle);
|
||||
if (process.IsNull()) {
|
||||
LOG_ERROR(Kernel_SVC, "Process is not valid! info_id={}, info_sub_id={}, handle={:08X}",
|
||||
info_id, info_sub_id, handle);
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
switch (info_id_type) {
|
||||
case InfoType::CoreMask:
|
||||
*result = process->GetCoreMask();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::PriorityMask:
|
||||
*result = process->GetPriorityMask();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::AliasRegionAddress:
|
||||
*result = process->PageTable().GetAliasRegionStart();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::AliasRegionSize:
|
||||
*result = process->PageTable().GetAliasRegionSize();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::HeapRegionAddress:
|
||||
*result = process->PageTable().GetHeapRegionStart();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::HeapRegionSize:
|
||||
*result = process->PageTable().GetHeapRegionSize();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::AslrRegionAddress:
|
||||
*result = process->PageTable().GetAliasCodeRegionStart();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::AslrRegionSize:
|
||||
*result = process->PageTable().GetAliasCodeRegionSize();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::StackRegionAddress:
|
||||
*result = process->PageTable().GetStackRegionStart();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::StackRegionSize:
|
||||
*result = process->PageTable().GetStackRegionSize();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::TotalMemorySize:
|
||||
*result = process->GetTotalPhysicalMemoryAvailable();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::UsedMemorySize:
|
||||
*result = process->GetTotalPhysicalMemoryUsed();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::SystemResourceSizeTotal:
|
||||
*result = process->GetSystemResourceSize();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::SystemResourceSizeUsed:
|
||||
LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query system resource usage");
|
||||
*result = process->GetSystemResourceUsage();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::ProgramId:
|
||||
*result = process->GetProgramID();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::UserExceptionContextAddress:
|
||||
*result = process->GetProcessLocalRegionAddress();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::TotalNonSystemMemorySize:
|
||||
*result = process->GetTotalPhysicalMemoryAvailableWithoutSystemResource();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::UsedNonSystemMemorySize:
|
||||
*result = process->GetTotalPhysicalMemoryUsedWithoutSystemResource();
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::FreeThreadCount:
|
||||
*result = process->GetFreeThreadCount();
|
||||
return ResultSuccess;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id=0x{:016X}", info_id);
|
||||
return ResultInvalidEnumValue;
|
||||
}
|
||||
|
||||
case InfoType::DebuggerAttached:
|
||||
*result = 0;
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::ResourceLimit: {
|
||||
if (handle != 0) {
|
||||
LOG_ERROR(Kernel, "Handle is non zero! handle={:08X}", handle);
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
if (info_sub_id != 0) {
|
||||
LOG_ERROR(Kernel, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id,
|
||||
info_sub_id);
|
||||
return ResultInvalidCombination;
|
||||
}
|
||||
|
||||
KProcess* const current_process = system.Kernel().CurrentProcess();
|
||||
KHandleTable& handle_table = current_process->GetHandleTable();
|
||||
const auto resource_limit = current_process->GetResourceLimit();
|
||||
if (!resource_limit) {
|
||||
*result = Svc::InvalidHandle;
|
||||
// Yes, the kernel considers this a successful operation.
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Handle resource_handle{};
|
||||
R_TRY(handle_table.Add(&resource_handle, resource_limit));
|
||||
|
||||
*result = resource_handle;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
case InfoType::RandomEntropy:
|
||||
if (handle != 0) {
|
||||
LOG_ERROR(Kernel_SVC, "Process Handle is non zero, expected 0 result but got {:016X}",
|
||||
handle);
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
if (info_sub_id >= KProcess::RANDOM_ENTROPY_SIZE) {
|
||||
LOG_ERROR(Kernel_SVC, "Entropy size is out of range, expected {} but got {}",
|
||||
KProcess::RANDOM_ENTROPY_SIZE, info_sub_id);
|
||||
return ResultInvalidCombination;
|
||||
}
|
||||
|
||||
*result = system.Kernel().CurrentProcess()->GetRandomEntropy(info_sub_id);
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::InitialProcessIdRange:
|
||||
LOG_WARNING(Kernel_SVC,
|
||||
"(STUBBED) Attempted to query privileged process id bounds, returned 0");
|
||||
*result = 0;
|
||||
return ResultSuccess;
|
||||
|
||||
case InfoType::ThreadTickCount: {
|
||||
constexpr u64 num_cpus = 4;
|
||||
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,
|
||||
info_sub_id);
|
||||
return ResultInvalidCombination;
|
||||
}
|
||||
|
||||
KScopedAutoObject thread =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(
|
||||
static_cast<Handle>(handle));
|
||||
if (thread.IsNull()) {
|
||||
LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}",
|
||||
static_cast<Handle>(handle));
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
const auto& core_timing = system.CoreTiming();
|
||||
const auto& scheduler = *system.Kernel().CurrentScheduler();
|
||||
const auto* const current_thread = GetCurrentThreadPointer(system.Kernel());
|
||||
const bool same_thread = current_thread == thread.GetPointerUnsafe();
|
||||
|
||||
const u64 prev_ctx_ticks = scheduler.GetLastContextSwitchTime();
|
||||
u64 out_ticks = 0;
|
||||
if (same_thread && info_sub_id == 0xFFFFFFFFFFFFFFFF) {
|
||||
const u64 thread_ticks = current_thread->GetCpuTime();
|
||||
|
||||
out_ticks = thread_ticks + (core_timing.GetCPUTicks() - prev_ctx_ticks);
|
||||
} else if (same_thread && info_sub_id == system.Kernel().CurrentPhysicalCoreIndex()) {
|
||||
out_ticks = core_timing.GetCPUTicks() - prev_ctx_ticks;
|
||||
}
|
||||
|
||||
*result = out_ticks;
|
||||
return ResultSuccess;
|
||||
}
|
||||
case InfoType::IdleTickCount: {
|
||||
// Verify the input handle is invalid.
|
||||
R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);
|
||||
|
||||
// Verify the requested core is valid.
|
||||
const bool core_valid =
|
||||
(info_sub_id == 0xFFFFFFFFFFFFFFFF) ||
|
||||
(info_sub_id == static_cast<u64>(system.Kernel().CurrentPhysicalCoreIndex()));
|
||||
R_UNLESS(core_valid, ResultInvalidCombination);
|
||||
|
||||
// Get the idle tick count.
|
||||
*result = system.Kernel().CurrentScheduler()->GetIdleThread()->GetCpuTime();
|
||||
return ResultSuccess;
|
||||
}
|
||||
case InfoType::MesosphereCurrentProcess: {
|
||||
// Verify the input handle is invalid.
|
||||
R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);
|
||||
|
||||
// Verify the sub-type is valid.
|
||||
R_UNLESS(info_sub_id == 0, ResultInvalidCombination);
|
||||
|
||||
// Get the handle table.
|
||||
KProcess* current_process = system.Kernel().CurrentProcess();
|
||||
KHandleTable& handle_table = current_process->GetHandleTable();
|
||||
|
||||
// Get a new handle for the current process.
|
||||
Handle tmp;
|
||||
R_TRY(handle_table.Add(&tmp, current_process));
|
||||
|
||||
// Set the output.
|
||||
*result = tmp;
|
||||
|
||||
// We succeeded.
|
||||
return ResultSuccess;
|
||||
}
|
||||
default:
|
||||
LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id=0x{:016X}", info_id);
|
||||
return ResultInvalidEnumValue;
|
||||
}
|
||||
}
|
||||
|
||||
Result GetSystemInfo(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle,
|
||||
uint64_t info_subtype) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result GetInfo64(Core::System& system, uint64_t* out, InfoType info_type, Handle handle,
|
||||
uint64_t info_subtype) {
|
||||
R_RETURN(GetInfo(system, out, info_type, handle, info_subtype));
|
||||
}
|
||||
|
||||
Result GetSystemInfo64(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle,
|
||||
uint64_t info_subtype) {
|
||||
R_RETURN(GetSystemInfo(system, out, info_type, handle, info_subtype));
|
||||
}
|
||||
|
||||
Result GetInfo64From32(Core::System& system, uint64_t* out, InfoType info_type, Handle handle,
|
||||
uint64_t info_subtype) {
|
||||
R_RETURN(GetInfo(system, out, info_type, handle, info_subtype));
|
||||
}
|
||||
|
||||
Result GetSystemInfo64From32(Core::System& system, uint64_t* out, SystemInfoType info_type,
|
||||
Handle handle, uint64_t info_subtype) {
|
||||
R_RETURN(GetSystemInfo(system, out, info_type, handle, info_subtype));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
35
src/core/hle/kernel/svc/svc_insecure_memory.cpp
Executable file
35
src/core/hle/kernel/svc/svc_insecure_memory.cpp
Executable file
|
|
@ -0,0 +1,35 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result MapInsecureMemory(Core::System& system, uintptr_t address, size_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result UnmapInsecureMemory(Core::System& system, uintptr_t address, size_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result MapInsecureMemory64(Core::System& system, uint64_t address, uint64_t size) {
|
||||
R_RETURN(MapInsecureMemory(system, address, size));
|
||||
}
|
||||
|
||||
Result UnmapInsecureMemory64(Core::System& system, uint64_t address, uint64_t size) {
|
||||
R_RETURN(UnmapInsecureMemory(system, address, size));
|
||||
}
|
||||
|
||||
Result MapInsecureMemory64From32(Core::System& system, uint32_t address, uint32_t size) {
|
||||
R_RETURN(MapInsecureMemory(system, address, size));
|
||||
}
|
||||
|
||||
Result UnmapInsecureMemory64From32(Core::System& system, uint32_t address, uint32_t size) {
|
||||
R_RETURN(UnmapInsecureMemory(system, address, size));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
25
src/core/hle/kernel/svc/svc_interrupt_event.cpp
Executable file
25
src/core/hle/kernel/svc/svc_interrupt_event.cpp
Executable file
|
|
@ -0,0 +1,25 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result CreateInterruptEvent(Core::System& system, Handle* out, int32_t interrupt_id,
|
||||
InterruptType type) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result CreateInterruptEvent64(Core::System& system, Handle* out_read_handle, int32_t interrupt_id,
|
||||
InterruptType interrupt_type) {
|
||||
R_RETURN(CreateInterruptEvent(system, out_read_handle, interrupt_id, interrupt_type));
|
||||
}
|
||||
|
||||
Result CreateInterruptEvent64From32(Core::System& system, Handle* out_read_handle,
|
||||
int32_t interrupt_id, InterruptType interrupt_type) {
|
||||
R_RETURN(CreateInterruptEvent(system, out_read_handle, interrupt_id, interrupt_type));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
71
src/core/hle/kernel/svc/svc_io_pool.cpp
Executable file
71
src/core/hle/kernel/svc/svc_io_pool.cpp
Executable file
|
|
@ -0,0 +1,71 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result CreateIoPool(Core::System& system, Handle* out, IoPoolType pool_type) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result CreateIoRegion(Core::System& system, Handle* out, Handle io_pool_handle, uint64_t phys_addr,
|
||||
size_t size, MemoryMapping mapping, MemoryPermission perm) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result MapIoRegion(Core::System& system, Handle io_region_handle, uintptr_t address, size_t size,
|
||||
MemoryPermission map_perm) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result UnmapIoRegion(Core::System& system, Handle io_region_handle, uintptr_t address,
|
||||
size_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result CreateIoPool64(Core::System& system, Handle* out_handle, IoPoolType pool_type) {
|
||||
R_RETURN(CreateIoPool(system, out_handle, pool_type));
|
||||
}
|
||||
|
||||
Result CreateIoRegion64(Core::System& system, Handle* out_handle, Handle io_pool,
|
||||
uint64_t physical_address, uint64_t size, MemoryMapping mapping,
|
||||
MemoryPermission perm) {
|
||||
R_RETURN(CreateIoRegion(system, out_handle, io_pool, physical_address, size, mapping, perm));
|
||||
}
|
||||
|
||||
Result MapIoRegion64(Core::System& system, Handle io_region, uint64_t address, uint64_t size,
|
||||
MemoryPermission perm) {
|
||||
R_RETURN(MapIoRegion(system, io_region, address, size, perm));
|
||||
}
|
||||
|
||||
Result UnmapIoRegion64(Core::System& system, Handle io_region, uint64_t address, uint64_t size) {
|
||||
R_RETURN(UnmapIoRegion(system, io_region, address, size));
|
||||
}
|
||||
|
||||
Result CreateIoPool64From32(Core::System& system, Handle* out_handle, IoPoolType pool_type) {
|
||||
R_RETURN(CreateIoPool(system, out_handle, pool_type));
|
||||
}
|
||||
|
||||
Result CreateIoRegion64From32(Core::System& system, Handle* out_handle, Handle io_pool,
|
||||
uint64_t physical_address, uint32_t size, MemoryMapping mapping,
|
||||
MemoryPermission perm) {
|
||||
R_RETURN(CreateIoRegion(system, out_handle, io_pool, physical_address, size, mapping, perm));
|
||||
}
|
||||
|
||||
Result MapIoRegion64From32(Core::System& system, Handle io_region, uint32_t address, uint32_t size,
|
||||
MemoryPermission perm) {
|
||||
R_RETURN(MapIoRegion(system, io_region, address, size, perm));
|
||||
}
|
||||
|
||||
Result UnmapIoRegion64From32(Core::System& system, Handle io_region, uint32_t address,
|
||||
uint32_t size) {
|
||||
R_RETURN(UnmapIoRegion(system, io_region, address, size));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
174
src/core/hle/kernel/svc/svc_ipc.cpp
Executable file
174
src/core/hle/kernel/svc/svc_ipc.cpp
Executable file
|
|
@ -0,0 +1,174 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_client_session.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_server_session.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Makes a blocking IPC call to a service.
|
||||
Result SendSyncRequest(Core::System& system, Handle handle) {
|
||||
auto& kernel = system.Kernel();
|
||||
|
||||
// Get the client session from its handle.
|
||||
KScopedAutoObject session =
|
||||
kernel.CurrentProcess()->GetHandleTable().GetObject<KClientSession>(handle);
|
||||
R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
LOG_TRACE(Kernel_SVC, "called handle=0x{:08X}({})", handle, session->GetName());
|
||||
|
||||
return session->SendSyncRequest();
|
||||
}
|
||||
|
||||
Result SendSyncRequestWithUserBuffer(Core::System& system, uint64_t message_buffer,
|
||||
uint64_t message_buffer_size, Handle session_handle) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result SendAsyncRequestWithUserBuffer(Core::System& system, Handle* out_event_handle,
|
||||
uint64_t message_buffer, uint64_t message_buffer_size,
|
||||
Handle session_handle) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles_addr, s32 num_handles,
|
||||
Handle reply_target, s64 timeout_ns) {
|
||||
auto& kernel = system.Kernel();
|
||||
auto& handle_table = GetCurrentThread(kernel).GetOwnerProcess()->GetHandleTable();
|
||||
|
||||
R_UNLESS(0 <= num_handles && num_handles <= ArgumentHandleCountMax, ResultOutOfRange);
|
||||
R_UNLESS(system.Memory().IsValidVirtualAddressRange(
|
||||
handles_addr, static_cast<u64>(sizeof(Handle) * num_handles)),
|
||||
ResultInvalidPointer);
|
||||
|
||||
std::vector<Handle> handles(num_handles);
|
||||
system.Memory().ReadBlock(handles_addr, handles.data(), sizeof(Handle) * num_handles);
|
||||
|
||||
// Convert handle list to object table.
|
||||
std::vector<KSynchronizationObject*> objs(num_handles);
|
||||
R_UNLESS(handle_table.GetMultipleObjects<KSynchronizationObject>(objs.data(), handles.data(),
|
||||
num_handles),
|
||||
ResultInvalidHandle);
|
||||
|
||||
// Ensure handles are closed when we're done.
|
||||
SCOPE_EXIT({
|
||||
for (auto i = 0; i < num_handles; ++i) {
|
||||
objs[i]->Close();
|
||||
}
|
||||
});
|
||||
|
||||
// Reply to the target, if one is specified.
|
||||
if (reply_target != InvalidHandle) {
|
||||
KScopedAutoObject session = handle_table.GetObject<KServerSession>(reply_target);
|
||||
R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// If we fail to reply, we want to set the output index to -1.
|
||||
ON_RESULT_FAILURE {
|
||||
*out_index = -1;
|
||||
};
|
||||
|
||||
// Send the reply.
|
||||
R_TRY(session->SendReply());
|
||||
}
|
||||
|
||||
// Wait for a message.
|
||||
while (true) {
|
||||
// Wait for an object.
|
||||
s32 index;
|
||||
Result result = KSynchronizationObject::Wait(kernel, &index, objs.data(),
|
||||
static_cast<s32>(objs.size()), timeout_ns);
|
||||
if (result == ResultTimedOut) {
|
||||
return result;
|
||||
}
|
||||
|
||||
// Receive the request.
|
||||
if (R_SUCCEEDED(result)) {
|
||||
KServerSession* session = objs[index]->DynamicCast<KServerSession*>();
|
||||
if (session != nullptr) {
|
||||
result = session->ReceiveRequest();
|
||||
if (result == ResultNotFound) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*out_index = index;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
Result ReplyAndReceiveWithUserBuffer(Core::System& system, int32_t* out_index,
|
||||
uint64_t message_buffer, uint64_t message_buffer_size,
|
||||
uint64_t handles, int32_t num_handles, Handle reply_target,
|
||||
int64_t timeout_ns) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result SendSyncRequest64(Core::System& system, Handle session_handle) {
|
||||
R_RETURN(SendSyncRequest(system, session_handle));
|
||||
}
|
||||
|
||||
Result SendSyncRequestWithUserBuffer64(Core::System& system, uint64_t message_buffer,
|
||||
uint64_t message_buffer_size, Handle session_handle) {
|
||||
R_RETURN(
|
||||
SendSyncRequestWithUserBuffer(system, message_buffer, message_buffer_size, session_handle));
|
||||
}
|
||||
|
||||
Result SendAsyncRequestWithUserBuffer64(Core::System& system, Handle* out_event_handle,
|
||||
uint64_t message_buffer, uint64_t message_buffer_size,
|
||||
Handle session_handle) {
|
||||
R_RETURN(SendAsyncRequestWithUserBuffer(system, out_event_handle, message_buffer,
|
||||
message_buffer_size, session_handle));
|
||||
}
|
||||
|
||||
Result ReplyAndReceive64(Core::System& system, int32_t* out_index, uint64_t handles,
|
||||
int32_t num_handles, Handle reply_target, int64_t timeout_ns) {
|
||||
R_RETURN(ReplyAndReceive(system, out_index, handles, num_handles, reply_target, timeout_ns));
|
||||
}
|
||||
|
||||
Result ReplyAndReceiveWithUserBuffer64(Core::System& system, int32_t* out_index,
|
||||
uint64_t message_buffer, uint64_t message_buffer_size,
|
||||
uint64_t handles, int32_t num_handles, Handle reply_target,
|
||||
int64_t timeout_ns) {
|
||||
R_RETURN(ReplyAndReceiveWithUserBuffer(system, out_index, message_buffer, message_buffer_size,
|
||||
handles, num_handles, reply_target, timeout_ns));
|
||||
}
|
||||
|
||||
Result SendSyncRequest64From32(Core::System& system, Handle session_handle) {
|
||||
R_RETURN(SendSyncRequest(system, session_handle));
|
||||
}
|
||||
|
||||
Result SendSyncRequestWithUserBuffer64From32(Core::System& system, uint32_t message_buffer,
|
||||
uint32_t message_buffer_size, Handle session_handle) {
|
||||
R_RETURN(
|
||||
SendSyncRequestWithUserBuffer(system, message_buffer, message_buffer_size, session_handle));
|
||||
}
|
||||
|
||||
Result SendAsyncRequestWithUserBuffer64From32(Core::System& system, Handle* out_event_handle,
|
||||
uint32_t message_buffer, uint32_t message_buffer_size,
|
||||
Handle session_handle) {
|
||||
R_RETURN(SendAsyncRequestWithUserBuffer(system, out_event_handle, message_buffer,
|
||||
message_buffer_size, session_handle));
|
||||
}
|
||||
|
||||
Result ReplyAndReceive64From32(Core::System& system, int32_t* out_index, uint32_t handles,
|
||||
int32_t num_handles, Handle reply_target, int64_t timeout_ns) {
|
||||
R_RETURN(ReplyAndReceive(system, out_index, handles, num_handles, reply_target, timeout_ns));
|
||||
}
|
||||
|
||||
Result ReplyAndReceiveWithUserBuffer64From32(Core::System& system, int32_t* out_index,
|
||||
uint32_t message_buffer, uint32_t message_buffer_size,
|
||||
uint32_t handles, int32_t num_handles,
|
||||
Handle reply_target, int64_t timeout_ns) {
|
||||
R_RETURN(ReplyAndReceiveWithUserBuffer(system, out_index, message_buffer, message_buffer_size,
|
||||
handles, num_handles, reply_target, timeout_ns));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
35
src/core/hle/kernel/svc/svc_kernel_debug.cpp
Executable file
35
src/core/hle/kernel/svc/svc_kernel_debug.cpp
Executable file
|
|
@ -0,0 +1,35 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
void KernelDebug(Core::System& system, KernelDebugType kernel_debug_type, u64 arg0, u64 arg1,
|
||||
u64 arg2) {
|
||||
// Intentionally do nothing, as this does nothing in released kernel binaries.
|
||||
}
|
||||
|
||||
void ChangeKernelTraceState(Core::System& system, KernelTraceState trace_state) {
|
||||
// Intentionally do nothing, as this does nothing in released kernel binaries.
|
||||
}
|
||||
|
||||
void KernelDebug64(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0,
|
||||
uint64_t arg1, uint64_t arg2) {
|
||||
KernelDebug(system, kern_debug_type, arg0, arg1, arg2);
|
||||
}
|
||||
|
||||
void ChangeKernelTraceState64(Core::System& system, KernelTraceState kern_trace_state) {
|
||||
ChangeKernelTraceState(system, kern_trace_state);
|
||||
}
|
||||
|
||||
void KernelDebug64From32(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0,
|
||||
uint64_t arg1, uint64_t arg2) {
|
||||
KernelDebug(system, kern_debug_type, arg0, arg1, arg2);
|
||||
}
|
||||
|
||||
void ChangeKernelTraceState64From32(Core::System& system, KernelTraceState kern_trace_state) {
|
||||
ChangeKernelTraceState(system, kern_trace_state);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
73
src/core/hle/kernel/svc/svc_light_ipc.cpp
Executable file
73
src/core/hle/kernel/svc/svc_light_ipc.cpp
Executable file
|
|
@ -0,0 +1,73 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/arm/arm_interface.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result SendSyncRequestLight(Core::System& system, Handle session_handle, u32* args) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result ReplyAndReceiveLight(Core::System& system, Handle session_handle, u32* args) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result SendSyncRequestLight64(Core::System& system, Handle session_handle, u32* args) {
|
||||
R_RETURN(SendSyncRequestLight(system, session_handle, args));
|
||||
}
|
||||
|
||||
Result ReplyAndReceiveLight64(Core::System& system, Handle session_handle, u32* args) {
|
||||
R_RETURN(ReplyAndReceiveLight(system, session_handle, args));
|
||||
}
|
||||
|
||||
Result SendSyncRequestLight64From32(Core::System& system, Handle session_handle, u32* args) {
|
||||
R_RETURN(SendSyncRequestLight(system, session_handle, args));
|
||||
}
|
||||
|
||||
Result ReplyAndReceiveLight64From32(Core::System& system, Handle session_handle, u32* args) {
|
||||
R_RETURN(ReplyAndReceiveLight(system, session_handle, args));
|
||||
}
|
||||
|
||||
// Custom ABI implementation for light IPC.
|
||||
|
||||
template <typename F>
|
||||
static void SvcWrap_LightIpc(Core::System& system, F&& cb) {
|
||||
auto& core = system.CurrentArmInterface();
|
||||
std::array<u32, 7> arguments{};
|
||||
|
||||
Handle session_handle = static_cast<Handle>(core.GetReg(0));
|
||||
for (int i = 0; i < 7; i++) {
|
||||
arguments[i] = static_cast<u32>(core.GetReg(i + 1));
|
||||
}
|
||||
|
||||
Result ret = cb(system, session_handle, arguments.data());
|
||||
|
||||
core.SetReg(0, ret.raw);
|
||||
for (int i = 0; i < 7; i++) {
|
||||
core.SetReg(i + 1, arguments[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void SvcWrap_SendSyncRequestLight64(Core::System& system) {
|
||||
SvcWrap_LightIpc(system, SendSyncRequestLight64);
|
||||
}
|
||||
|
||||
void SvcWrap_ReplyAndReceiveLight64(Core::System& system) {
|
||||
SvcWrap_LightIpc(system, ReplyAndReceiveLight64);
|
||||
}
|
||||
|
||||
void SvcWrap_SendSyncRequestLight64From32(Core::System& system) {
|
||||
SvcWrap_LightIpc(system, SendSyncRequestLight64From32);
|
||||
}
|
||||
|
||||
void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system) {
|
||||
SvcWrap_LightIpc(system, ReplyAndReceiveLight64From32);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
66
src/core/hle/kernel/svc/svc_lock.cpp
Executable file
66
src/core/hle/kernel/svc/svc_lock.cpp
Executable file
|
|
@ -0,0 +1,66 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_memory_layout.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Attempts to locks a mutex
|
||||
Result ArbitrateLock(Core::System& system, Handle thread_handle, VAddr address, u32 tag) {
|
||||
LOG_TRACE(Kernel_SVC, "called thread_handle=0x{:08X}, address=0x{:X}, tag=0x{:08X}",
|
||||
thread_handle, address, tag);
|
||||
|
||||
// Validate the input address.
|
||||
if (IsKernelAddress(address)) {
|
||||
LOG_ERROR(Kernel_SVC, "Attempting to arbitrate a lock on a kernel address (address={:08X})",
|
||||
address);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
if (!Common::IsAligned(address, sizeof(u32))) {
|
||||
LOG_ERROR(Kernel_SVC, "Input address must be 4 byte aligned (address: {:08X})", address);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
return system.Kernel().CurrentProcess()->WaitForAddress(thread_handle, address, tag);
|
||||
}
|
||||
|
||||
/// Unlock a mutex
|
||||
Result ArbitrateUnlock(Core::System& system, VAddr address) {
|
||||
LOG_TRACE(Kernel_SVC, "called address=0x{:X}", address);
|
||||
|
||||
// Validate the input address.
|
||||
if (IsKernelAddress(address)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Attempting to arbitrate an unlock on a kernel address (address={:08X})",
|
||||
address);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
if (!Common::IsAligned(address, sizeof(u32))) {
|
||||
LOG_ERROR(Kernel_SVC, "Input address must be 4 byte aligned (address: {:08X})", address);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
return system.Kernel().CurrentProcess()->SignalToAddress(address);
|
||||
}
|
||||
|
||||
Result ArbitrateLock64(Core::System& system, Handle thread_handle, uint64_t address, uint32_t tag) {
|
||||
R_RETURN(ArbitrateLock(system, thread_handle, address, tag));
|
||||
}
|
||||
|
||||
Result ArbitrateUnlock64(Core::System& system, uint64_t address) {
|
||||
R_RETURN(ArbitrateUnlock(system, address));
|
||||
}
|
||||
|
||||
Result ArbitrateLock64From32(Core::System& system, Handle thread_handle, uint32_t address,
|
||||
uint32_t tag) {
|
||||
R_RETURN(ArbitrateLock(system, thread_handle, address, tag));
|
||||
}
|
||||
|
||||
Result ArbitrateUnlock64From32(Core::System& system, uint32_t address) {
|
||||
R_RETURN(ArbitrateUnlock(system, address));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
217
src/core/hle/kernel/svc/svc_memory.cpp
Executable file
217
src/core/hle/kernel/svc/svc_memory.cpp
Executable file
|
|
@ -0,0 +1,217 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
namespace {
|
||||
|
||||
constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) {
|
||||
switch (perm) {
|
||||
case MemoryPermission::None:
|
||||
case MemoryPermission::Read:
|
||||
case MemoryPermission::ReadWrite:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Checks if address + size is greater than the given address
|
||||
// This can return false if the size causes an overflow of a 64-bit type
|
||||
// or if the given size is zero.
|
||||
constexpr bool IsValidAddressRange(VAddr address, u64 size) {
|
||||
return address + size > address;
|
||||
}
|
||||
|
||||
// Helper function that performs the common sanity checks for svcMapMemory
|
||||
// and svcUnmapMemory. This is doable, as both functions perform their sanitizing
|
||||
// in the same order.
|
||||
Result MapUnmapMemorySanityChecks(const KPageTable& manager, VAddr dst_addr, VAddr src_addr,
|
||||
u64 size) {
|
||||
if (!Common::Is4KBAligned(dst_addr)) {
|
||||
LOG_ERROR(Kernel_SVC, "Destination address is not aligned to 4KB, 0x{:016X}", dst_addr);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
if (!Common::Is4KBAligned(src_addr)) {
|
||||
LOG_ERROR(Kernel_SVC, "Source address is not aligned to 4KB, 0x{:016X}", src_addr);
|
||||
return ResultInvalidSize;
|
||||
}
|
||||
|
||||
if (size == 0) {
|
||||
LOG_ERROR(Kernel_SVC, "Size is 0");
|
||||
return ResultInvalidSize;
|
||||
}
|
||||
|
||||
if (!Common::Is4KBAligned(size)) {
|
||||
LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:016X}", size);
|
||||
return ResultInvalidSize;
|
||||
}
|
||||
|
||||
if (!IsValidAddressRange(dst_addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Destination is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
|
||||
dst_addr, size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
if (!IsValidAddressRange(src_addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC, "Source is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
|
||||
src_addr, size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
if (!manager.IsInsideAddressSpace(src_addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Source is not within the address space, addr=0x{:016X}, size=0x{:016X}",
|
||||
src_addr, size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
if (manager.IsOutsideStackRegion(dst_addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Destination is not within the stack region, addr=0x{:016X}, size=0x{:016X}",
|
||||
dst_addr, size);
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
if (manager.IsInsideHeapRegion(dst_addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Destination does not fit within the heap region, addr=0x{:016X}, "
|
||||
"size=0x{:016X}",
|
||||
dst_addr, size);
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
if (manager.IsInsideAliasRegion(dst_addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Destination does not fit within the map region, addr=0x{:016X}, "
|
||||
"size=0x{:016X}",
|
||||
dst_addr, size);
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
Result SetMemoryPermission(Core::System& system, VAddr address, u64 size, MemoryPermission perm) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, address=0x{:016X}, size=0x{:X}, perm=0x{:08X", address, size,
|
||||
perm);
|
||||
|
||||
// Validate address / size.
|
||||
R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Validate the permission.
|
||||
R_UNLESS(IsValidSetMemoryPermission(perm), ResultInvalidNewMemoryPermission);
|
||||
|
||||
// Validate that the region is in range for the current process.
|
||||
auto& page_table = system.Kernel().CurrentProcess()->PageTable();
|
||||
R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Set the memory attribute.
|
||||
return page_table.SetMemoryPermission(address, size, perm);
|
||||
}
|
||||
|
||||
Result SetMemoryAttribute(Core::System& system, VAddr address, u64 size, u32 mask, u32 attr) {
|
||||
LOG_DEBUG(Kernel_SVC,
|
||||
"called, address=0x{:016X}, size=0x{:X}, mask=0x{:08X}, attribute=0x{:08X}", address,
|
||||
size, mask, attr);
|
||||
|
||||
// Validate address / size.
|
||||
R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Validate the attribute and mask.
|
||||
constexpr u32 SupportedMask = static_cast<u32>(MemoryAttribute::Uncached);
|
||||
R_UNLESS((mask | attr) == mask, ResultInvalidCombination);
|
||||
R_UNLESS((mask | attr | SupportedMask) == SupportedMask, ResultInvalidCombination);
|
||||
|
||||
// Validate that the region is in range for the current process.
|
||||
auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
|
||||
R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Set the memory attribute.
|
||||
return page_table.SetMemoryAttribute(address, size, mask, attr);
|
||||
}
|
||||
|
||||
/// Maps a memory range into a different range.
|
||||
Result MapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size) {
|
||||
LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
|
||||
src_addr, size);
|
||||
|
||||
auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
|
||||
|
||||
if (const Result result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
|
||||
result.IsError()) {
|
||||
return result;
|
||||
}
|
||||
|
||||
return page_table.MapMemory(dst_addr, src_addr, size);
|
||||
}
|
||||
|
||||
/// Unmaps a region that was previously mapped with svcMapMemory
|
||||
Result UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size) {
|
||||
LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
|
||||
src_addr, size);
|
||||
|
||||
auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
|
||||
|
||||
if (const Result result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
|
||||
result.IsError()) {
|
||||
return result;
|
||||
}
|
||||
|
||||
return page_table.UnmapMemory(dst_addr, src_addr, size);
|
||||
}
|
||||
|
||||
Result SetMemoryPermission64(Core::System& system, uint64_t address, uint64_t size,
|
||||
MemoryPermission perm) {
|
||||
R_RETURN(SetMemoryPermission(system, address, size, perm));
|
||||
}
|
||||
|
||||
Result SetMemoryAttribute64(Core::System& system, uint64_t address, uint64_t size, uint32_t mask,
|
||||
uint32_t attr) {
|
||||
R_RETURN(SetMemoryAttribute(system, address, size, mask, attr));
|
||||
}
|
||||
|
||||
Result MapMemory64(Core::System& system, uint64_t dst_address, uint64_t src_address,
|
||||
uint64_t size) {
|
||||
R_RETURN(MapMemory(system, dst_address, src_address, size));
|
||||
}
|
||||
|
||||
Result UnmapMemory64(Core::System& system, uint64_t dst_address, uint64_t src_address,
|
||||
uint64_t size) {
|
||||
R_RETURN(UnmapMemory(system, dst_address, src_address, size));
|
||||
}
|
||||
|
||||
Result SetMemoryPermission64From32(Core::System& system, uint32_t address, uint32_t size,
|
||||
MemoryPermission perm) {
|
||||
R_RETURN(SetMemoryPermission(system, address, size, perm));
|
||||
}
|
||||
|
||||
Result SetMemoryAttribute64From32(Core::System& system, uint32_t address, uint32_t size,
|
||||
uint32_t mask, uint32_t attr) {
|
||||
R_RETURN(SetMemoryAttribute(system, address, size, mask, attr));
|
||||
}
|
||||
|
||||
Result MapMemory64From32(Core::System& system, uint32_t dst_address, uint32_t src_address,
|
||||
uint32_t size) {
|
||||
R_RETURN(MapMemory(system, dst_address, src_address, size));
|
||||
}
|
||||
|
||||
Result UnmapMemory64From32(Core::System& system, uint32_t dst_address, uint32_t src_address,
|
||||
uint32_t size) {
|
||||
R_RETURN(UnmapMemory(system, dst_address, src_address, size));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
185
src/core/hle/kernel/svc/svc_physical_memory.cpp
Executable file
185
src/core/hle/kernel/svc/svc_physical_memory.cpp
Executable file
|
|
@ -0,0 +1,185 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Set the process heap to a given Size. It can both extend and shrink the heap.
|
||||
Result SetHeapSize(Core::System& system, VAddr* out_address, u64 size) {
|
||||
LOG_TRACE(Kernel_SVC, "called, heap_size=0x{:X}", size);
|
||||
|
||||
// Validate size.
|
||||
R_UNLESS(Common::IsAligned(size, HeapSizeAlignment), ResultInvalidSize);
|
||||
R_UNLESS(size < MainMemorySizeMax, ResultInvalidSize);
|
||||
|
||||
// Set the heap size.
|
||||
R_TRY(system.Kernel().CurrentProcess()->PageTable().SetHeapSize(out_address, size));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
/// Maps memory at a desired address
|
||||
Result MapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
|
||||
|
||||
if (!Common::Is4KBAligned(addr)) {
|
||||
LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
if (!Common::Is4KBAligned(size)) {
|
||||
LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size);
|
||||
return ResultInvalidSize;
|
||||
}
|
||||
|
||||
if (size == 0) {
|
||||
LOG_ERROR(Kernel_SVC, "Size is zero");
|
||||
return ResultInvalidSize;
|
||||
}
|
||||
|
||||
if (!(addr < addr + size)) {
|
||||
LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address");
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
KProcess* const current_process{system.Kernel().CurrentProcess()};
|
||||
auto& page_table{current_process->PageTable()};
|
||||
|
||||
if (current_process->GetSystemResourceSize() == 0) {
|
||||
LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
|
||||
return ResultInvalidState;
|
||||
}
|
||||
|
||||
if (!page_table.IsInsideAddressSpace(addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Address is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr,
|
||||
size);
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
if (page_table.IsOutsideAliasRegion(addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Address is not within the alias region, addr=0x{:016X}, size=0x{:016X}", addr,
|
||||
size);
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
return page_table.MapPhysicalMemory(addr, size);
|
||||
}
|
||||
|
||||
/// Unmaps memory previously mapped via MapPhysicalMemory
|
||||
Result UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
|
||||
|
||||
if (!Common::Is4KBAligned(addr)) {
|
||||
LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
if (!Common::Is4KBAligned(size)) {
|
||||
LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size);
|
||||
return ResultInvalidSize;
|
||||
}
|
||||
|
||||
if (size == 0) {
|
||||
LOG_ERROR(Kernel_SVC, "Size is zero");
|
||||
return ResultInvalidSize;
|
||||
}
|
||||
|
||||
if (!(addr < addr + size)) {
|
||||
LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address");
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
KProcess* const current_process{system.Kernel().CurrentProcess()};
|
||||
auto& page_table{current_process->PageTable()};
|
||||
|
||||
if (current_process->GetSystemResourceSize() == 0) {
|
||||
LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
|
||||
return ResultInvalidState;
|
||||
}
|
||||
|
||||
if (!page_table.IsInsideAddressSpace(addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Address is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr,
|
||||
size);
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
if (page_table.IsOutsideAliasRegion(addr, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Address is not within the alias region, addr=0x{:016X}, size=0x{:016X}", addr,
|
||||
size);
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
return page_table.UnmapPhysicalMemory(addr, size);
|
||||
}
|
||||
|
||||
Result MapPhysicalMemoryUnsafe(Core::System& system, uint64_t address, uint64_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result UnmapPhysicalMemoryUnsafe(Core::System& system, uint64_t address, uint64_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result SetUnsafeLimit(Core::System& system, uint64_t limit) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result SetHeapSize64(Core::System& system, uint64_t* out_address, uint64_t size) {
|
||||
R_RETURN(SetHeapSize(system, out_address, size));
|
||||
}
|
||||
|
||||
Result MapPhysicalMemory64(Core::System& system, uint64_t address, uint64_t size) {
|
||||
R_RETURN(MapPhysicalMemory(system, address, size));
|
||||
}
|
||||
|
||||
Result UnmapPhysicalMemory64(Core::System& system, uint64_t address, uint64_t size) {
|
||||
R_RETURN(UnmapPhysicalMemory(system, address, size));
|
||||
}
|
||||
|
||||
Result MapPhysicalMemoryUnsafe64(Core::System& system, uint64_t address, uint64_t size) {
|
||||
R_RETURN(MapPhysicalMemoryUnsafe(system, address, size));
|
||||
}
|
||||
|
||||
Result UnmapPhysicalMemoryUnsafe64(Core::System& system, uint64_t address, uint64_t size) {
|
||||
R_RETURN(UnmapPhysicalMemoryUnsafe(system, address, size));
|
||||
}
|
||||
|
||||
Result SetUnsafeLimit64(Core::System& system, uint64_t limit) {
|
||||
R_RETURN(SetUnsafeLimit(system, limit));
|
||||
}
|
||||
|
||||
Result SetHeapSize64From32(Core::System& system, uintptr_t* out_address, uint32_t size) {
|
||||
R_RETURN(SetHeapSize(system, out_address, size));
|
||||
}
|
||||
|
||||
Result MapPhysicalMemory64From32(Core::System& system, uint32_t address, uint32_t size) {
|
||||
R_RETURN(MapPhysicalMemory(system, address, size));
|
||||
}
|
||||
|
||||
Result UnmapPhysicalMemory64From32(Core::System& system, uint32_t address, uint32_t size) {
|
||||
R_RETURN(UnmapPhysicalMemory(system, address, size));
|
||||
}
|
||||
|
||||
Result MapPhysicalMemoryUnsafe64From32(Core::System& system, uint32_t address, uint32_t size) {
|
||||
R_RETURN(MapPhysicalMemoryUnsafe(system, address, size));
|
||||
}
|
||||
|
||||
Result UnmapPhysicalMemoryUnsafe64From32(Core::System& system, uint32_t address, uint32_t size) {
|
||||
R_RETURN(UnmapPhysicalMemoryUnsafe(system, address, size));
|
||||
}
|
||||
|
||||
Result SetUnsafeLimit64From32(Core::System& system, uint32_t limit) {
|
||||
R_RETURN(SetUnsafeLimit(system, limit));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
122
src/core/hle/kernel/svc/svc_port.cpp
Executable file
122
src/core/hle/kernel/svc/svc_port.cpp
Executable file
|
|
@ -0,0 +1,122 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_client_port.h"
|
||||
#include "core/hle/kernel/k_client_session.h"
|
||||
#include "core/hle/kernel/k_port.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Connect to an OS service given the port name, returns the handle to the port to out
|
||||
Result ConnectToNamedPort(Core::System& system, Handle* out, VAddr port_name_address) {
|
||||
auto& memory = system.Memory();
|
||||
if (!memory.IsValidVirtualAddress(port_name_address)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Port Name Address is not a valid virtual address, port_name_address=0x{:016X}",
|
||||
port_name_address);
|
||||
return ResultNotFound;
|
||||
}
|
||||
|
||||
static constexpr std::size_t PortNameMaxLength = 11;
|
||||
// Read 1 char beyond the max allowed port name to detect names that are too long.
|
||||
const std::string port_name = memory.ReadCString(port_name_address, PortNameMaxLength + 1);
|
||||
if (port_name.size() > PortNameMaxLength) {
|
||||
LOG_ERROR(Kernel_SVC, "Port name is too long, expected {} but got {}", PortNameMaxLength,
|
||||
port_name.size());
|
||||
return ResultOutOfRange;
|
||||
}
|
||||
|
||||
LOG_TRACE(Kernel_SVC, "called port_name={}", port_name);
|
||||
|
||||
// Get the current handle table.
|
||||
auto& kernel = system.Kernel();
|
||||
auto& handle_table = kernel.CurrentProcess()->GetHandleTable();
|
||||
|
||||
// Find the client port.
|
||||
auto port = kernel.CreateNamedServicePort(port_name);
|
||||
if (!port) {
|
||||
LOG_ERROR(Kernel_SVC, "tried to connect to unknown port: {}", port_name);
|
||||
return ResultNotFound;
|
||||
}
|
||||
|
||||
// Reserve a handle for the port.
|
||||
// NOTE: Nintendo really does write directly to the output handle here.
|
||||
R_TRY(handle_table.Reserve(out));
|
||||
auto handle_guard = SCOPE_GUARD({ handle_table.Unreserve(*out); });
|
||||
|
||||
// Create a session.
|
||||
KClientSession* session{};
|
||||
R_TRY(port->CreateSession(std::addressof(session)));
|
||||
|
||||
kernel.RegisterNamedServiceHandler(port_name, &port->GetParent()->GetServerPort());
|
||||
|
||||
// Register the session in the table, close the extra reference.
|
||||
handle_table.Register(*out, session);
|
||||
session->Close();
|
||||
|
||||
// We succeeded.
|
||||
handle_guard.Cancel();
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result CreatePort(Core::System& system, Handle* out_server, Handle* out_client,
|
||||
int32_t max_sessions, bool is_light, uintptr_t name) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result ConnectToPort(Core::System& system, Handle* out_handle, Handle port) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t name,
|
||||
int32_t max_sessions) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result ConnectToNamedPort64(Core::System& system, Handle* out_handle, uint64_t name) {
|
||||
R_RETURN(ConnectToNamedPort(system, out_handle, name));
|
||||
}
|
||||
|
||||
Result CreatePort64(Core::System& system, Handle* out_server_handle, Handle* out_client_handle,
|
||||
int32_t max_sessions, bool is_light, uint64_t name) {
|
||||
R_RETURN(
|
||||
CreatePort(system, out_server_handle, out_client_handle, max_sessions, is_light, name));
|
||||
}
|
||||
|
||||
Result ManageNamedPort64(Core::System& system, Handle* out_server_handle, uint64_t name,
|
||||
int32_t max_sessions) {
|
||||
R_RETURN(ManageNamedPort(system, out_server_handle, name, max_sessions));
|
||||
}
|
||||
|
||||
Result ConnectToPort64(Core::System& system, Handle* out_handle, Handle port) {
|
||||
R_RETURN(ConnectToPort(system, out_handle, port));
|
||||
}
|
||||
|
||||
Result ConnectToNamedPort64From32(Core::System& system, Handle* out_handle, uint32_t name) {
|
||||
R_RETURN(ConnectToNamedPort(system, out_handle, name));
|
||||
}
|
||||
|
||||
Result CreatePort64From32(Core::System& system, Handle* out_server_handle,
|
||||
Handle* out_client_handle, int32_t max_sessions, bool is_light,
|
||||
uint32_t name) {
|
||||
R_RETURN(
|
||||
CreatePort(system, out_server_handle, out_client_handle, max_sessions, is_light, name));
|
||||
}
|
||||
|
||||
Result ManageNamedPort64From32(Core::System& system, Handle* out_server_handle, uint32_t name,
|
||||
int32_t max_sessions) {
|
||||
R_RETURN(ManageNamedPort(system, out_server_handle, name, max_sessions));
|
||||
}
|
||||
|
||||
Result ConnectToPort64From32(Core::System& system, Handle* out_handle, Handle port) {
|
||||
R_RETURN(ConnectToPort(system, out_handle, port));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
21
src/core/hle/kernel/svc/svc_power_management.cpp
Executable file
21
src/core/hle/kernel/svc/svc_power_management.cpp
Executable file
|
|
@ -0,0 +1,21 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
void SleepSystem(Core::System& system) {
|
||||
UNIMPLEMENTED();
|
||||
}
|
||||
|
||||
void SleepSystem64(Core::System& system) {
|
||||
return SleepSystem(system);
|
||||
}
|
||||
|
||||
void SleepSystem64From32(Core::System& system) {
|
||||
return SleepSystem(system);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
194
src/core/hle/kernel/svc/svc_process.cpp
Executable file
194
src/core/hle/kernel/svc/svc_process.cpp
Executable file
|
|
@ -0,0 +1,194 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Exits the current process
|
||||
void ExitProcess(Core::System& system) {
|
||||
auto* current_process = system.Kernel().CurrentProcess();
|
||||
|
||||
LOG_INFO(Kernel_SVC, "Process {} exiting", current_process->GetProcessID());
|
||||
ASSERT_MSG(current_process->GetState() == KProcess::State::Running,
|
||||
"Process has already exited");
|
||||
|
||||
system.Exit();
|
||||
}
|
||||
|
||||
/// Gets the ID of the specified process or a specified thread's owning process.
|
||||
Result GetProcessId(Core::System& system, u64* out_process_id, Handle handle) {
|
||||
LOG_DEBUG(Kernel_SVC, "called handle=0x{:08X}", handle);
|
||||
|
||||
// Get the object from the handle table.
|
||||
KScopedAutoObject obj =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KAutoObject>(
|
||||
static_cast<Handle>(handle));
|
||||
R_UNLESS(obj.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the process from the object.
|
||||
KProcess* process = nullptr;
|
||||
if (KProcess* p = obj->DynamicCast<KProcess*>(); p != nullptr) {
|
||||
// The object is a process, so we can use it directly.
|
||||
process = p;
|
||||
} else if (KThread* t = obj->DynamicCast<KThread*>(); t != nullptr) {
|
||||
// The object is a thread, so we want to use its parent.
|
||||
process = reinterpret_cast<KThread*>(obj.GetPointerUnsafe())->GetOwnerProcess();
|
||||
} else {
|
||||
// TODO(bunnei): This should also handle debug objects before returning.
|
||||
UNIMPLEMENTED_MSG("Debug objects not implemented");
|
||||
}
|
||||
|
||||
// Make sure the target process exists.
|
||||
R_UNLESS(process != nullptr, ResultInvalidHandle);
|
||||
|
||||
// Get the process id.
|
||||
*out_process_id = process->GetId();
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result GetProcessList(Core::System& system, s32* out_num_processes, VAddr out_process_ids,
|
||||
int32_t out_process_ids_size) {
|
||||
LOG_DEBUG(Kernel_SVC, "called. out_process_ids=0x{:016X}, out_process_ids_size={}",
|
||||
out_process_ids, out_process_ids_size);
|
||||
|
||||
// If the supplied size is negative or greater than INT32_MAX / sizeof(u64), bail.
|
||||
if ((out_process_ids_size & 0xF0000000) != 0) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Supplied size outside [0, 0x0FFFFFFF] range. out_process_ids_size={}",
|
||||
out_process_ids_size);
|
||||
return ResultOutOfRange;
|
||||
}
|
||||
|
||||
const auto& kernel = system.Kernel();
|
||||
const auto total_copy_size = out_process_ids_size * sizeof(u64);
|
||||
|
||||
if (out_process_ids_size > 0 && !kernel.CurrentProcess()->PageTable().IsInsideAddressSpace(
|
||||
out_process_ids, total_copy_size)) {
|
||||
LOG_ERROR(Kernel_SVC, "Address range outside address space. begin=0x{:016X}, end=0x{:016X}",
|
||||
out_process_ids, out_process_ids + total_copy_size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
auto& memory = system.Memory();
|
||||
const auto& process_list = kernel.GetProcessList();
|
||||
const auto num_processes = process_list.size();
|
||||
const auto copy_amount =
|
||||
std::min(static_cast<std::size_t>(out_process_ids_size), num_processes);
|
||||
|
||||
for (std::size_t i = 0; i < copy_amount; ++i) {
|
||||
memory.Write64(out_process_ids, process_list[i]->GetProcessID());
|
||||
out_process_ids += sizeof(u64);
|
||||
}
|
||||
|
||||
*out_num_processes = static_cast<u32>(num_processes);
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result GetProcessInfo(Core::System& system, s64* out, Handle process_handle,
|
||||
ProcessInfoType info_type) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, type=0x{:X}", process_handle, info_type);
|
||||
|
||||
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
||||
KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
|
||||
if (process.IsNull()) {
|
||||
LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
|
||||
process_handle);
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
if (info_type != ProcessInfoType::ProcessState) {
|
||||
LOG_ERROR(Kernel_SVC, "Expected info_type to be ProcessState but got {} instead",
|
||||
info_type);
|
||||
return ResultInvalidEnumValue;
|
||||
}
|
||||
|
||||
*out = static_cast<s64>(process->GetState());
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result CreateProcess(Core::System& system, Handle* out_handle, uint64_t parameters, uint64_t caps,
|
||||
int32_t num_caps) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result StartProcess(Core::System& system, Handle process_handle, int32_t priority, int32_t core_id,
|
||||
uint64_t main_thread_stack_size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result TerminateProcess(Core::System& system, Handle process_handle) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
void ExitProcess64(Core::System& system) {
|
||||
ExitProcess(system);
|
||||
}
|
||||
|
||||
Result GetProcessId64(Core::System& system, uint64_t* out_process_id, Handle process_handle) {
|
||||
R_RETURN(GetProcessId(system, out_process_id, process_handle));
|
||||
}
|
||||
|
||||
Result GetProcessList64(Core::System& system, int32_t* out_num_processes, uint64_t out_process_ids,
|
||||
int32_t max_out_count) {
|
||||
R_RETURN(GetProcessList(system, out_num_processes, out_process_ids, max_out_count));
|
||||
}
|
||||
|
||||
Result CreateProcess64(Core::System& system, Handle* out_handle, uint64_t parameters, uint64_t caps,
|
||||
int32_t num_caps) {
|
||||
R_RETURN(CreateProcess(system, out_handle, parameters, caps, num_caps));
|
||||
}
|
||||
|
||||
Result StartProcess64(Core::System& system, Handle process_handle, int32_t priority,
|
||||
int32_t core_id, uint64_t main_thread_stack_size) {
|
||||
R_RETURN(StartProcess(system, process_handle, priority, core_id, main_thread_stack_size));
|
||||
}
|
||||
|
||||
Result TerminateProcess64(Core::System& system, Handle process_handle) {
|
||||
R_RETURN(TerminateProcess(system, process_handle));
|
||||
}
|
||||
|
||||
Result GetProcessInfo64(Core::System& system, int64_t* out_info, Handle process_handle,
|
||||
ProcessInfoType info_type) {
|
||||
R_RETURN(GetProcessInfo(system, out_info, process_handle, info_type));
|
||||
}
|
||||
|
||||
void ExitProcess64From32(Core::System& system) {
|
||||
ExitProcess(system);
|
||||
}
|
||||
|
||||
Result GetProcessId64From32(Core::System& system, uint64_t* out_process_id, Handle process_handle) {
|
||||
R_RETURN(GetProcessId(system, out_process_id, process_handle));
|
||||
}
|
||||
|
||||
Result GetProcessList64From32(Core::System& system, int32_t* out_num_processes,
|
||||
uint32_t out_process_ids, int32_t max_out_count) {
|
||||
R_RETURN(GetProcessList(system, out_num_processes, out_process_ids, max_out_count));
|
||||
}
|
||||
|
||||
Result CreateProcess64From32(Core::System& system, Handle* out_handle, uint32_t parameters,
|
||||
uint32_t caps, int32_t num_caps) {
|
||||
R_RETURN(CreateProcess(system, out_handle, parameters, caps, num_caps));
|
||||
}
|
||||
|
||||
Result StartProcess64From32(Core::System& system, Handle process_handle, int32_t priority,
|
||||
int32_t core_id, uint64_t main_thread_stack_size) {
|
||||
R_RETURN(StartProcess(system, process_handle, priority, core_id, main_thread_stack_size));
|
||||
}
|
||||
|
||||
Result TerminateProcess64From32(Core::System& system, Handle process_handle) {
|
||||
R_RETURN(TerminateProcess(system, process_handle));
|
||||
}
|
||||
|
||||
Result GetProcessInfo64From32(Core::System& system, int64_t* out_info, Handle process_handle,
|
||||
ProcessInfoType info_type) {
|
||||
R_RETURN(GetProcessInfo(system, out_info, process_handle, info_type));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
324
src/core/hle/kernel/svc/svc_process_memory.cpp
Executable file
324
src/core/hle/kernel/svc/svc_process_memory.cpp
Executable file
|
|
@ -0,0 +1,324 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
namespace {
|
||||
|
||||
constexpr bool IsValidAddressRange(VAddr address, u64 size) {
|
||||
return address + size > address;
|
||||
}
|
||||
|
||||
constexpr bool IsValidProcessMemoryPermission(Svc::MemoryPermission perm) {
|
||||
switch (perm) {
|
||||
case Svc::MemoryPermission::None:
|
||||
case Svc::MemoryPermission::Read:
|
||||
case Svc::MemoryPermission::ReadWrite:
|
||||
case Svc::MemoryPermission::ReadExecute:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
Result SetProcessMemoryPermission(Core::System& system, Handle process_handle, VAddr address,
|
||||
u64 size, Svc::MemoryPermission perm) {
|
||||
LOG_TRACE(Kernel_SVC,
|
||||
"called, process_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
|
||||
process_handle, address, size, perm);
|
||||
|
||||
// Validate the address/size.
|
||||
R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
|
||||
R_UNLESS(address == static_cast<uintptr_t>(address), ResultInvalidCurrentMemory);
|
||||
R_UNLESS(size == static_cast<size_t>(size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Validate the memory permission.
|
||||
R_UNLESS(IsValidProcessMemoryPermission(perm), ResultInvalidNewMemoryPermission);
|
||||
|
||||
// Get the process from its handle.
|
||||
KScopedAutoObject process =
|
||||
system.CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
|
||||
R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Validate that the address is in range.
|
||||
auto& page_table = process->PageTable();
|
||||
R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Set the memory permission.
|
||||
return page_table.SetProcessMemoryPermission(address, size, perm);
|
||||
}
|
||||
|
||||
Result MapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
|
||||
VAddr src_address, u64 size) {
|
||||
LOG_TRACE(Kernel_SVC,
|
||||
"called, dst_address=0x{:X}, process_handle=0x{:X}, src_address=0x{:X}, size=0x{:X}",
|
||||
dst_address, process_handle, src_address, size);
|
||||
|
||||
// Validate the address/size.
|
||||
R_UNLESS(Common::IsAligned(dst_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(src_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((dst_address < dst_address + size), ResultInvalidCurrentMemory);
|
||||
R_UNLESS((src_address < src_address + size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Get the processes.
|
||||
KProcess* dst_process = system.CurrentProcess();
|
||||
KScopedAutoObject src_process =
|
||||
dst_process->GetHandleTable().GetObjectWithoutPseudoHandle<KProcess>(process_handle);
|
||||
R_UNLESS(src_process.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the page tables.
|
||||
auto& dst_pt = dst_process->PageTable();
|
||||
auto& src_pt = src_process->PageTable();
|
||||
|
||||
// Validate that the mapping is in range.
|
||||
R_UNLESS(src_pt.Contains(src_address, size), ResultInvalidCurrentMemory);
|
||||
R_UNLESS(dst_pt.CanContain(dst_address, size, KMemoryState::SharedCode),
|
||||
ResultInvalidMemoryRegion);
|
||||
|
||||
// Create a new page group.
|
||||
KPageGroup pg{system.Kernel(), dst_pt.GetBlockInfoManager()};
|
||||
R_TRY(src_pt.MakeAndOpenPageGroup(
|
||||
std::addressof(pg), src_address, size / PageSize, KMemoryState::FlagCanMapProcess,
|
||||
KMemoryState::FlagCanMapProcess, KMemoryPermission::None, KMemoryPermission::None,
|
||||
KMemoryAttribute::All, KMemoryAttribute::None));
|
||||
|
||||
// Map the group.
|
||||
R_TRY(dst_pt.MapPageGroup(dst_address, pg, KMemoryState::SharedCode,
|
||||
KMemoryPermission::UserReadWrite));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result UnmapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
|
||||
VAddr src_address, u64 size) {
|
||||
LOG_TRACE(Kernel_SVC,
|
||||
"called, dst_address=0x{:X}, process_handle=0x{:X}, src_address=0x{:X}, size=0x{:X}",
|
||||
dst_address, process_handle, src_address, size);
|
||||
|
||||
// Validate the address/size.
|
||||
R_UNLESS(Common::IsAligned(dst_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(src_address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((dst_address < dst_address + size), ResultInvalidCurrentMemory);
|
||||
R_UNLESS((src_address < src_address + size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Get the processes.
|
||||
KProcess* dst_process = system.CurrentProcess();
|
||||
KScopedAutoObject src_process =
|
||||
dst_process->GetHandleTable().GetObjectWithoutPseudoHandle<KProcess>(process_handle);
|
||||
R_UNLESS(src_process.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the page tables.
|
||||
auto& dst_pt = dst_process->PageTable();
|
||||
auto& src_pt = src_process->PageTable();
|
||||
|
||||
// Validate that the mapping is in range.
|
||||
R_UNLESS(src_pt.Contains(src_address, size), ResultInvalidCurrentMemory);
|
||||
R_UNLESS(dst_pt.CanContain(dst_address, size, KMemoryState::SharedCode),
|
||||
ResultInvalidMemoryRegion);
|
||||
|
||||
// Unmap the memory.
|
||||
R_TRY(dst_pt.UnmapProcessMemory(dst_address, size, src_pt, src_address));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst_address,
|
||||
u64 src_address, u64 size) {
|
||||
LOG_DEBUG(Kernel_SVC,
|
||||
"called. process_handle=0x{:08X}, dst_address=0x{:016X}, "
|
||||
"src_address=0x{:016X}, size=0x{:016X}",
|
||||
process_handle, dst_address, src_address, size);
|
||||
|
||||
if (!Common::Is4KBAligned(src_address)) {
|
||||
LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).",
|
||||
src_address);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
if (!Common::Is4KBAligned(dst_address)) {
|
||||
LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).",
|
||||
dst_address);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
if (size == 0 || !Common::Is4KBAligned(size)) {
|
||||
LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X})", size);
|
||||
return ResultInvalidSize;
|
||||
}
|
||||
|
||||
if (!IsValidAddressRange(dst_address, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Destination address range overflows the address space (dst_address=0x{:016X}, "
|
||||
"size=0x{:016X}).",
|
||||
dst_address, size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
if (!IsValidAddressRange(src_address, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Source address range overflows the address space (src_address=0x{:016X}, "
|
||||
"size=0x{:016X}).",
|
||||
src_address, size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
||||
KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
|
||||
if (process.IsNull()) {
|
||||
LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).",
|
||||
process_handle);
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
auto& page_table = process->PageTable();
|
||||
if (!page_table.IsInsideAddressSpace(src_address, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Source address range is not within the address space (src_address=0x{:016X}, "
|
||||
"size=0x{:016X}).",
|
||||
src_address, size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
if (!page_table.IsInsideASLRRegion(dst_address, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Destination address range is not within the ASLR region (dst_address=0x{:016X}, "
|
||||
"size=0x{:016X}).",
|
||||
dst_address, size);
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
return page_table.MapCodeMemory(dst_address, src_address, size);
|
||||
}
|
||||
|
||||
Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst_address,
|
||||
u64 src_address, u64 size) {
|
||||
LOG_DEBUG(Kernel_SVC,
|
||||
"called. process_handle=0x{:08X}, dst_address=0x{:016X}, src_address=0x{:016X}, "
|
||||
"size=0x{:016X}",
|
||||
process_handle, dst_address, src_address, size);
|
||||
|
||||
if (!Common::Is4KBAligned(dst_address)) {
|
||||
LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).",
|
||||
dst_address);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
if (!Common::Is4KBAligned(src_address)) {
|
||||
LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).",
|
||||
src_address);
|
||||
return ResultInvalidAddress;
|
||||
}
|
||||
|
||||
if (size == 0 || !Common::Is4KBAligned(size)) {
|
||||
LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X}).", size);
|
||||
return ResultInvalidSize;
|
||||
}
|
||||
|
||||
if (!IsValidAddressRange(dst_address, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Destination address range overflows the address space (dst_address=0x{:016X}, "
|
||||
"size=0x{:016X}).",
|
||||
dst_address, size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
if (!IsValidAddressRange(src_address, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Source address range overflows the address space (src_address=0x{:016X}, "
|
||||
"size=0x{:016X}).",
|
||||
src_address, size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
||||
KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
|
||||
if (process.IsNull()) {
|
||||
LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).",
|
||||
process_handle);
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
auto& page_table = process->PageTable();
|
||||
if (!page_table.IsInsideAddressSpace(src_address, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Source address range is not within the address space (src_address=0x{:016X}, "
|
||||
"size=0x{:016X}).",
|
||||
src_address, size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
if (!page_table.IsInsideASLRRegion(dst_address, size)) {
|
||||
LOG_ERROR(Kernel_SVC,
|
||||
"Destination address range is not within the ASLR region (dst_address=0x{:016X}, "
|
||||
"size=0x{:016X}).",
|
||||
dst_address, size);
|
||||
return ResultInvalidMemoryRegion;
|
||||
}
|
||||
|
||||
return page_table.UnmapCodeMemory(dst_address, src_address, size,
|
||||
KPageTable::ICacheInvalidationStrategy::InvalidateAll);
|
||||
}
|
||||
|
||||
Result SetProcessMemoryPermission64(Core::System& system, Handle process_handle, uint64_t address,
|
||||
uint64_t size, MemoryPermission perm) {
|
||||
R_RETURN(SetProcessMemoryPermission(system, process_handle, address, size, perm));
|
||||
}
|
||||
|
||||
Result MapProcessMemory64(Core::System& system, uint64_t dst_address, Handle process_handle,
|
||||
uint64_t src_address, uint64_t size) {
|
||||
R_RETURN(MapProcessMemory(system, dst_address, process_handle, src_address, size));
|
||||
}
|
||||
|
||||
Result UnmapProcessMemory64(Core::System& system, uint64_t dst_address, Handle process_handle,
|
||||
uint64_t src_address, uint64_t size) {
|
||||
R_RETURN(UnmapProcessMemory(system, dst_address, process_handle, src_address, size));
|
||||
}
|
||||
|
||||
Result MapProcessCodeMemory64(Core::System& system, Handle process_handle, uint64_t dst_address,
|
||||
uint64_t src_address, uint64_t size) {
|
||||
R_RETURN(MapProcessCodeMemory(system, process_handle, dst_address, src_address, size));
|
||||
}
|
||||
|
||||
Result UnmapProcessCodeMemory64(Core::System& system, Handle process_handle, uint64_t dst_address,
|
||||
uint64_t src_address, uint64_t size) {
|
||||
R_RETURN(UnmapProcessCodeMemory(system, process_handle, dst_address, src_address, size));
|
||||
}
|
||||
|
||||
Result SetProcessMemoryPermission64From32(Core::System& system, Handle process_handle,
|
||||
uint64_t address, uint64_t size, MemoryPermission perm) {
|
||||
R_RETURN(SetProcessMemoryPermission(system, process_handle, address, size, perm));
|
||||
}
|
||||
|
||||
Result MapProcessMemory64From32(Core::System& system, uint32_t dst_address, Handle process_handle,
|
||||
uint64_t src_address, uint32_t size) {
|
||||
R_RETURN(MapProcessMemory(system, dst_address, process_handle, src_address, size));
|
||||
}
|
||||
|
||||
Result UnmapProcessMemory64From32(Core::System& system, uint32_t dst_address, Handle process_handle,
|
||||
uint64_t src_address, uint32_t size) {
|
||||
R_RETURN(UnmapProcessMemory(system, dst_address, process_handle, src_address, size));
|
||||
}
|
||||
|
||||
Result MapProcessCodeMemory64From32(Core::System& system, Handle process_handle,
|
||||
uint64_t dst_address, uint64_t src_address, uint64_t size) {
|
||||
R_RETURN(MapProcessCodeMemory(system, process_handle, dst_address, src_address, size));
|
||||
}
|
||||
|
||||
Result UnmapProcessCodeMemory64From32(Core::System& system, Handle process_handle,
|
||||
uint64_t dst_address, uint64_t src_address, uint64_t size) {
|
||||
R_RETURN(UnmapProcessCodeMemory(system, process_handle, dst_address, src_address, size));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
25
src/core/hle/kernel/svc/svc_processor.cpp
Executable file
25
src/core/hle/kernel/svc/svc_processor.cpp
Executable file
|
|
@ -0,0 +1,25 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/logging/log.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/physical_core.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Get which CPU core is executing the current thread
|
||||
int32_t GetCurrentProcessorNumber(Core::System& system) {
|
||||
LOG_TRACE(Kernel_SVC, "called");
|
||||
return static_cast<int32_t>(system.CurrentPhysicalCore().CoreIndex());
|
||||
}
|
||||
|
||||
int32_t GetCurrentProcessorNumber64(Core::System& system) {
|
||||
return GetCurrentProcessorNumber(system);
|
||||
}
|
||||
|
||||
int32_t GetCurrentProcessorNumber64From32(Core::System& system) {
|
||||
return GetCurrentProcessorNumber(system);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
65
src/core/hle/kernel/svc/svc_query_memory.cpp
Executable file
65
src/core/hle/kernel/svc/svc_query_memory.cpp
Executable file
|
|
@ -0,0 +1,65 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result QueryMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info,
|
||||
VAddr query_address) {
|
||||
LOG_TRACE(Kernel_SVC,
|
||||
"called, out_memory_info=0x{:016X}, "
|
||||
"query_address=0x{:016X}",
|
||||
out_memory_info, query_address);
|
||||
|
||||
// Query memory is just QueryProcessMemory on the current process.
|
||||
return QueryProcessMemory(system, out_memory_info, out_page_info, CurrentProcess,
|
||||
query_address);
|
||||
}
|
||||
|
||||
Result QueryProcessMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info,
|
||||
Handle process_handle, uint64_t address) {
|
||||
LOG_TRACE(Kernel_SVC, "called process=0x{:08X} address={:X}", process_handle, address);
|
||||
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
||||
KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
|
||||
if (process.IsNull()) {
|
||||
LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
|
||||
process_handle);
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
auto& memory{system.Memory()};
|
||||
const auto memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()};
|
||||
|
||||
memory.WriteBlock(out_memory_info, &memory_info, sizeof(memory_info));
|
||||
|
||||
//! This is supposed to be part of the QueryInfo call.
|
||||
*out_page_info = {};
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result QueryMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info,
|
||||
uint64_t address) {
|
||||
R_RETURN(QueryMemory(system, out_memory_info, out_page_info, address));
|
||||
}
|
||||
|
||||
Result QueryProcessMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info,
|
||||
Handle process_handle, uint64_t address) {
|
||||
R_RETURN(QueryProcessMemory(system, out_memory_info, out_page_info, process_handle, address));
|
||||
}
|
||||
|
||||
Result QueryMemory64From32(Core::System& system, uint32_t out_memory_info, PageInfo* out_page_info,
|
||||
uint32_t address) {
|
||||
R_RETURN(QueryMemory(system, out_memory_info, out_page_info, address));
|
||||
}
|
||||
|
||||
Result QueryProcessMemory64From32(Core::System& system, uint32_t out_memory_info,
|
||||
PageInfo* out_page_info, Handle process_handle,
|
||||
uint64_t address) {
|
||||
R_RETURN(QueryProcessMemory(system, out_memory_info, out_page_info, process_handle, address));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
27
src/core/hle/kernel/svc/svc_register.cpp
Executable file
27
src/core/hle/kernel/svc/svc_register.cpp
Executable file
|
|
@ -0,0 +1,27 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result ReadWriteRegister(Core::System& system, uint32_t* out, uint64_t address, uint32_t mask,
|
||||
uint32_t value) {
|
||||
*out = 0;
|
||||
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result ReadWriteRegister64(Core::System& system, uint32_t* out_value, uint64_t address,
|
||||
uint32_t mask, uint32_t value) {
|
||||
R_RETURN(ReadWriteRegister(system, out_value, address, mask, value));
|
||||
}
|
||||
|
||||
Result ReadWriteRegister64From32(Core::System& system, uint32_t* out_value, uint64_t address,
|
||||
uint32_t mask, uint32_t value) {
|
||||
R_RETURN(ReadWriteRegister(system, out_value, address, mask, value));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
149
src/core/hle/kernel/svc/svc_resource_limit.cpp
Executable file
149
src/core/hle/kernel/svc/svc_resource_limit.cpp
Executable file
|
|
@ -0,0 +1,149 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_resource_limit.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result CreateResourceLimit(Core::System& system, Handle* out_handle) {
|
||||
LOG_DEBUG(Kernel_SVC, "called");
|
||||
|
||||
// Create a new resource limit.
|
||||
auto& kernel = system.Kernel();
|
||||
KResourceLimit* resource_limit = KResourceLimit::Create(kernel);
|
||||
R_UNLESS(resource_limit != nullptr, ResultOutOfResource);
|
||||
|
||||
// Ensure we don't leak a reference to the limit.
|
||||
SCOPE_EXIT({ resource_limit->Close(); });
|
||||
|
||||
// Initialize the resource limit.
|
||||
resource_limit->Initialize(&system.CoreTiming());
|
||||
|
||||
// Register the limit.
|
||||
KResourceLimit::Register(kernel, resource_limit);
|
||||
|
||||
// Add the limit to the handle table.
|
||||
R_TRY(kernel.CurrentProcess()->GetHandleTable().Add(out_handle, resource_limit));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result GetResourceLimitLimitValue(Core::System& system, s64* out_limit_value,
|
||||
Handle resource_limit_handle, LimitableResource which) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, resource_limit_handle={:08X}, which={}", resource_limit_handle,
|
||||
which);
|
||||
|
||||
// Validate the resource.
|
||||
R_UNLESS(IsValidResourceType(which), ResultInvalidEnumValue);
|
||||
|
||||
// Get the resource limit.
|
||||
auto& kernel = system.Kernel();
|
||||
KScopedAutoObject resource_limit =
|
||||
kernel.CurrentProcess()->GetHandleTable().GetObject<KResourceLimit>(resource_limit_handle);
|
||||
R_UNLESS(resource_limit.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the limit value.
|
||||
*out_limit_value = resource_limit->GetLimitValue(which);
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result GetResourceLimitCurrentValue(Core::System& system, s64* out_current_value,
|
||||
Handle resource_limit_handle, LimitableResource which) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, resource_limit_handle={:08X}, which={}", resource_limit_handle,
|
||||
which);
|
||||
|
||||
// Validate the resource.
|
||||
R_UNLESS(IsValidResourceType(which), ResultInvalidEnumValue);
|
||||
|
||||
// Get the resource limit.
|
||||
auto& kernel = system.Kernel();
|
||||
KScopedAutoObject resource_limit =
|
||||
kernel.CurrentProcess()->GetHandleTable().GetObject<KResourceLimit>(resource_limit_handle);
|
||||
R_UNLESS(resource_limit.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the current value.
|
||||
*out_current_value = resource_limit->GetCurrentValue(which);
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result SetResourceLimitLimitValue(Core::System& system, Handle resource_limit_handle,
|
||||
LimitableResource which, s64 limit_value) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, resource_limit_handle={:08X}, which={}, limit_value={}",
|
||||
resource_limit_handle, which, limit_value);
|
||||
|
||||
// Validate the resource.
|
||||
R_UNLESS(IsValidResourceType(which), ResultInvalidEnumValue);
|
||||
|
||||
// Get the resource limit.
|
||||
auto& kernel = system.Kernel();
|
||||
KScopedAutoObject resource_limit =
|
||||
kernel.CurrentProcess()->GetHandleTable().GetObject<KResourceLimit>(resource_limit_handle);
|
||||
R_UNLESS(resource_limit.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Set the limit value.
|
||||
R_TRY(resource_limit->SetLimitValue(which, limit_value));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result GetResourceLimitPeakValue(Core::System& system, int64_t* out_peak_value,
|
||||
Handle resource_limit_handle, LimitableResource which) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result GetResourceLimitLimitValue64(Core::System& system, int64_t* out_limit_value,
|
||||
Handle resource_limit_handle, LimitableResource which) {
|
||||
R_RETURN(GetResourceLimitLimitValue(system, out_limit_value, resource_limit_handle, which));
|
||||
}
|
||||
|
||||
Result GetResourceLimitCurrentValue64(Core::System& system, int64_t* out_current_value,
|
||||
Handle resource_limit_handle, LimitableResource which) {
|
||||
R_RETURN(GetResourceLimitCurrentValue(system, out_current_value, resource_limit_handle, which));
|
||||
}
|
||||
|
||||
Result GetResourceLimitPeakValue64(Core::System& system, int64_t* out_peak_value,
|
||||
Handle resource_limit_handle, LimitableResource which) {
|
||||
R_RETURN(GetResourceLimitPeakValue(system, out_peak_value, resource_limit_handle, which));
|
||||
}
|
||||
|
||||
Result CreateResourceLimit64(Core::System& system, Handle* out_handle) {
|
||||
R_RETURN(CreateResourceLimit(system, out_handle));
|
||||
}
|
||||
|
||||
Result SetResourceLimitLimitValue64(Core::System& system, Handle resource_limit_handle,
|
||||
LimitableResource which, int64_t limit_value) {
|
||||
R_RETURN(SetResourceLimitLimitValue(system, resource_limit_handle, which, limit_value));
|
||||
}
|
||||
|
||||
Result GetResourceLimitLimitValue64From32(Core::System& system, int64_t* out_limit_value,
|
||||
Handle resource_limit_handle, LimitableResource which) {
|
||||
R_RETURN(GetResourceLimitLimitValue(system, out_limit_value, resource_limit_handle, which));
|
||||
}
|
||||
|
||||
Result GetResourceLimitCurrentValue64From32(Core::System& system, int64_t* out_current_value,
|
||||
Handle resource_limit_handle, LimitableResource which) {
|
||||
R_RETURN(GetResourceLimitCurrentValue(system, out_current_value, resource_limit_handle, which));
|
||||
}
|
||||
|
||||
Result GetResourceLimitPeakValue64From32(Core::System& system, int64_t* out_peak_value,
|
||||
Handle resource_limit_handle, LimitableResource which) {
|
||||
R_RETURN(GetResourceLimitPeakValue(system, out_peak_value, resource_limit_handle, which));
|
||||
}
|
||||
|
||||
Result CreateResourceLimit64From32(Core::System& system, Handle* out_handle) {
|
||||
R_RETURN(CreateResourceLimit(system, out_handle));
|
||||
}
|
||||
|
||||
Result SetResourceLimitLimitValue64From32(Core::System& system, Handle resource_limit_handle,
|
||||
LimitableResource which, int64_t limit_value) {
|
||||
R_RETURN(SetResourceLimitLimitValue(system, resource_limit_handle, which, limit_value));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
53
src/core/hle/kernel/svc/svc_secure_monitor_call.cpp
Executable file
53
src/core/hle/kernel/svc/svc_secure_monitor_call.cpp
Executable file
|
|
@ -0,0 +1,53 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/physical_core.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
void CallSecureMonitor(Core::System& system, lp64::SecureMonitorArguments* args) {
|
||||
UNIMPLEMENTED();
|
||||
}
|
||||
|
||||
void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args) {
|
||||
CallSecureMonitor(system, args);
|
||||
}
|
||||
|
||||
void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArguments* args) {
|
||||
// CallSecureMonitor64From32 is not supported.
|
||||
UNIMPLEMENTED_MSG("CallSecureMonitor64From32");
|
||||
}
|
||||
|
||||
// Custom ABI for CallSecureMonitor.
|
||||
|
||||
void SvcWrap_CallSecureMonitor64(Core::System& system) {
|
||||
auto& core = system.CurrentPhysicalCore().ArmInterface();
|
||||
lp64::SecureMonitorArguments args{};
|
||||
for (int i = 0; i < 8; i++) {
|
||||
args.r[i] = core.GetReg(i);
|
||||
}
|
||||
|
||||
CallSecureMonitor64(system, &args);
|
||||
|
||||
for (int i = 0; i < 8; i++) {
|
||||
core.SetReg(i, args.r[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void SvcWrap_CallSecureMonitor64From32(Core::System& system) {
|
||||
auto& core = system.CurrentPhysicalCore().ArmInterface();
|
||||
ilp32::SecureMonitorArguments args{};
|
||||
for (int i = 0; i < 8; i++) {
|
||||
args.r[i] = static_cast<u32>(core.GetReg(i));
|
||||
}
|
||||
|
||||
CallSecureMonitor64From32(system, &args);
|
||||
|
||||
for (int i = 0; i < 8; i++) {
|
||||
core.SetReg(i, args.r[i]);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
128
src/core/hle/kernel/svc/svc_session.cpp
Executable file
128
src/core/hle/kernel/svc/svc_session.cpp
Executable file
|
|
@ -0,0 +1,128 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
||||
#include "core/hle/kernel/k_session.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
namespace {
|
||||
|
||||
template <typename T>
|
||||
Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, u64 name) {
|
||||
auto& process = *system.CurrentProcess();
|
||||
auto& handle_table = process.GetHandleTable();
|
||||
|
||||
// Declare the session we're going to allocate.
|
||||
T* session;
|
||||
|
||||
// Reserve a new session from the process resource limit.
|
||||
// FIXME: LimitableResource_SessionCountMax
|
||||
KScopedResourceReservation session_reservation(&process, LimitableResource::SessionCountMax);
|
||||
if (session_reservation.Succeeded()) {
|
||||
session = T::Create(system.Kernel());
|
||||
} else {
|
||||
return ResultLimitReached;
|
||||
|
||||
// // We couldn't reserve a session. Check that we support dynamically expanding the
|
||||
// // resource limit.
|
||||
// R_UNLESS(process.GetResourceLimit() ==
|
||||
// &system.Kernel().GetSystemResourceLimit(), ResultLimitReached);
|
||||
// R_UNLESS(KTargetSystem::IsDynamicResourceLimitsEnabled(), ResultLimitReached());
|
||||
|
||||
// // Try to allocate a session from unused slab memory.
|
||||
// session = T::CreateFromUnusedSlabMemory();
|
||||
// R_UNLESS(session != nullptr, ResultLimitReached);
|
||||
// ON_RESULT_FAILURE { session->Close(); };
|
||||
|
||||
// // If we're creating a KSession, we want to add two KSessionRequests to the heap, to
|
||||
// // prevent request exhaustion.
|
||||
// // NOTE: Nintendo checks if session->DynamicCast<KSession *>() != nullptr, but there's
|
||||
// // no reason to not do this statically.
|
||||
// if constexpr (std::same_as<T, KSession>) {
|
||||
// for (size_t i = 0; i < 2; i++) {
|
||||
// KSessionRequest* request = KSessionRequest::CreateFromUnusedSlabMemory();
|
||||
// R_UNLESS(request != nullptr, ResultLimitReached);
|
||||
// request->Close();
|
||||
// }
|
||||
// }
|
||||
|
||||
// We successfully allocated a session, so add the object we allocated to the resource
|
||||
// limit.
|
||||
// system.Kernel().GetSystemResourceLimit().Reserve(LimitableResource::SessionCountMax, 1);
|
||||
}
|
||||
|
||||
// Check that we successfully created a session.
|
||||
R_UNLESS(session != nullptr, ResultOutOfResource);
|
||||
|
||||
// Initialize the session.
|
||||
session->Initialize(nullptr, fmt::format("{}", name));
|
||||
|
||||
// Commit the session reservation.
|
||||
session_reservation.Commit();
|
||||
|
||||
// Ensure that we clean up the session (and its only references are handle table) on function
|
||||
// end.
|
||||
SCOPE_EXIT({
|
||||
session->GetClientSession().Close();
|
||||
session->GetServerSession().Close();
|
||||
});
|
||||
|
||||
// Register the session.
|
||||
T::Register(system.Kernel(), session);
|
||||
|
||||
// Add the server session to the handle table.
|
||||
R_TRY(handle_table.Add(out_server, &session->GetServerSession()));
|
||||
|
||||
// Add the client session to the handle table.
|
||||
const auto result = handle_table.Add(out_client, &session->GetClientSession());
|
||||
|
||||
if (!R_SUCCEEDED(result)) {
|
||||
// Ensure that we maintaing a clean handle state on exit.
|
||||
handle_table.Remove(*out_server);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, bool is_light,
|
||||
u64 name) {
|
||||
if (is_light) {
|
||||
// return CreateSession<KLightSession>(system, out_server, out_client, name);
|
||||
return ResultNotImplemented;
|
||||
} else {
|
||||
return CreateSession<KSession>(system, out_server, out_client, name);
|
||||
}
|
||||
}
|
||||
|
||||
Result AcceptSession(Core::System& system, Handle* out_handle, Handle port_handle) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result CreateSession64(Core::System& system, Handle* out_server_session_handle,
|
||||
Handle* out_client_session_handle, bool is_light, uint64_t name) {
|
||||
R_RETURN(CreateSession(system, out_server_session_handle, out_client_session_handle, is_light,
|
||||
name));
|
||||
}
|
||||
|
||||
Result AcceptSession64(Core::System& system, Handle* out_handle, Handle port) {
|
||||
R_RETURN(AcceptSession(system, out_handle, port));
|
||||
}
|
||||
|
||||
Result CreateSession64From32(Core::System& system, Handle* out_server_session_handle,
|
||||
Handle* out_client_session_handle, bool is_light, uint32_t name) {
|
||||
R_RETURN(CreateSession(system, out_server_session_handle, out_client_session_handle, is_light,
|
||||
name));
|
||||
}
|
||||
|
||||
Result AcceptSession64From32(Core::System& system, Handle* out_handle, Handle port) {
|
||||
R_RETURN(AcceptSession(system, out_handle, port));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
133
src/core/hle/kernel/svc/svc_shared_memory.cpp
Executable file
133
src/core/hle/kernel/svc/svc_shared_memory.cpp
Executable file
|
|
@ -0,0 +1,133 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_shared_memory.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
namespace {
|
||||
|
||||
constexpr bool IsValidSharedMemoryPermission(MemoryPermission perm) {
|
||||
switch (perm) {
|
||||
case MemoryPermission::Read:
|
||||
case MemoryPermission::ReadWrite:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
[[maybe_unused]] constexpr bool IsValidRemoteSharedMemoryPermission(MemoryPermission perm) {
|
||||
return IsValidSharedMemoryPermission(perm) || perm == MemoryPermission::DontCare;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
Result MapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address, u64 size,
|
||||
Svc::MemoryPermission map_perm) {
|
||||
LOG_TRACE(Kernel_SVC,
|
||||
"called, shared_memory_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
|
||||
shmem_handle, address, size, map_perm);
|
||||
|
||||
// Validate the address/size.
|
||||
R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Validate the permission.
|
||||
R_UNLESS(IsValidSharedMemoryPermission(map_perm), ResultInvalidNewMemoryPermission);
|
||||
|
||||
// Get the current process.
|
||||
auto& process = *system.Kernel().CurrentProcess();
|
||||
auto& page_table = process.PageTable();
|
||||
|
||||
// Get the shared memory.
|
||||
KScopedAutoObject shmem = process.GetHandleTable().GetObject<KSharedMemory>(shmem_handle);
|
||||
R_UNLESS(shmem.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Verify that the mapping is in range.
|
||||
R_UNLESS(page_table.CanContain(address, size, KMemoryState::Shared), ResultInvalidMemoryRegion);
|
||||
|
||||
// Add the shared memory to the process.
|
||||
R_TRY(process.AddSharedMemory(shmem.GetPointerUnsafe(), address, size));
|
||||
|
||||
// Ensure that we clean up the shared memory if we fail to map it.
|
||||
auto guard =
|
||||
SCOPE_GUARD({ process.RemoveSharedMemory(shmem.GetPointerUnsafe(), address, size); });
|
||||
|
||||
// Map the shared memory.
|
||||
R_TRY(shmem->Map(process, address, size, map_perm));
|
||||
|
||||
// We succeeded.
|
||||
guard.Cancel();
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result UnmapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address, u64 size) {
|
||||
// Validate the address/size.
|
||||
R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Get the current process.
|
||||
auto& process = *system.Kernel().CurrentProcess();
|
||||
auto& page_table = process.PageTable();
|
||||
|
||||
// Get the shared memory.
|
||||
KScopedAutoObject shmem = process.GetHandleTable().GetObject<KSharedMemory>(shmem_handle);
|
||||
R_UNLESS(shmem.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Verify that the mapping is in range.
|
||||
R_UNLESS(page_table.CanContain(address, size, KMemoryState::Shared), ResultInvalidMemoryRegion);
|
||||
|
||||
// Unmap the shared memory.
|
||||
R_TRY(shmem->Unmap(process, address, size));
|
||||
|
||||
// Remove the shared memory from the process.
|
||||
process.RemoveSharedMemory(shmem.GetPointerUnsafe(), address, size);
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result CreateSharedMemory(Core::System& system, Handle* out_handle, uint64_t size,
|
||||
MemoryPermission owner_perm, MemoryPermission remote_perm) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result MapSharedMemory64(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size,
|
||||
MemoryPermission map_perm) {
|
||||
R_RETURN(MapSharedMemory(system, shmem_handle, address, size, map_perm));
|
||||
}
|
||||
|
||||
Result UnmapSharedMemory64(Core::System& system, Handle shmem_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
R_RETURN(UnmapSharedMemory(system, shmem_handle, address, size));
|
||||
}
|
||||
|
||||
Result CreateSharedMemory64(Core::System& system, Handle* out_handle, uint64_t size,
|
||||
MemoryPermission owner_perm, MemoryPermission remote_perm) {
|
||||
R_RETURN(CreateSharedMemory(system, out_handle, size, owner_perm, remote_perm));
|
||||
}
|
||||
|
||||
Result MapSharedMemory64From32(Core::System& system, Handle shmem_handle, uint32_t address,
|
||||
uint32_t size, MemoryPermission map_perm) {
|
||||
R_RETURN(MapSharedMemory(system, shmem_handle, address, size, map_perm));
|
||||
}
|
||||
|
||||
Result UnmapSharedMemory64From32(Core::System& system, Handle shmem_handle, uint32_t address,
|
||||
uint32_t size) {
|
||||
R_RETURN(UnmapSharedMemory(system, shmem_handle, address, size));
|
||||
}
|
||||
|
||||
Result CreateSharedMemory64From32(Core::System& system, Handle* out_handle, uint32_t size,
|
||||
MemoryPermission owner_perm, MemoryPermission remote_perm) {
|
||||
R_RETURN(CreateSharedMemory(system, out_handle, size, owner_perm, remote_perm));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
163
src/core/hle/kernel/svc/svc_synchronization.cpp
Executable file
163
src/core/hle/kernel/svc/svc_synchronization.cpp
Executable file
|
|
@ -0,0 +1,163 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_readable_event.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// Close a handle
|
||||
Result CloseHandle(Core::System& system, Handle handle) {
|
||||
LOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);
|
||||
|
||||
// Remove the handle.
|
||||
R_UNLESS(system.Kernel().CurrentProcess()->GetHandleTable().Remove(handle),
|
||||
ResultInvalidHandle);
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
/// Clears the signaled state of an event or process.
|
||||
Result ResetSignal(Core::System& system, Handle handle) {
|
||||
LOG_DEBUG(Kernel_SVC, "called handle 0x{:08X}", handle);
|
||||
|
||||
// Get the current handle table.
|
||||
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
||||
|
||||
// Try to reset as readable event.
|
||||
{
|
||||
KScopedAutoObject readable_event = handle_table.GetObject<KReadableEvent>(handle);
|
||||
if (readable_event.IsNotNull()) {
|
||||
return readable_event->Reset();
|
||||
}
|
||||
}
|
||||
|
||||
// Try to reset as process.
|
||||
{
|
||||
KScopedAutoObject process = handle_table.GetObject<KProcess>(handle);
|
||||
if (process.IsNotNull()) {
|
||||
return process->Reset();
|
||||
}
|
||||
}
|
||||
|
||||
LOG_ERROR(Kernel_SVC, "invalid handle (0x{:08X})", handle);
|
||||
|
||||
return ResultInvalidHandle;
|
||||
}
|
||||
|
||||
/// Wait for the given handles to synchronize, timeout after the specified nanoseconds
|
||||
Result WaitSynchronization(Core::System& system, s32* index, VAddr handles_address, s32 num_handles,
|
||||
s64 nano_seconds) {
|
||||
LOG_TRACE(Kernel_SVC, "called handles_address=0x{:X}, num_handles={}, nano_seconds={}",
|
||||
handles_address, num_handles, nano_seconds);
|
||||
|
||||
// Ensure number of handles is valid.
|
||||
R_UNLESS(0 <= num_handles && num_handles <= ArgumentHandleCountMax, ResultOutOfRange);
|
||||
|
||||
auto& kernel = system.Kernel();
|
||||
std::vector<KSynchronizationObject*> objs(num_handles);
|
||||
const auto& handle_table = kernel.CurrentProcess()->GetHandleTable();
|
||||
Handle* handles = system.Memory().GetPointer<Handle>(handles_address);
|
||||
|
||||
// Copy user handles.
|
||||
if (num_handles > 0) {
|
||||
// Convert the handles to objects.
|
||||
R_UNLESS(handle_table.GetMultipleObjects<KSynchronizationObject>(objs.data(), handles,
|
||||
num_handles),
|
||||
ResultInvalidHandle);
|
||||
for (const auto& obj : objs) {
|
||||
kernel.RegisterInUseObject(obj);
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure handles are closed when we're done.
|
||||
SCOPE_EXIT({
|
||||
for (s32 i = 0; i < num_handles; ++i) {
|
||||
kernel.UnregisterInUseObject(objs[i]);
|
||||
objs[i]->Close();
|
||||
}
|
||||
});
|
||||
|
||||
return KSynchronizationObject::Wait(kernel, index, objs.data(), static_cast<s32>(objs.size()),
|
||||
nano_seconds);
|
||||
}
|
||||
|
||||
/// Resumes a thread waiting on WaitSynchronization
|
||||
Result CancelSynchronization(Core::System& system, Handle handle) {
|
||||
LOG_TRACE(Kernel_SVC, "called handle=0x{:X}", handle);
|
||||
|
||||
// Get the thread from its handle.
|
||||
KScopedAutoObject thread =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(handle);
|
||||
R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Cancel the thread's wait.
|
||||
thread->WaitCancel();
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
void SynchronizePreemptionState(Core::System& system) {
|
||||
auto& kernel = system.Kernel();
|
||||
|
||||
// Lock the scheduler.
|
||||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
// If the current thread is pinned, unpin it.
|
||||
KProcess* cur_process = system.Kernel().CurrentProcess();
|
||||
const auto core_id = GetCurrentCoreId(kernel);
|
||||
|
||||
if (cur_process->GetPinnedThread(core_id) == GetCurrentThreadPointer(kernel)) {
|
||||
// Clear the current thread's interrupt flag.
|
||||
GetCurrentThread(kernel).ClearInterruptFlag();
|
||||
|
||||
// Unpin the current thread.
|
||||
cur_process->UnpinCurrentThread(core_id);
|
||||
}
|
||||
}
|
||||
|
||||
Result CloseHandle64(Core::System& system, Handle handle) {
|
||||
R_RETURN(CloseHandle(system, handle));
|
||||
}
|
||||
|
||||
Result ResetSignal64(Core::System& system, Handle handle) {
|
||||
R_RETURN(ResetSignal(system, handle));
|
||||
}
|
||||
|
||||
Result WaitSynchronization64(Core::System& system, int32_t* out_index, uint64_t handles,
|
||||
int32_t num_handles, int64_t timeout_ns) {
|
||||
R_RETURN(WaitSynchronization(system, out_index, handles, num_handles, timeout_ns));
|
||||
}
|
||||
|
||||
Result CancelSynchronization64(Core::System& system, Handle handle) {
|
||||
R_RETURN(CancelSynchronization(system, handle));
|
||||
}
|
||||
|
||||
void SynchronizePreemptionState64(Core::System& system) {
|
||||
SynchronizePreemptionState(system);
|
||||
}
|
||||
|
||||
Result CloseHandle64From32(Core::System& system, Handle handle) {
|
||||
R_RETURN(CloseHandle(system, handle));
|
||||
}
|
||||
|
||||
Result ResetSignal64From32(Core::System& system, Handle handle) {
|
||||
R_RETURN(ResetSignal(system, handle));
|
||||
}
|
||||
|
||||
Result WaitSynchronization64From32(Core::System& system, int32_t* out_index, uint32_t handles,
|
||||
int32_t num_handles, int64_t timeout_ns) {
|
||||
R_RETURN(WaitSynchronization(system, out_index, handles, num_handles, timeout_ns));
|
||||
}
|
||||
|
||||
Result CancelSynchronization64From32(Core::System& system, Handle handle) {
|
||||
R_RETURN(CancelSynchronization(system, handle));
|
||||
}
|
||||
|
||||
void SynchronizePreemptionState64From32(Core::System& system) {
|
||||
SynchronizePreemptionState(system);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
437
src/core/hle/kernel/svc/svc_thread.cpp
Executable file
437
src/core/hle/kernel/svc/svc_thread.cpp
Executable file
|
|
@ -0,0 +1,437 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/core_timing.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
||||
#include "core/hle/kernel/k_thread.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
namespace {
|
||||
|
||||
constexpr bool IsValidVirtualCoreId(int32_t core_id) {
|
||||
return (0 <= core_id && core_id < static_cast<int32_t>(Core::Hardware::NUM_CPU_CORES));
|
||||
}
|
||||
|
||||
} // Anonymous namespace
|
||||
|
||||
/// Creates a new thread
|
||||
Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point, u64 arg,
|
||||
VAddr stack_bottom, s32 priority, s32 core_id) {
|
||||
LOG_DEBUG(Kernel_SVC,
|
||||
"called entry_point=0x{:08X}, arg=0x{:08X}, stack_bottom=0x{:08X}, "
|
||||
"priority=0x{:08X}, core_id=0x{:08X}",
|
||||
entry_point, arg, stack_bottom, priority, core_id);
|
||||
|
||||
// Adjust core id, if it's the default magic.
|
||||
auto& kernel = system.Kernel();
|
||||
auto& process = *kernel.CurrentProcess();
|
||||
if (core_id == IdealCoreUseProcessValue) {
|
||||
core_id = process.GetIdealCoreId();
|
||||
}
|
||||
|
||||
// Validate arguments.
|
||||
if (!IsValidVirtualCoreId(core_id)) {
|
||||
LOG_ERROR(Kernel_SVC, "Invalid Core ID specified (id={})", core_id);
|
||||
return ResultInvalidCoreId;
|
||||
}
|
||||
if (((1ULL << core_id) & process.GetCoreMask()) == 0) {
|
||||
LOG_ERROR(Kernel_SVC, "Core ID doesn't fall within allowable cores (id={})", core_id);
|
||||
return ResultInvalidCoreId;
|
||||
}
|
||||
|
||||
if (HighestThreadPriority > priority || priority > LowestThreadPriority) {
|
||||
LOG_ERROR(Kernel_SVC, "Invalid priority specified (priority={})", priority);
|
||||
return ResultInvalidPriority;
|
||||
}
|
||||
if (!process.CheckThreadPriority(priority)) {
|
||||
LOG_ERROR(Kernel_SVC, "Invalid allowable thread priority (priority={})", priority);
|
||||
return ResultInvalidPriority;
|
||||
}
|
||||
|
||||
// Reserve a new thread from the process resource limit (waiting up to 100ms).
|
||||
KScopedResourceReservation thread_reservation(
|
||||
kernel.CurrentProcess(), LimitableResource::ThreadCountMax, 1,
|
||||
system.CoreTiming().GetGlobalTimeNs().count() + 100000000);
|
||||
if (!thread_reservation.Succeeded()) {
|
||||
LOG_ERROR(Kernel_SVC, "Could not reserve a new thread");
|
||||
return ResultLimitReached;
|
||||
}
|
||||
|
||||
// Create the thread.
|
||||
KThread* thread = KThread::Create(kernel);
|
||||
if (!thread) {
|
||||
LOG_ERROR(Kernel_SVC, "Unable to create new threads. Thread creation limit reached.");
|
||||
return ResultOutOfResource;
|
||||
}
|
||||
SCOPE_EXIT({ thread->Close(); });
|
||||
|
||||
// Initialize the thread.
|
||||
{
|
||||
KScopedLightLock lk{process.GetStateLock()};
|
||||
R_TRY(KThread::InitializeUserThread(system, thread, entry_point, arg, stack_bottom,
|
||||
priority, core_id, &process));
|
||||
}
|
||||
|
||||
// Set the thread name for debugging purposes.
|
||||
thread->SetName(fmt::format("thread[entry_point={:X}, handle={:X}]", entry_point, *out_handle));
|
||||
|
||||
// Commit the thread reservation.
|
||||
thread_reservation.Commit();
|
||||
|
||||
// Register the new thread.
|
||||
KThread::Register(kernel, thread);
|
||||
|
||||
// Add the thread to the handle table.
|
||||
R_TRY(process.GetHandleTable().Add(out_handle, thread));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
/// Starts the thread for the provided handle
|
||||
Result StartThread(Core::System& system, Handle thread_handle) {
|
||||
LOG_DEBUG(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
|
||||
|
||||
// Get the thread from its handle.
|
||||
KScopedAutoObject thread =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
|
||||
R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Try to start the thread.
|
||||
R_TRY(thread->Run());
|
||||
|
||||
// If we succeeded, persist a reference to the thread.
|
||||
thread->Open();
|
||||
system.Kernel().RegisterInUseObject(thread.GetPointerUnsafe());
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
/// Called when a thread exits
|
||||
void ExitThread(Core::System& system) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, pc=0x{:08X}", system.CurrentArmInterface().GetPC());
|
||||
|
||||
auto* const current_thread = GetCurrentThreadPointer(system.Kernel());
|
||||
system.GlobalSchedulerContext().RemoveThread(current_thread);
|
||||
current_thread->Exit();
|
||||
system.Kernel().UnregisterInUseObject(current_thread);
|
||||
}
|
||||
|
||||
/// Sleep the current thread
|
||||
void SleepThread(Core::System& system, s64 nanoseconds) {
|
||||
auto& kernel = system.Kernel();
|
||||
const auto yield_type = static_cast<Svc::YieldType>(nanoseconds);
|
||||
|
||||
LOG_TRACE(Kernel_SVC, "called nanoseconds={}", nanoseconds);
|
||||
|
||||
// When the input tick is positive, sleep.
|
||||
if (nanoseconds > 0) {
|
||||
// Convert the timeout from nanoseconds to ticks.
|
||||
// NOTE: Nintendo does not use this conversion logic in WaitSynchronization...
|
||||
|
||||
// Sleep.
|
||||
// NOTE: Nintendo does not check the result of this sleep.
|
||||
static_cast<void>(GetCurrentThread(kernel).Sleep(nanoseconds));
|
||||
} else if (yield_type == Svc::YieldType::WithoutCoreMigration) {
|
||||
KScheduler::YieldWithoutCoreMigration(kernel);
|
||||
} else if (yield_type == Svc::YieldType::WithCoreMigration) {
|
||||
KScheduler::YieldWithCoreMigration(kernel);
|
||||
} else if (yield_type == Svc::YieldType::ToAnyThread) {
|
||||
KScheduler::YieldToAnyThread(kernel);
|
||||
} else {
|
||||
// Nintendo does nothing at all if an otherwise invalid value is passed.
|
||||
ASSERT_MSG(false, "Unimplemented sleep yield type '{:016X}'!", nanoseconds);
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets the thread context
|
||||
Result GetThreadContext3(Core::System& system, VAddr out_context, Handle thread_handle) {
|
||||
LOG_DEBUG(Kernel_SVC, "called, out_context=0x{:08X}, thread_handle=0x{:X}", out_context,
|
||||
thread_handle);
|
||||
|
||||
auto& kernel = system.Kernel();
|
||||
|
||||
// Get the thread from its handle.
|
||||
KScopedAutoObject thread =
|
||||
kernel.CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
|
||||
R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Require the handle be to a non-current thread in the current process.
|
||||
const auto* current_process = kernel.CurrentProcess();
|
||||
R_UNLESS(current_process == thread->GetOwnerProcess(), ResultInvalidId);
|
||||
|
||||
// Verify that the thread isn't terminated.
|
||||
R_UNLESS(thread->GetState() != ThreadState::Terminated, ResultTerminationRequested);
|
||||
|
||||
/// Check that the thread is not the current one.
|
||||
/// NOTE: Nintendo does not check this, and thus the following loop will deadlock.
|
||||
R_UNLESS(thread.GetPointerUnsafe() != GetCurrentThreadPointer(kernel), ResultInvalidId);
|
||||
|
||||
// Try to get the thread context until the thread isn't current on any core.
|
||||
while (true) {
|
||||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
// TODO(bunnei): Enforce that thread is suspended for debug here.
|
||||
|
||||
// If the thread's raw state isn't runnable, check if it's current on some core.
|
||||
if (thread->GetRawState() != ThreadState::Runnable) {
|
||||
bool current = false;
|
||||
for (auto i = 0; i < static_cast<s32>(Core::Hardware::NUM_CPU_CORES); ++i) {
|
||||
if (thread.GetPointerUnsafe() == kernel.Scheduler(i).GetSchedulerCurrentThread()) {
|
||||
current = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// If the thread is current, retry until it isn't.
|
||||
if (current) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// Get the thread context.
|
||||
std::vector<u8> context;
|
||||
R_TRY(thread->GetThreadContext3(context));
|
||||
|
||||
// Copy the thread context to user space.
|
||||
system.Memory().WriteBlock(out_context, context.data(), context.size());
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
/// Gets the priority for the specified thread
|
||||
Result GetThreadPriority(Core::System& system, s32* out_priority, Handle handle) {
|
||||
LOG_TRACE(Kernel_SVC, "called");
|
||||
|
||||
// Get the thread from its handle.
|
||||
KScopedAutoObject thread =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(handle);
|
||||
R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the thread's priority.
|
||||
*out_priority = thread->GetPriority();
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
/// Sets the priority for the specified thread
|
||||
Result SetThreadPriority(Core::System& system, Handle thread_handle, s32 priority) {
|
||||
// Get the current process.
|
||||
KProcess& process = *system.Kernel().CurrentProcess();
|
||||
|
||||
// Validate the priority.
|
||||
R_UNLESS(HighestThreadPriority <= priority && priority <= LowestThreadPriority,
|
||||
ResultInvalidPriority);
|
||||
R_UNLESS(process.CheckThreadPriority(priority), ResultInvalidPriority);
|
||||
|
||||
// Get the thread from its handle.
|
||||
KScopedAutoObject thread = process.GetHandleTable().GetObject<KThread>(thread_handle);
|
||||
R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Set the thread priority.
|
||||
thread->SetBasePriority(priority);
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result GetThreadList(Core::System& system, s32* out_num_threads, VAddr out_thread_ids,
|
||||
s32 out_thread_ids_size, Handle debug_handle) {
|
||||
// TODO: Handle this case when debug events are supported.
|
||||
UNIMPLEMENTED_IF(debug_handle != InvalidHandle);
|
||||
|
||||
LOG_DEBUG(Kernel_SVC, "called. out_thread_ids=0x{:016X}, out_thread_ids_size={}",
|
||||
out_thread_ids, out_thread_ids_size);
|
||||
|
||||
// If the size is negative or larger than INT32_MAX / sizeof(u64)
|
||||
if ((out_thread_ids_size & 0xF0000000) != 0) {
|
||||
LOG_ERROR(Kernel_SVC, "Supplied size outside [0, 0x0FFFFFFF] range. size={}",
|
||||
out_thread_ids_size);
|
||||
return ResultOutOfRange;
|
||||
}
|
||||
|
||||
auto* const current_process = system.Kernel().CurrentProcess();
|
||||
const auto total_copy_size = out_thread_ids_size * sizeof(u64);
|
||||
|
||||
if (out_thread_ids_size > 0 &&
|
||||
!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}",
|
||||
out_thread_ids, out_thread_ids + total_copy_size);
|
||||
return ResultInvalidCurrentMemory;
|
||||
}
|
||||
|
||||
auto& memory = system.Memory();
|
||||
const auto& thread_list = current_process->GetThreadList();
|
||||
const auto num_threads = thread_list.size();
|
||||
const auto copy_amount = std::min(static_cast<std::size_t>(out_thread_ids_size), num_threads);
|
||||
|
||||
auto list_iter = thread_list.cbegin();
|
||||
for (std::size_t i = 0; i < copy_amount; ++i, ++list_iter) {
|
||||
memory.Write64(out_thread_ids, (*list_iter)->GetThreadID());
|
||||
out_thread_ids += sizeof(u64);
|
||||
}
|
||||
|
||||
*out_num_threads = static_cast<u32>(num_threads);
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result GetThreadCoreMask(Core::System& system, s32* out_core_id, u64* out_affinity_mask,
|
||||
Handle thread_handle) {
|
||||
LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);
|
||||
|
||||
// Get the thread from its handle.
|
||||
KScopedAutoObject thread =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
|
||||
R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the core mask.
|
||||
R_TRY(thread->GetCoreMask(out_core_id, out_affinity_mask));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result SetThreadCoreMask(Core::System& system, Handle thread_handle, s32 core_id,
|
||||
u64 affinity_mask) {
|
||||
// Determine the core id/affinity mask.
|
||||
if (core_id == IdealCoreUseProcessValue) {
|
||||
core_id = system.Kernel().CurrentProcess()->GetIdealCoreId();
|
||||
affinity_mask = (1ULL << core_id);
|
||||
} else {
|
||||
// Validate the affinity mask.
|
||||
const u64 process_core_mask = system.Kernel().CurrentProcess()->GetCoreMask();
|
||||
R_UNLESS((affinity_mask | process_core_mask) == process_core_mask, ResultInvalidCoreId);
|
||||
R_UNLESS(affinity_mask != 0, ResultInvalidCombination);
|
||||
|
||||
// Validate the core id.
|
||||
if (IsValidVirtualCoreId(core_id)) {
|
||||
R_UNLESS(((1ULL << core_id) & affinity_mask) != 0, ResultInvalidCombination);
|
||||
} else {
|
||||
R_UNLESS(core_id == IdealCoreNoUpdate || core_id == IdealCoreDontCare,
|
||||
ResultInvalidCoreId);
|
||||
}
|
||||
}
|
||||
|
||||
// Get the thread from its handle.
|
||||
KScopedAutoObject thread =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
|
||||
R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Set the core mask.
|
||||
R_TRY(thread->SetCoreMask(core_id, affinity_mask));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
/// Get the ID for the specified thread.
|
||||
Result GetThreadId(Core::System& system, u64* out_thread_id, Handle thread_handle) {
|
||||
// Get the thread from its handle.
|
||||
KScopedAutoObject thread =
|
||||
system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
|
||||
R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
|
||||
|
||||
// Get the thread's id.
|
||||
*out_thread_id = thread->GetId();
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result CreateThread64(Core::System& system, Handle* out_handle, uint64_t func, uint64_t arg,
|
||||
uint64_t stack_bottom, int32_t priority, int32_t core_id) {
|
||||
R_RETURN(CreateThread(system, out_handle, func, arg, stack_bottom, priority, core_id));
|
||||
}
|
||||
|
||||
Result StartThread64(Core::System& system, Handle thread_handle) {
|
||||
R_RETURN(StartThread(system, thread_handle));
|
||||
}
|
||||
|
||||
void ExitThread64(Core::System& system) {
|
||||
return ExitThread(system);
|
||||
}
|
||||
|
||||
void SleepThread64(Core::System& system, int64_t ns) {
|
||||
return SleepThread(system, ns);
|
||||
}
|
||||
|
||||
Result GetThreadPriority64(Core::System& system, int32_t* out_priority, Handle thread_handle) {
|
||||
R_RETURN(GetThreadPriority(system, out_priority, thread_handle));
|
||||
}
|
||||
|
||||
Result SetThreadPriority64(Core::System& system, Handle thread_handle, int32_t priority) {
|
||||
R_RETURN(SetThreadPriority(system, thread_handle, priority));
|
||||
}
|
||||
|
||||
Result GetThreadCoreMask64(Core::System& system, int32_t* out_core_id, uint64_t* out_affinity_mask,
|
||||
Handle thread_handle) {
|
||||
R_RETURN(GetThreadCoreMask(system, out_core_id, out_affinity_mask, thread_handle));
|
||||
}
|
||||
|
||||
Result SetThreadCoreMask64(Core::System& system, Handle thread_handle, int32_t core_id,
|
||||
uint64_t affinity_mask) {
|
||||
R_RETURN(SetThreadCoreMask(system, thread_handle, core_id, affinity_mask));
|
||||
}
|
||||
|
||||
Result GetThreadId64(Core::System& system, uint64_t* out_thread_id, Handle thread_handle) {
|
||||
R_RETURN(GetThreadId(system, out_thread_id, thread_handle));
|
||||
}
|
||||
|
||||
Result GetThreadContext364(Core::System& system, uint64_t out_context, Handle thread_handle) {
|
||||
R_RETURN(GetThreadContext3(system, out_context, thread_handle));
|
||||
}
|
||||
|
||||
Result GetThreadList64(Core::System& system, int32_t* out_num_threads, uint64_t out_thread_ids,
|
||||
int32_t max_out_count, Handle debug_handle) {
|
||||
R_RETURN(GetThreadList(system, out_num_threads, out_thread_ids, max_out_count, debug_handle));
|
||||
}
|
||||
|
||||
Result CreateThread64From32(Core::System& system, Handle* out_handle, uint32_t func, uint32_t arg,
|
||||
uint32_t stack_bottom, int32_t priority, int32_t core_id) {
|
||||
R_RETURN(CreateThread(system, out_handle, func, arg, stack_bottom, priority, core_id));
|
||||
}
|
||||
|
||||
Result StartThread64From32(Core::System& system, Handle thread_handle) {
|
||||
R_RETURN(StartThread(system, thread_handle));
|
||||
}
|
||||
|
||||
void ExitThread64From32(Core::System& system) {
|
||||
return ExitThread(system);
|
||||
}
|
||||
|
||||
void SleepThread64From32(Core::System& system, int64_t ns) {
|
||||
return SleepThread(system, ns);
|
||||
}
|
||||
|
||||
Result GetThreadPriority64From32(Core::System& system, int32_t* out_priority,
|
||||
Handle thread_handle) {
|
||||
R_RETURN(GetThreadPriority(system, out_priority, thread_handle));
|
||||
}
|
||||
|
||||
Result SetThreadPriority64From32(Core::System& system, Handle thread_handle, int32_t priority) {
|
||||
R_RETURN(SetThreadPriority(system, thread_handle, priority));
|
||||
}
|
||||
|
||||
Result GetThreadCoreMask64From32(Core::System& system, int32_t* out_core_id,
|
||||
uint64_t* out_affinity_mask, Handle thread_handle) {
|
||||
R_RETURN(GetThreadCoreMask(system, out_core_id, out_affinity_mask, thread_handle));
|
||||
}
|
||||
|
||||
Result SetThreadCoreMask64From32(Core::System& system, Handle thread_handle, int32_t core_id,
|
||||
uint64_t affinity_mask) {
|
||||
R_RETURN(SetThreadCoreMask(system, thread_handle, core_id, affinity_mask));
|
||||
}
|
||||
|
||||
Result GetThreadId64From32(Core::System& system, uint64_t* out_thread_id, Handle thread_handle) {
|
||||
R_RETURN(GetThreadId(system, out_thread_id, thread_handle));
|
||||
}
|
||||
|
||||
Result GetThreadContext364From32(Core::System& system, uint32_t out_context, Handle thread_handle) {
|
||||
R_RETURN(GetThreadContext3(system, out_context, thread_handle));
|
||||
}
|
||||
|
||||
Result GetThreadList64From32(Core::System& system, int32_t* out_num_threads,
|
||||
uint32_t out_thread_ids, int32_t max_out_count, Handle debug_handle) {
|
||||
R_RETURN(GetThreadList(system, out_num_threads, out_thread_ids, max_out_count, debug_handle));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
60
src/core/hle/kernel/svc/svc_thread_profiler.cpp
Executable file
60
src/core/hle/kernel/svc/svc_thread_profiler.cpp
Executable file
|
|
@ -0,0 +1,60 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/kernel/svc.h"
|
||||
#include "core/hle/kernel/svc_results.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
Result GetDebugFutureThreadInfo(Core::System& system, lp64::LastThreadContext* out_context,
|
||||
uint64_t* out_thread_id, Handle debug_handle, int64_t ns) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result GetLastThreadInfo(Core::System& system, lp64::LastThreadContext* out_context,
|
||||
uint64_t* out_tls_address, uint32_t* out_flags) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result GetDebugFutureThreadInfo64(Core::System& system, lp64::LastThreadContext* out_context,
|
||||
uint64_t* out_thread_id, Handle debug_handle, int64_t ns) {
|
||||
R_RETURN(GetDebugFutureThreadInfo(system, out_context, out_thread_id, debug_handle, ns));
|
||||
}
|
||||
|
||||
Result GetLastThreadInfo64(Core::System& system, lp64::LastThreadContext* out_context,
|
||||
uint64_t* out_tls_address, uint32_t* out_flags) {
|
||||
R_RETURN(GetLastThreadInfo(system, out_context, out_tls_address, out_flags));
|
||||
}
|
||||
|
||||
Result GetDebugFutureThreadInfo64From32(Core::System& system, ilp32::LastThreadContext* out_context,
|
||||
uint64_t* out_thread_id, Handle debug_handle, int64_t ns) {
|
||||
lp64::LastThreadContext context{};
|
||||
R_TRY(
|
||||
GetDebugFutureThreadInfo(system, std::addressof(context), out_thread_id, debug_handle, ns));
|
||||
|
||||
*out_context = {
|
||||
.fp = static_cast<u32>(context.fp),
|
||||
.sp = static_cast<u32>(context.sp),
|
||||
.lr = static_cast<u32>(context.lr),
|
||||
.pc = static_cast<u32>(context.pc),
|
||||
};
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result GetLastThreadInfo64From32(Core::System& system, ilp32::LastThreadContext* out_context,
|
||||
uint64_t* out_tls_address, uint32_t* out_flags) {
|
||||
lp64::LastThreadContext context{};
|
||||
R_TRY(GetLastThreadInfo(system, std::addressof(context), out_tls_address, out_flags));
|
||||
|
||||
*out_context = {
|
||||
.fp = static_cast<u32>(context.fp),
|
||||
.sp = static_cast<u32>(context.sp),
|
||||
.lr = static_cast<u32>(context.lr),
|
||||
.pc = static_cast<u32>(context.pc),
|
||||
};
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
35
src/core/hle/kernel/svc/svc_tick.cpp
Executable file
35
src/core/hle/kernel/svc/svc_tick.cpp
Executable file
|
|
@ -0,0 +1,35 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/core_timing.h"
|
||||
#include "core/hle/kernel/kernel.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
/// This returns the total CPU ticks elapsed since the CPU was powered-on
|
||||
int64_t GetSystemTick(Core::System& system) {
|
||||
LOG_TRACE(Kernel_SVC, "called");
|
||||
|
||||
auto& core_timing = system.CoreTiming();
|
||||
|
||||
// Returns the value of cntpct_el0 (https://switchbrew.org/wiki/SVC#svcGetSystemTick)
|
||||
const u64 result{core_timing.GetClockTicks()};
|
||||
|
||||
if (!system.Kernel().IsMulticore()) {
|
||||
core_timing.AddTicks(400U);
|
||||
}
|
||||
|
||||
return static_cast<int64_t>(result);
|
||||
}
|
||||
|
||||
int64_t GetSystemTick64(Core::System& system) {
|
||||
return GetSystemTick(system);
|
||||
}
|
||||
|
||||
int64_t GetSystemTick64From32(Core::System& system) {
|
||||
return GetSystemTick(system);
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
117
src/core/hle/kernel/svc/svc_transfer_memory.cpp
Executable file
117
src/core/hle/kernel/svc/svc_transfer_memory.cpp
Executable file
|
|
@ -0,0 +1,117 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
||||
#include "core/hle/kernel/k_transfer_memory.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
namespace {
|
||||
|
||||
constexpr bool IsValidTransferMemoryPermission(MemoryPermission perm) {
|
||||
switch (perm) {
|
||||
case MemoryPermission::None:
|
||||
case MemoryPermission::Read:
|
||||
case MemoryPermission::ReadWrite:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
} // Anonymous namespace
|
||||
|
||||
/// Creates a TransferMemory object
|
||||
Result CreateTransferMemory(Core::System& system, Handle* out, VAddr address, u64 size,
|
||||
MemoryPermission map_perm) {
|
||||
auto& kernel = system.Kernel();
|
||||
|
||||
// Validate the size.
|
||||
R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
|
||||
R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
|
||||
R_UNLESS(size > 0, ResultInvalidSize);
|
||||
R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Validate the permissions.
|
||||
R_UNLESS(IsValidTransferMemoryPermission(map_perm), ResultInvalidNewMemoryPermission);
|
||||
|
||||
// Get the current process and handle table.
|
||||
auto& process = *kernel.CurrentProcess();
|
||||
auto& handle_table = process.GetHandleTable();
|
||||
|
||||
// Reserve a new transfer memory from the process resource limit.
|
||||
KScopedResourceReservation trmem_reservation(kernel.CurrentProcess(),
|
||||
LimitableResource::TransferMemoryCountMax);
|
||||
R_UNLESS(trmem_reservation.Succeeded(), ResultLimitReached);
|
||||
|
||||
// Create the transfer memory.
|
||||
KTransferMemory* trmem = KTransferMemory::Create(kernel);
|
||||
R_UNLESS(trmem != nullptr, ResultOutOfResource);
|
||||
|
||||
// Ensure the only reference is in the handle table when we're done.
|
||||
SCOPE_EXIT({ trmem->Close(); });
|
||||
|
||||
// Ensure that the region is in range.
|
||||
R_UNLESS(process.PageTable().Contains(address, size), ResultInvalidCurrentMemory);
|
||||
|
||||
// Initialize the transfer memory.
|
||||
R_TRY(trmem->Initialize(address, size, map_perm));
|
||||
|
||||
// Commit the reservation.
|
||||
trmem_reservation.Commit();
|
||||
|
||||
// Register the transfer memory.
|
||||
KTransferMemory::Register(kernel, trmem);
|
||||
|
||||
// Add the transfer memory to the handle table.
|
||||
R_TRY(handle_table.Add(out, trmem));
|
||||
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
Result MapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size,
|
||||
MemoryPermission owner_perm) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result UnmapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
UNIMPLEMENTED();
|
||||
R_THROW(ResultNotImplemented);
|
||||
}
|
||||
|
||||
Result MapTransferMemory64(Core::System& system, Handle trmem_handle, uint64_t address,
|
||||
uint64_t size, MemoryPermission owner_perm) {
|
||||
R_RETURN(MapTransferMemory(system, trmem_handle, address, size, owner_perm));
|
||||
}
|
||||
|
||||
Result UnmapTransferMemory64(Core::System& system, Handle trmem_handle, uint64_t address,
|
||||
uint64_t size) {
|
||||
R_RETURN(UnmapTransferMemory(system, trmem_handle, address, size));
|
||||
}
|
||||
|
||||
Result CreateTransferMemory64(Core::System& system, Handle* out_handle, uint64_t address,
|
||||
uint64_t size, MemoryPermission map_perm) {
|
||||
R_RETURN(CreateTransferMemory(system, out_handle, address, size, map_perm));
|
||||
}
|
||||
|
||||
Result MapTransferMemory64From32(Core::System& system, Handle trmem_handle, uint32_t address,
|
||||
uint32_t size, MemoryPermission owner_perm) {
|
||||
R_RETURN(MapTransferMemory(system, trmem_handle, address, size, owner_perm));
|
||||
}
|
||||
|
||||
Result UnmapTransferMemory64From32(Core::System& system, Handle trmem_handle, uint32_t address,
|
||||
uint32_t size) {
|
||||
R_RETURN(UnmapTransferMemory(system, trmem_handle, address, size));
|
||||
}
|
||||
|
||||
Result CreateTransferMemory64From32(Core::System& system, Handle* out_handle, uint32_t address,
|
||||
uint32_t size, MemoryPermission map_perm) {
|
||||
R_RETURN(CreateTransferMemory(system, out_handle, address, size, map_perm));
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
716
src/core/hle/kernel/svc_generator.py
Executable file
716
src/core/hle/kernel/svc_generator.py
Executable file
|
|
@ -0,0 +1,716 @@
|
|||
# SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
# SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
# Raw SVC definitions from the kernel.
|
||||
#
|
||||
# Avoid modifying the prototypes; see below for how to customize generation
|
||||
# for a given typename.
|
||||
SVCS = [
|
||||
[0x01, "Result SetHeapSize(Address* out_address, Size size);"],
|
||||
[0x02, "Result SetMemoryPermission(Address address, Size size, MemoryPermission perm);"],
|
||||
[0x03, "Result SetMemoryAttribute(Address address, Size size, uint32_t mask, uint32_t attr);"],
|
||||
[0x04, "Result MapMemory(Address dst_address, Address src_address, Size size);"],
|
||||
[0x05, "Result UnmapMemory(Address dst_address, Address src_address, Size size);"],
|
||||
[0x06, "Result QueryMemory(Address out_memory_info, PageInfo* out_page_info, Address address);"],
|
||||
[0x07, "void ExitProcess();"],
|
||||
[0x08, "Result CreateThread(Handle* out_handle, ThreadFunc func, Address arg, Address stack_bottom, int32_t priority, int32_t core_id);"],
|
||||
[0x09, "Result StartThread(Handle thread_handle);"],
|
||||
[0x0A, "void ExitThread();"],
|
||||
[0x0B, "void SleepThread(int64_t ns);"],
|
||||
[0x0C, "Result GetThreadPriority(int32_t* out_priority, Handle thread_handle);"],
|
||||
[0x0D, "Result SetThreadPriority(Handle thread_handle, int32_t priority);"],
|
||||
[0x0E, "Result GetThreadCoreMask(int32_t* out_core_id, uint64_t* out_affinity_mask, Handle thread_handle);"],
|
||||
[0x0F, "Result SetThreadCoreMask(Handle thread_handle, int32_t core_id, uint64_t affinity_mask);"],
|
||||
[0x10, "int32_t GetCurrentProcessorNumber();"],
|
||||
[0x11, "Result SignalEvent(Handle event_handle);"],
|
||||
[0x12, "Result ClearEvent(Handle event_handle);"],
|
||||
[0x13, "Result MapSharedMemory(Handle shmem_handle, Address address, Size size, MemoryPermission map_perm);"],
|
||||
[0x14, "Result UnmapSharedMemory(Handle shmem_handle, Address address, Size size);"],
|
||||
[0x15, "Result CreateTransferMemory(Handle* out_handle, Address address, Size size, MemoryPermission map_perm);"],
|
||||
[0x16, "Result CloseHandle(Handle handle);"],
|
||||
[0x17, "Result ResetSignal(Handle handle);"],
|
||||
[0x18, "Result WaitSynchronization(int32_t* out_index, Address handles, int32_t num_handles, int64_t timeout_ns);"],
|
||||
[0x19, "Result CancelSynchronization(Handle handle);"],
|
||||
[0x1A, "Result ArbitrateLock(Handle thread_handle, Address address, uint32_t tag);"],
|
||||
[0x1B, "Result ArbitrateUnlock(Address address);"],
|
||||
[0x1C, "Result WaitProcessWideKeyAtomic(Address address, Address cv_key, uint32_t tag, int64_t timeout_ns);"],
|
||||
[0x1D, "void SignalProcessWideKey(Address cv_key, int32_t count);"],
|
||||
[0x1E, "int64_t GetSystemTick();"],
|
||||
[0x1F, "Result ConnectToNamedPort(Handle* out_handle, Address name);"],
|
||||
[0x20, "Result SendSyncRequestLight(Handle session_handle);"],
|
||||
[0x21, "Result SendSyncRequest(Handle session_handle);"],
|
||||
[0x22, "Result SendSyncRequestWithUserBuffer(Address message_buffer, Size message_buffer_size, Handle session_handle);"],
|
||||
[0x23, "Result SendAsyncRequestWithUserBuffer(Handle* out_event_handle, Address message_buffer, Size message_buffer_size, Handle session_handle);"],
|
||||
[0x24, "Result GetProcessId(uint64_t* out_process_id, Handle process_handle);"],
|
||||
[0x25, "Result GetThreadId(uint64_t* out_thread_id, Handle thread_handle);"],
|
||||
[0x26, "void Break(BreakReason break_reason, Address arg, Size size);"],
|
||||
[0x27, "Result OutputDebugString(Address debug_str, Size len);"],
|
||||
[0x28, "void ReturnFromException(Result result);"],
|
||||
[0x29, "Result GetInfo(uint64_t* out, InfoType info_type, Handle handle, uint64_t info_subtype);"],
|
||||
[0x2A, "void FlushEntireDataCache();"],
|
||||
[0x2B, "Result FlushDataCache(Address address, Size size);"],
|
||||
[0x2C, "Result MapPhysicalMemory(Address address, Size size);"],
|
||||
[0x2D, "Result UnmapPhysicalMemory(Address address, Size size);"],
|
||||
[0x2E, "Result GetDebugFutureThreadInfo(LastThreadContext* out_context, uint64_t* out_thread_id, Handle debug_handle, int64_t ns);"],
|
||||
[0x2F, "Result GetLastThreadInfo(LastThreadContext* out_context, Address* out_tls_address, uint32_t* out_flags);"],
|
||||
[0x30, "Result GetResourceLimitLimitValue(int64_t* out_limit_value, Handle resource_limit_handle, LimitableResource which);"],
|
||||
[0x31, "Result GetResourceLimitCurrentValue(int64_t* out_current_value, Handle resource_limit_handle, LimitableResource which);"],
|
||||
[0x32, "Result SetThreadActivity(Handle thread_handle, ThreadActivity thread_activity);"],
|
||||
[0x33, "Result GetThreadContext3(Address out_context, Handle thread_handle);"],
|
||||
[0x34, "Result WaitForAddress(Address address, ArbitrationType arb_type, int32_t value, int64_t timeout_ns);"],
|
||||
[0x35, "Result SignalToAddress(Address address, SignalType signal_type, int32_t value, int32_t count);"],
|
||||
[0x36, "void SynchronizePreemptionState();"],
|
||||
[0x37, "Result GetResourceLimitPeakValue(int64_t* out_peak_value, Handle resource_limit_handle, LimitableResource which);"],
|
||||
|
||||
[0x39, "Result CreateIoPool(Handle* out_handle, IoPoolType which);"],
|
||||
[0x3A, "Result CreateIoRegion(Handle* out_handle, Handle io_pool, PhysicalAddress physical_address, Size size, MemoryMapping mapping, MemoryPermission perm);"],
|
||||
|
||||
[0x3C, "void KernelDebug(KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2);"],
|
||||
[0x3D, "void ChangeKernelTraceState(KernelTraceState kern_trace_state);"],
|
||||
|
||||
[0x40, "Result CreateSession(Handle* out_server_session_handle, Handle* out_client_session_handle, bool is_light, Address name);"],
|
||||
[0x41, "Result AcceptSession(Handle* out_handle, Handle port);"],
|
||||
[0x42, "Result ReplyAndReceiveLight(Handle handle);"],
|
||||
[0x43, "Result ReplyAndReceive(int32_t* out_index, Address handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);"],
|
||||
[0x44, "Result ReplyAndReceiveWithUserBuffer(int32_t* out_index, Address message_buffer, Size message_buffer_size, Address handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);"],
|
||||
[0x45, "Result CreateEvent(Handle* out_write_handle, Handle* out_read_handle);"],
|
||||
[0x46, "Result MapIoRegion(Handle io_region, Address address, Size size, MemoryPermission perm);"],
|
||||
[0x47, "Result UnmapIoRegion(Handle io_region, Address address, Size size);"],
|
||||
[0x48, "Result MapPhysicalMemoryUnsafe(Address address, Size size);"],
|
||||
[0x49, "Result UnmapPhysicalMemoryUnsafe(Address address, Size size);"],
|
||||
[0x4A, "Result SetUnsafeLimit(Size limit);"],
|
||||
[0x4B, "Result CreateCodeMemory(Handle* out_handle, Address address, Size size);"],
|
||||
[0x4C, "Result ControlCodeMemory(Handle code_memory_handle, CodeMemoryOperation operation, uint64_t address, uint64_t size, MemoryPermission perm);"],
|
||||
[0x4D, "void SleepSystem();"],
|
||||
[0x4E, "Result ReadWriteRegister(uint32_t* out_value, PhysicalAddress address, uint32_t mask, uint32_t value);"],
|
||||
[0x4F, "Result SetProcessActivity(Handle process_handle, ProcessActivity process_activity);"],
|
||||
[0x50, "Result CreateSharedMemory(Handle* out_handle, Size size, MemoryPermission owner_perm, MemoryPermission remote_perm);"],
|
||||
[0x51, "Result MapTransferMemory(Handle trmem_handle, Address address, Size size, MemoryPermission owner_perm);"],
|
||||
[0x52, "Result UnmapTransferMemory(Handle trmem_handle, Address address, Size size);"],
|
||||
[0x53, "Result CreateInterruptEvent(Handle* out_read_handle, int32_t interrupt_id, InterruptType interrupt_type);"],
|
||||
[0x54, "Result QueryPhysicalAddress(PhysicalMemoryInfo* out_info, Address address);"],
|
||||
[0x55, "Result QueryIoMapping(Address* out_address, Size* out_size, PhysicalAddress physical_address, Size size);"],
|
||||
[0x56, "Result CreateDeviceAddressSpace(Handle* out_handle, uint64_t das_address, uint64_t das_size);"],
|
||||
[0x57, "Result AttachDeviceAddressSpace(DeviceName device_name, Handle das_handle);"],
|
||||
[0x58, "Result DetachDeviceAddressSpace(DeviceName device_name, Handle das_handle);"],
|
||||
[0x59, "Result MapDeviceAddressSpaceByForce(Handle das_handle, Handle process_handle, uint64_t process_address, Size size, uint64_t device_address, uint32_t option);"],
|
||||
[0x5A, "Result MapDeviceAddressSpaceAligned(Handle das_handle, Handle process_handle, uint64_t process_address, Size size, uint64_t device_address, uint32_t option);"],
|
||||
[0x5C, "Result UnmapDeviceAddressSpace(Handle das_handle, Handle process_handle, uint64_t process_address, Size size, uint64_t device_address);"],
|
||||
[0x5D, "Result InvalidateProcessDataCache(Handle process_handle, uint64_t address, uint64_t size);"],
|
||||
[0x5E, "Result StoreProcessDataCache(Handle process_handle, uint64_t address, uint64_t size);"],
|
||||
[0x5F, "Result FlushProcessDataCache(Handle process_handle, uint64_t address, uint64_t size);"],
|
||||
[0x60, "Result DebugActiveProcess(Handle* out_handle, uint64_t process_id);"],
|
||||
[0x61, "Result BreakDebugProcess(Handle debug_handle);"],
|
||||
[0x62, "Result TerminateDebugProcess(Handle debug_handle);"],
|
||||
[0x63, "Result GetDebugEvent(Address out_info, Handle debug_handle);"],
|
||||
[0x64, "Result ContinueDebugEvent(Handle debug_handle, uint32_t flags, Address thread_ids, int32_t num_thread_ids);"],
|
||||
[0x65, "Result GetProcessList(int32_t* out_num_processes, Address out_process_ids, int32_t max_out_count);"],
|
||||
[0x66, "Result GetThreadList(int32_t* out_num_threads, Address out_thread_ids, int32_t max_out_count, Handle debug_handle);"],
|
||||
[0x67, "Result GetDebugThreadContext(Address out_context, Handle debug_handle, uint64_t thread_id, uint32_t context_flags);"],
|
||||
[0x68, "Result SetDebugThreadContext(Handle debug_handle, uint64_t thread_id, Address context, uint32_t context_flags);"],
|
||||
[0x69, "Result QueryDebugProcessMemory(Address out_memory_info, PageInfo* out_page_info, Handle process_handle, Address address);"],
|
||||
[0x6A, "Result ReadDebugProcessMemory(Address buffer, Handle debug_handle, Address address, Size size);"],
|
||||
[0x6B, "Result WriteDebugProcessMemory(Handle debug_handle, Address buffer, Address address, Size size);"],
|
||||
[0x6C, "Result SetHardwareBreakPoint(HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value);"],
|
||||
[0x6D, "Result GetDebugThreadParam(uint64_t* out_64, uint32_t* out_32, Handle debug_handle, uint64_t thread_id, DebugThreadParam param);"],
|
||||
|
||||
[0x6F, "Result GetSystemInfo(uint64_t* out, SystemInfoType info_type, Handle handle, uint64_t info_subtype);"],
|
||||
[0x70, "Result CreatePort(Handle* out_server_handle, Handle* out_client_handle, int32_t max_sessions, bool is_light, Address name);"],
|
||||
[0x71, "Result ManageNamedPort(Handle* out_server_handle, Address name, int32_t max_sessions);"],
|
||||
[0x72, "Result ConnectToPort(Handle* out_handle, Handle port);"],
|
||||
[0x73, "Result SetProcessMemoryPermission(Handle process_handle, uint64_t address, uint64_t size, MemoryPermission perm);"],
|
||||
[0x74, "Result MapProcessMemory(Address dst_address, Handle process_handle, uint64_t src_address, Size size);"],
|
||||
[0x75, "Result UnmapProcessMemory(Address dst_address, Handle process_handle, uint64_t src_address, Size size);"],
|
||||
[0x76, "Result QueryProcessMemory(Address out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);"],
|
||||
[0x77, "Result MapProcessCodeMemory(Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);"],
|
||||
[0x78, "Result UnmapProcessCodeMemory(Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);"],
|
||||
[0x79, "Result CreateProcess(Handle* out_handle, Address parameters, Address caps, int32_t num_caps);"],
|
||||
[0x7A, "Result StartProcess(Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size);"],
|
||||
[0x7B, "Result TerminateProcess(Handle process_handle);"],
|
||||
[0x7C, "Result GetProcessInfo(int64_t* out_info, Handle process_handle, ProcessInfoType info_type);"],
|
||||
[0x7D, "Result CreateResourceLimit(Handle* out_handle);"],
|
||||
[0x7E, "Result SetResourceLimitLimitValue(Handle resource_limit_handle, LimitableResource which, int64_t limit_value);"],
|
||||
[0x7F, "void CallSecureMonitor(SecureMonitorArguments args);"],
|
||||
|
||||
[0x90, "Result MapInsecureMemory(Address address, Size size);"],
|
||||
[0x91, "Result UnmapInsecureMemory(Address address, Size size);"],
|
||||
]
|
||||
|
||||
# These use a custom ABI, and therefore require custom wrappers
|
||||
SKIP_WRAPPERS = {
|
||||
0x20: "SendSyncRequestLight",
|
||||
0x42: "ReplyAndReceiveLight",
|
||||
0x7F: "CallSecureMonitor",
|
||||
}
|
||||
|
||||
BIT_32 = 0
|
||||
BIT_64 = 1
|
||||
|
||||
REG_SIZES = [4, 8]
|
||||
SUFFIX_NAMES = ["64From32", "64"]
|
||||
TYPE_SIZES = {
|
||||
# SVC types
|
||||
"ArbitrationType": 4,
|
||||
"BreakReason": 4,
|
||||
"CodeMemoryOperation": 4,
|
||||
"DebugThreadParam": 4,
|
||||
"DeviceName": 4,
|
||||
"HardwareBreakPointRegisterName": 4,
|
||||
"Handle": 4,
|
||||
"InfoType": 4,
|
||||
"InterruptType": 4,
|
||||
"IoPoolType": 4,
|
||||
"KernelDebugType": 4,
|
||||
"KernelTraceState": 4,
|
||||
"LimitableResource": 4,
|
||||
"MemoryMapping": 4,
|
||||
"MemoryPermission": 4,
|
||||
"PageInfo": 4,
|
||||
"ProcessActivity": 4,
|
||||
"ProcessInfoType": 4,
|
||||
"Result": 4,
|
||||
"SignalType": 4,
|
||||
"SystemInfoType": 4,
|
||||
"ThreadActivity": 4,
|
||||
|
||||
# Arch-specific types
|
||||
"ilp32::LastThreadContext": 16,
|
||||
"ilp32::PhysicalMemoryInfo": 16,
|
||||
"ilp32::SecureMonitorArguments": 32,
|
||||
"lp64::LastThreadContext": 32,
|
||||
"lp64::PhysicalMemoryInfo": 24,
|
||||
"lp64::SecureMonitorArguments": 64,
|
||||
|
||||
# Generic types
|
||||
"bool": 1,
|
||||
"int32_t": 4,
|
||||
"int64_t": 8,
|
||||
"uint32_t": 4,
|
||||
"uint64_t": 8,
|
||||
"void": 0,
|
||||
}
|
||||
|
||||
TYPE_REPLACEMENTS = {
|
||||
"Address": ["uint32_t", "uint64_t"],
|
||||
"LastThreadContext": ["ilp32::LastThreadContext", "lp64::LastThreadContext"],
|
||||
"PhysicalAddress": ["uint64_t", "uint64_t"],
|
||||
"PhysicalMemoryInfo": ["ilp32::PhysicalMemoryInfo", "lp64::PhysicalMemoryInfo"],
|
||||
"SecureMonitorArguments": ["ilp32::SecureMonitorArguments", "lp64::SecureMonitorArguments"],
|
||||
"Size": ["uint32_t", "uint64_t"],
|
||||
"ThreadFunc": ["uint32_t", "uint64_t"],
|
||||
}
|
||||
|
||||
# Statically verify that the hardcoded sizes match the intended
|
||||
# sizes in C++.
|
||||
def emit_size_check():
|
||||
lines = []
|
||||
|
||||
for type, size in TYPE_SIZES.items():
|
||||
if type != "void":
|
||||
lines.append(f"static_assert(sizeof({type}) == {size});")
|
||||
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
# Replaces a type with an arch-specific one, if it exists.
|
||||
def substitute_type(name, bitness):
|
||||
if name in TYPE_REPLACEMENTS:
|
||||
return TYPE_REPLACEMENTS[name][bitness]
|
||||
else:
|
||||
return name
|
||||
|
||||
|
||||
class Argument:
|
||||
def __init__(self, type_name, var_name, is_output, is_outptr, is_address):
|
||||
self.type_name = type_name
|
||||
self.var_name = var_name
|
||||
self.is_output = is_output
|
||||
self.is_outptr = is_outptr
|
||||
self.is_address = is_address
|
||||
|
||||
|
||||
# Parses C-style string declarations for SVCs.
|
||||
def parse_declaration(declaration, bitness):
|
||||
return_type, rest = declaration.split(" ", 1)
|
||||
func_name, rest = rest.split("(", 1)
|
||||
arg_names, rest = rest.split(")", 1)
|
||||
argument_types = []
|
||||
|
||||
return_type = substitute_type(return_type, bitness)
|
||||
assert return_type in TYPE_SIZES, f"Unknown type '{return_type}'"
|
||||
|
||||
if arg_names:
|
||||
for arg_name in arg_names.split(", "):
|
||||
type_name, var_name = arg_name.replace("*", "").split(" ", 1)
|
||||
|
||||
# All outputs must contain out_ in the name.
|
||||
is_output = var_name == "out" or var_name.find("out_") != -1
|
||||
|
||||
# User-pointer outputs are not written to registers.
|
||||
is_outptr = is_output and arg_name.find("*") == -1
|
||||
|
||||
# Special handling is performed for output addresses to avoid awkwardness
|
||||
# in conversion for the 32-bit equivalents.
|
||||
is_address = is_output and not is_outptr and \
|
||||
type_name in ["Address", "Size"]
|
||||
type_name = substitute_type(type_name, bitness)
|
||||
|
||||
assert type_name in TYPE_SIZES, f"Unknown type '{type_name}'"
|
||||
|
||||
argument_types.append(
|
||||
Argument(type_name, var_name, is_output, is_outptr, is_address))
|
||||
|
||||
return (return_type, func_name, argument_types)
|
||||
|
||||
|
||||
class RegisterAllocator:
|
||||
def __init__(self, num_regs, byte_size, parameter_count):
|
||||
self.registers = {}
|
||||
self.num_regs = num_regs
|
||||
self.byte_size = byte_size
|
||||
self.parameter_count = parameter_count
|
||||
|
||||
# Mark the given register as allocated, for use in layout
|
||||
# calculation if the NGRN exceeds the ABI parameter count.
|
||||
def allocate(self, i):
|
||||
assert i not in self.registers, f"Register R{i} already allocated"
|
||||
self.registers[i] = True
|
||||
return i
|
||||
|
||||
# Calculate the next available location for a register;
|
||||
# the NGRN has exceeded the ABI parameter count.
|
||||
def allocate_first_free(self):
|
||||
for i in range(0, self.num_regs):
|
||||
if i in self.registers:
|
||||
continue
|
||||
|
||||
self.allocate(i)
|
||||
return i
|
||||
|
||||
assert False, "No registers available"
|
||||
|
||||
# Add a single register at the given NGRN.
|
||||
# If the index exceeds the ABI parameter count, try to find a
|
||||
# location to add it. Returns the output location and increment.
|
||||
def add_single(self, ngrn):
|
||||
if ngrn >= self.parameter_count:
|
||||
return (self.allocate_first_free(), 0)
|
||||
else:
|
||||
return (self.allocate(ngrn), 1)
|
||||
|
||||
# Add registers at the given NGRN for a data type of
|
||||
# the given size. Returns the output locations and increment.
|
||||
def add(self, ngrn, data_size, align=True):
|
||||
if data_size <= self.byte_size:
|
||||
r, i = self.add_single(ngrn)
|
||||
return ([r], i)
|
||||
|
||||
regs = []
|
||||
inc = ngrn % 2 if align else 0
|
||||
remaining_size = data_size
|
||||
while remaining_size > 0:
|
||||
r, i = self.add_single(ngrn + inc)
|
||||
regs.append(r)
|
||||
inc += i
|
||||
remaining_size -= self.byte_size
|
||||
|
||||
return (regs, inc)
|
||||
|
||||
|
||||
def reg_alloc(bitness):
|
||||
if bitness == 0:
|
||||
# aapcs32: 4 4-byte registers
|
||||
return RegisterAllocator(8, 4, 4)
|
||||
elif bitness == 1:
|
||||
# aapcs64: 8 8-byte registers
|
||||
return RegisterAllocator(8, 8, 8)
|
||||
|
||||
|
||||
# Converts a parsed SVC declaration into register lists for
|
||||
# the return value, outputs, and inputs.
|
||||
def get_registers(parse_result, bitness):
|
||||
output_alloc = reg_alloc(bitness)
|
||||
input_alloc = reg_alloc(bitness)
|
||||
return_type, _, arguments = parse_result
|
||||
|
||||
return_write = []
|
||||
output_writes = []
|
||||
input_reads = []
|
||||
|
||||
input_ngrn = 0
|
||||
output_ngrn = 0
|
||||
|
||||
# Run the input calculation.
|
||||
for arg in arguments:
|
||||
if arg.is_output and not arg.is_outptr:
|
||||
input_ngrn += 1
|
||||
continue
|
||||
|
||||
regs, increment = input_alloc.add(
|
||||
input_ngrn, TYPE_SIZES[arg.type_name], align=True)
|
||||
input_reads.append([arg.type_name, arg.var_name, regs])
|
||||
input_ngrn += increment
|
||||
|
||||
# Include the return value if this SVC returns a value.
|
||||
if return_type != "void":
|
||||
regs, increment = output_alloc.add(
|
||||
output_ngrn, TYPE_SIZES[return_type], align=False)
|
||||
return_write.append([return_type, regs])
|
||||
output_ngrn += increment
|
||||
|
||||
# Run the output calculation.
|
||||
for arg in arguments:
|
||||
if not arg.is_output or arg.is_outptr:
|
||||
continue
|
||||
|
||||
regs, increment = output_alloc.add(
|
||||
output_ngrn, TYPE_SIZES[arg.type_name], align=False)
|
||||
output_writes.append(
|
||||
[arg.type_name, arg.var_name, regs, arg.is_address])
|
||||
output_ngrn += increment
|
||||
|
||||
return (return_write, output_writes, input_reads)
|
||||
|
||||
|
||||
# Collects possibly multiple source registers into the named C++ value.
|
||||
def emit_gather(sources, name, type_name, reg_size):
|
||||
get_fn = f"GetReg{reg_size*8}"
|
||||
|
||||
if len(sources) == 1:
|
||||
s, = sources
|
||||
line = f"{name} = Convert<{type_name}>({get_fn}(system, {s}));"
|
||||
return [line]
|
||||
|
||||
var_type = f"std::array<uint{reg_size*8}_t, {len(sources)}>"
|
||||
lines = [
|
||||
f"{var_type} {name}_gather{{}};"
|
||||
]
|
||||
for i in range(0, len(sources)):
|
||||
lines.append(
|
||||
f"{name}_gather[{i}] = {get_fn}(system, {sources[i]});")
|
||||
|
||||
lines.append(f"{name} = Convert<{type_name}>({name}_gather);")
|
||||
return lines
|
||||
|
||||
|
||||
# Produces one or more statements which assign the named C++ value
|
||||
# into possibly multiple registers.
|
||||
def emit_scatter(destinations, name, reg_size):
|
||||
set_fn = f"SetReg{reg_size*8}"
|
||||
reg_type = f"uint{reg_size*8}_t"
|
||||
|
||||
if len(destinations) == 1:
|
||||
d, = destinations
|
||||
line = f"{set_fn}(system, {d}, Convert<{reg_type}>({name}));"
|
||||
return [line]
|
||||
|
||||
var_type = f"std::array<{reg_type}, {len(destinations)}>"
|
||||
lines = [
|
||||
f"auto {name}_scatter = Convert<{var_type}>({name});"
|
||||
]
|
||||
|
||||
for i in range(0, len(destinations)):
|
||||
lines.append(
|
||||
f"{set_fn}(system, {destinations[i]}, {name}_scatter[{i}]);")
|
||||
|
||||
return lines
|
||||
|
||||
|
||||
def emit_lines(lines, indent=' '):
|
||||
output_lines = []
|
||||
first = True
|
||||
for line in lines:
|
||||
if line and not first:
|
||||
output_lines.append(indent + line)
|
||||
else:
|
||||
output_lines.append(line)
|
||||
first = False
|
||||
|
||||
return "\n".join(output_lines)
|
||||
|
||||
|
||||
# Emit a C++ function to wrap a guest SVC.
|
||||
def emit_wrapper(wrapped_fn, suffix, register_info, arguments, byte_size):
|
||||
return_write, output_writes, input_reads = register_info
|
||||
lines = [
|
||||
f"static void SvcWrap_{wrapped_fn}{suffix}(Core::System& system) {{"
|
||||
]
|
||||
|
||||
# Get everything ready.
|
||||
for return_type, _ in return_write:
|
||||
lines.append(f"{return_type} ret{{}};")
|
||||
if return_write:
|
||||
lines.append("")
|
||||
|
||||
for output_type, var_name, _, is_address in output_writes:
|
||||
output_type = "uintptr_t" if is_address else output_type
|
||||
lines.append(f"{output_type} {var_name}{{}};")
|
||||
for input_type, var_name, _ in input_reads:
|
||||
lines.append(f"{input_type} {var_name}{{}};")
|
||||
|
||||
if output_writes or input_reads:
|
||||
lines.append("")
|
||||
|
||||
for input_type, var_name, sources in input_reads:
|
||||
lines += emit_gather(sources, var_name, input_type, byte_size)
|
||||
if input_reads:
|
||||
lines.append("")
|
||||
|
||||
# Build the call.
|
||||
call_arguments = ["system"]
|
||||
for arg in arguments:
|
||||
if arg.is_output and not arg.is_outptr:
|
||||
call_arguments.append(f"&{arg.var_name}")
|
||||
else:
|
||||
call_arguments.append(arg.var_name)
|
||||
|
||||
line = ""
|
||||
if return_write:
|
||||
line += "ret = "
|
||||
|
||||
line += f"{wrapped_fn}{suffix}({', '.join(call_arguments)});"
|
||||
lines.append(line)
|
||||
|
||||
if return_write or output_writes:
|
||||
lines.append("")
|
||||
|
||||
# Write back the return value and outputs.
|
||||
for _, destinations in return_write:
|
||||
lines += emit_scatter(destinations, "ret", byte_size)
|
||||
for _, var_name, destinations, _ in output_writes:
|
||||
lines += emit_scatter(destinations, var_name, byte_size)
|
||||
|
||||
# Finish.
|
||||
return emit_lines(lines) + "\n}"
|
||||
|
||||
|
||||
COPYRIGHT = """\
|
||||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
// This file is automatically generated using svc_generator.py.
|
||||
"""
|
||||
|
||||
PROLOGUE_H = """
|
||||
#pragma once
|
||||
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
#include "common/common_types.h"
|
||||
#include "core/hle/kernel/svc_types.h"
|
||||
#include "core/hle/result.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
// clang-format off
|
||||
"""
|
||||
|
||||
EPILOGUE_H = """
|
||||
// clang-format on
|
||||
|
||||
// Custom ABI.
|
||||
Result ReplyAndReceiveLight(Core::System& system, Handle handle, uint32_t* args);
|
||||
Result ReplyAndReceiveLight64From32(Core::System& system, Handle handle, uint32_t* args);
|
||||
Result ReplyAndReceiveLight64(Core::System& system, Handle handle, uint32_t* args);
|
||||
|
||||
Result SendSyncRequestLight(Core::System& system, Handle session_handle, uint32_t* args);
|
||||
Result SendSyncRequestLight64From32(Core::System& system, Handle session_handle, uint32_t* args);
|
||||
Result SendSyncRequestLight64(Core::System& system, Handle session_handle, uint32_t* args);
|
||||
|
||||
void CallSecureMonitor(Core::System& system, lp64::SecureMonitorArguments* args);
|
||||
void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArguments* args);
|
||||
void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args);
|
||||
|
||||
// Defined in svc_light_ipc.cpp.
|
||||
void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system);
|
||||
void SvcWrap_ReplyAndReceiveLight64(Core::System& system);
|
||||
|
||||
void SvcWrap_SendSyncRequestLight64From32(Core::System& system);
|
||||
void SvcWrap_SendSyncRequestLight64(Core::System& system);
|
||||
|
||||
// Defined in svc_secure_monitor_call.cpp.
|
||||
void SvcWrap_CallSecureMonitor64From32(Core::System& system);
|
||||
void SvcWrap_CallSecureMonitor64(Core::System& system);
|
||||
|
||||
// Perform a supervisor call by index.
|
||||
void Call(Core::System& system, u32 imm);
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
"""
|
||||
|
||||
PROLOGUE_CPP = """
|
||||
#include <type_traits>
|
||||
|
||||
#include "core/arm/arm_interface.h"
|
||||
#include "core/core.h"
|
||||
#include "core/hle/kernel/k_process.h"
|
||||
#include "core/hle/kernel/svc.h"
|
||||
|
||||
namespace Kernel::Svc {
|
||||
|
||||
static uint32_t GetReg32(Core::System& system, int n) {
|
||||
return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n));
|
||||
}
|
||||
|
||||
static void SetReg32(Core::System& system, int n, uint32_t result) {
|
||||
system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result));
|
||||
}
|
||||
|
||||
static uint64_t GetReg64(Core::System& system, int n) {
|
||||
return system.CurrentArmInterface().GetReg(n);
|
||||
}
|
||||
|
||||
static void SetReg64(Core::System& system, int n, uint64_t result) {
|
||||
system.CurrentArmInterface().SetReg(n, result);
|
||||
}
|
||||
|
||||
// Like bit_cast, but handles the case when the source and dest
|
||||
// are differently-sized.
|
||||
template <typename To, typename From>
|
||||
requires(std::is_trivial_v<To> && std::is_trivially_copyable_v<From>)
|
||||
static To Convert(const From& from) {
|
||||
To to{};
|
||||
|
||||
if constexpr (sizeof(To) >= sizeof(From)) {
|
||||
std::memcpy(&to, &from, sizeof(From));
|
||||
} else {
|
||||
std::memcpy(&to, &from, sizeof(To));
|
||||
}
|
||||
|
||||
return to;
|
||||
}
|
||||
|
||||
// clang-format off
|
||||
"""
|
||||
|
||||
EPILOGUE_CPP = """
|
||||
// clang-format on
|
||||
|
||||
void Call(Core::System& system, u32 imm) {
|
||||
auto& kernel = system.Kernel();
|
||||
kernel.EnterSVCProfile();
|
||||
|
||||
if (system.CurrentProcess()->Is64BitProcess()) {
|
||||
Call64(system, imm);
|
||||
} else {
|
||||
Call32(system, imm);
|
||||
}
|
||||
|
||||
kernel.ExitSVCProfile();
|
||||
}
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
"""
|
||||
|
||||
|
||||
def emit_call(bitness, names, suffix):
|
||||
bit_size = REG_SIZES[bitness]*8
|
||||
indent = " "
|
||||
lines = [
|
||||
f"static void Call{bit_size}(Core::System& system, u32 imm) {{",
|
||||
f"{indent}switch (static_cast<SvcId>(imm)) {{"
|
||||
]
|
||||
|
||||
for _, name in names:
|
||||
lines.append(f"{indent}case SvcId::{name}:")
|
||||
lines.append(f"{indent*2}return SvcWrap_{name}{suffix}(system);")
|
||||
|
||||
lines.append(f"{indent}default:")
|
||||
lines.append(
|
||||
f"{indent*2}LOG_CRITICAL(Kernel_SVC, \"Unknown SVC {{:x}}!\", imm);")
|
||||
lines.append(f"{indent*2}break;")
|
||||
lines.append(f"{indent}}}")
|
||||
lines.append("}")
|
||||
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def build_fn_declaration(return_type, name, arguments):
|
||||
arg_list = ["Core::System& system"]
|
||||
for arg in arguments:
|
||||
type_name = "uintptr_t" if arg.is_address else arg.type_name
|
||||
pointer = "*" if arg.is_output and not arg.is_outptr else ""
|
||||
arg_list.append(f"{type_name}{pointer} {arg.var_name}")
|
||||
|
||||
return f"{return_type} {name}({', '.join(arg_list)});"
|
||||
|
||||
|
||||
def build_enum_declarations():
|
||||
lines = ["enum class SvcId : u32 {"]
|
||||
indent = " "
|
||||
|
||||
for imm, decl in SVCS:
|
||||
_, name, _ = parse_declaration(decl, BIT_64)
|
||||
lines.append(f"{indent}{name} = {hex(imm)},")
|
||||
|
||||
lines.append("};")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def main():
|
||||
arch_fw_declarations = [[], []]
|
||||
svc_fw_declarations = []
|
||||
wrapper_fns = []
|
||||
names = []
|
||||
|
||||
for imm, decl in SVCS:
|
||||
return_type, name, arguments = parse_declaration(decl, BIT_64)
|
||||
|
||||
if imm not in SKIP_WRAPPERS:
|
||||
svc_fw_declarations.append(
|
||||
build_fn_declaration(return_type, name, arguments))
|
||||
|
||||
names.append([imm, name])
|
||||
|
||||
for bitness in range(2):
|
||||
byte_size = REG_SIZES[bitness]
|
||||
suffix = SUFFIX_NAMES[bitness]
|
||||
|
||||
for imm, decl in SVCS:
|
||||
if imm in SKIP_WRAPPERS:
|
||||
continue
|
||||
|
||||
parse_result = parse_declaration(decl, bitness)
|
||||
return_type, name, arguments = parse_result
|
||||
|
||||
register_info = get_registers(parse_result, bitness)
|
||||
wrapper_fns.append(
|
||||
emit_wrapper(name, suffix, register_info, arguments, byte_size))
|
||||
arch_fw_declarations[bitness].append(
|
||||
build_fn_declaration(return_type, name + suffix, arguments))
|
||||
|
||||
call_32 = emit_call(BIT_32, names, SUFFIX_NAMES[BIT_32])
|
||||
call_64 = emit_call(BIT_64, names, SUFFIX_NAMES[BIT_64])
|
||||
enum_decls = build_enum_declarations()
|
||||
|
||||
with open("svc.h", "w") as f:
|
||||
f.write(COPYRIGHT)
|
||||
f.write(PROLOGUE_H)
|
||||
f.write("\n".join(svc_fw_declarations))
|
||||
f.write("\n\n")
|
||||
f.write("\n".join(arch_fw_declarations[BIT_32]))
|
||||
f.write("\n\n")
|
||||
f.write("\n".join(arch_fw_declarations[BIT_64]))
|
||||
f.write("\n\n")
|
||||
f.write(enum_decls)
|
||||
f.write(EPILOGUE_H)
|
||||
|
||||
with open("svc.cpp", "w") as f:
|
||||
f.write(COPYRIGHT)
|
||||
f.write(PROLOGUE_CPP)
|
||||
f.write(emit_size_check())
|
||||
f.write("\n\n")
|
||||
f.write("\n\n".join(wrapper_fns))
|
||||
f.write("\n\n")
|
||||
f.write(call_32)
|
||||
f.write("\n\n")
|
||||
f.write(call_64)
|
||||
f.write(EPILOGUE_CPP)
|
||||
|
||||
print(f"Done (emitted {len(names)} definitions)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
|
@ -11,6 +11,7 @@ namespace Kernel {
|
|||
|
||||
constexpr Result ResultOutOfSessions{ErrorModule::Kernel, 7};
|
||||
constexpr Result ResultInvalidArgument{ErrorModule::Kernel, 14};
|
||||
constexpr Result ResultNotImplemented{ErrorModule::Kernel, 33};
|
||||
constexpr Result ResultNoSynchronizationObject{ErrorModule::Kernel, 57};
|
||||
constexpr Result ResultTerminationRequested{ErrorModule::Kernel, 59};
|
||||
constexpr Result ResultInvalidSize{ErrorModule::Kernel, 101};
|
||||
|
|
|
|||
|
|
@ -168,6 +168,7 @@ enum class BreakReason : u32 {
|
|||
|
||||
NotificationOnlyFlag = 0x80000000,
|
||||
};
|
||||
DECLARE_ENUM_FLAG_OPERATORS(BreakReason);
|
||||
|
||||
enum class DebugEvent : u32 {
|
||||
CreateProcess = 0,
|
||||
|
|
@ -596,6 +597,11 @@ enum class ProcessInfoType : u32 {
|
|||
ProcessState = 0,
|
||||
};
|
||||
|
||||
enum class ProcessActivity : u32 {
|
||||
Runnable,
|
||||
Paused,
|
||||
};
|
||||
|
||||
struct CreateProcessParameter {
|
||||
std::array<char, 12> name;
|
||||
u32 version;
|
||||
|
|
@ -611,4 +617,9 @@ static_assert(sizeof(CreateProcessParameter) == 0x30);
|
|||
constexpr size_t NumSupervisorCalls = 0xC0;
|
||||
using SvcAccessFlagSet = std::bitset<NumSupervisorCalls>;
|
||||
|
||||
enum class InitialProcessIdRangeInfo : u64 {
|
||||
Minimum = 0,
|
||||
Maximum = 1,
|
||||
};
|
||||
|
||||
} // namespace Kernel::Svc
|
||||
|
|
|
|||
|
|
@ -758,12 +758,20 @@ Core::HID::NpadStyleTag Controller_NPad::GetSupportedStyleSet() const {
|
|||
return hid_core.GetSupportedStyleTag();
|
||||
}
|
||||
|
||||
void Controller_NPad::SetSupportedNpadIdTypes(std::span<const u8> data) {
|
||||
Result Controller_NPad::SetSupportedNpadIdTypes(std::span<const u8> data) {
|
||||
constexpr std::size_t max_number_npad_ids = 0xa;
|
||||
const auto length = data.size();
|
||||
ASSERT(length > 0 && (length % sizeof(u32)) == 0);
|
||||
const std::size_t elements = length / sizeof(u32);
|
||||
|
||||
if (elements > max_number_npad_ids) {
|
||||
return InvalidArraySize;
|
||||
}
|
||||
|
||||
supported_npad_id_types.clear();
|
||||
supported_npad_id_types.resize(length / sizeof(u32));
|
||||
supported_npad_id_types.resize(elements);
|
||||
std::memcpy(supported_npad_id_types.data(), data.data(), length);
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ public:
|
|||
void SetSupportedStyleSet(Core::HID::NpadStyleTag style_set);
|
||||
Core::HID::NpadStyleTag GetSupportedStyleSet() const;
|
||||
|
||||
void SetSupportedNpadIdTypes(std::span<const u8> data);
|
||||
Result SetSupportedNpadIdTypes(std::span<const u8> data);
|
||||
void GetSupportedNpadIdTypes(u32* data, std::size_t max_length);
|
||||
std::size_t GetSupportedNpadIdTypesSize() const;
|
||||
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ constexpr Result NpadIsDualJoycon{ErrorModule::HID, 601};
|
|||
constexpr Result NpadIsSameType{ErrorModule::HID, 602};
|
||||
constexpr Result InvalidNpadId{ErrorModule::HID, 709};
|
||||
constexpr Result NpadNotConnected{ErrorModule::HID, 710};
|
||||
constexpr Result InvalidArraySize{ErrorModule::HID, 715};
|
||||
constexpr Result InvalidPalmaHandle{ErrorModule::HID, 3302};
|
||||
|
||||
} // namespace Service::HID
|
||||
|
|
|
|||
|
|
@ -1025,13 +1025,13 @@ void Hid::SetSupportedNpadIdType(Kernel::HLERequestContext& ctx) {
|
|||
IPC::RequestParser rp{ctx};
|
||||
const auto applet_resource_user_id{rp.Pop<u64>()};
|
||||
|
||||
applet_resource->GetController<Controller_NPad>(HidController::NPad)
|
||||
.SetSupportedNpadIdTypes(ctx.ReadBuffer());
|
||||
const auto result = applet_resource->GetController<Controller_NPad>(HidController::NPad)
|
||||
.SetSupportedNpadIdTypes(ctx.ReadBuffer());
|
||||
|
||||
LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
|
||||
|
||||
IPC::ResponseBuilder rb{ctx, 2};
|
||||
rb.Push(ResultSuccess);
|
||||
rb.Push(result);
|
||||
}
|
||||
|
||||
void Hid::ActivateNpad(Kernel::HLERequestContext& ctx) {
|
||||
|
|
|
|||
|
|
@ -310,12 +310,6 @@ EmitContext::EmitContext(IR::Program& program, Bindings& bindings, const Profile
|
|||
if (runtime_info.force_early_z) {
|
||||
header += "layout(early_fragment_tests)in;";
|
||||
}
|
||||
if (info.uses_sample_id) {
|
||||
header += "in int gl_SampleID;";
|
||||
}
|
||||
if (info.stores_sample_mask) {
|
||||
header += "out int gl_SampleMask[];";
|
||||
}
|
||||
break;
|
||||
case Stage::Compute:
|
||||
stage_name = "cs";
|
||||
|
|
|
|||
|
|
@ -538,7 +538,7 @@ TEST_CASE("BufferBase: Cached write downloads") {
|
|||
int num = 0;
|
||||
buffer.ForEachDownloadRangeAndClear(c, WORD, [&](u64 offset, u64 size) { ++num; });
|
||||
buffer.ForEachUploadRange(c, WORD, [&](u64 offset, u64 size) { ++num; });
|
||||
REQUIRE(num == 1);
|
||||
REQUIRE(num == 0);
|
||||
REQUIRE(!buffer.IsRegionCpuModified(c + PAGE, PAGE));
|
||||
REQUIRE(!buffer.IsRegionGpuModified(c + PAGE, PAGE));
|
||||
buffer.FlushCachedWrites();
|
||||
|
|
|
|||
|
|
@ -430,7 +430,7 @@ private:
|
|||
if (query_begin >= SizeBytes() || size < 0) {
|
||||
return;
|
||||
}
|
||||
[[maybe_unused]] u64* const untracked_words = Array<Type::Untracked>();
|
||||
u64* const untracked_words = Array<Type::Untracked>();
|
||||
u64* const state_words = Array<type>();
|
||||
const u64 query_end = query_begin + std::min(static_cast<u64>(size), SizeBytes());
|
||||
u64* const words_begin = state_words + query_begin / BYTES_PER_WORD;
|
||||
|
|
@ -483,7 +483,7 @@ private:
|
|||
NotifyRasterizer<true>(word_index, current_bits, ~u64{0});
|
||||
}
|
||||
// Exclude CPU modified pages when visiting GPU pages
|
||||
const u64 word = current_word;
|
||||
const u64 word = current_word & ~(type == Type::GPU ? untracked_words[word_index] : 0);
|
||||
u64 page = page_begin;
|
||||
page_begin = 0;
|
||||
|
||||
|
|
@ -531,7 +531,7 @@ private:
|
|||
[[nodiscard]] bool IsRegionModified(u64 offset, u64 size) const noexcept {
|
||||
static_assert(type != Type::Untracked);
|
||||
|
||||
[[maybe_unused]] const u64* const untracked_words = Array<Type::Untracked>();
|
||||
const u64* const untracked_words = Array<Type::Untracked>();
|
||||
const u64* const state_words = Array<type>();
|
||||
const u64 num_query_words = size / BYTES_PER_WORD + 1;
|
||||
const u64 word_begin = offset / BYTES_PER_WORD;
|
||||
|
|
@ -539,7 +539,8 @@ private:
|
|||
const u64 page_limit = Common::DivCeil(offset + size, BYTES_PER_PAGE);
|
||||
u64 page_index = (offset / BYTES_PER_PAGE) % PAGES_PER_WORD;
|
||||
for (u64 word_index = word_begin; word_index < word_end; ++word_index, page_index = 0) {
|
||||
const u64 word = state_words[word_index];
|
||||
const u64 off_word = type == Type::GPU ? untracked_words[word_index] : 0;
|
||||
const u64 word = state_words[word_index] & ~off_word;
|
||||
if (word == 0) {
|
||||
continue;
|
||||
}
|
||||
|
|
@ -563,7 +564,7 @@ private:
|
|||
[[nodiscard]] std::pair<u64, u64> ModifiedRegion(u64 offset, u64 size) const noexcept {
|
||||
static_assert(type != Type::Untracked);
|
||||
|
||||
[[maybe_unused]] const u64* const untracked_words = Array<Type::Untracked>();
|
||||
const u64* const untracked_words = Array<Type::Untracked>();
|
||||
const u64* const state_words = Array<type>();
|
||||
const u64 num_query_words = size / BYTES_PER_WORD + 1;
|
||||
const u64 word_begin = offset / BYTES_PER_WORD;
|
||||
|
|
@ -573,7 +574,8 @@ private:
|
|||
u64 begin = std::numeric_limits<u64>::max();
|
||||
u64 end = 0;
|
||||
for (u64 word_index = word_begin; word_index < word_end; ++word_index) {
|
||||
const u64 word = state_words[word_index];
|
||||
const u64 off_word = type == Type::GPU ? untracked_words[word_index] : 0;
|
||||
const u64 word = state_words[word_index] & ~off_word;
|
||||
if (word == 0) {
|
||||
continue;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -99,7 +99,7 @@ struct GPU::Impl {
|
|||
|
||||
/// Signal the ending of command list.
|
||||
void OnCommandListEnd() {
|
||||
gpu_thread.OnCommandListEnd();
|
||||
rasterizer->ReleaseFences();
|
||||
}
|
||||
|
||||
/// Request a host GPU memory flush from the CPU.
|
||||
|
|
|
|||
|
|
@ -40,8 +40,6 @@ static void RunThread(std::stop_token stop_token, Core::System& system,
|
|||
scheduler.Push(submit_list->channel, std::move(submit_list->entries));
|
||||
} else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) {
|
||||
renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
|
||||
} else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {
|
||||
rasterizer->ReleaseFences();
|
||||
} else if (std::holds_alternative<GPUTickCommand>(next.data)) {
|
||||
system.GPU().TickWork();
|
||||
} else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
|
||||
|
|
@ -110,10 +108,6 @@ void ThreadManager::FlushAndInvalidateRegion(VAddr addr, u64 size) {
|
|||
rasterizer->OnCPUWrite(addr, size);
|
||||
}
|
||||
|
||||
void ThreadManager::OnCommandListEnd() {
|
||||
PushCommand(OnCommandListEndCommand());
|
||||
}
|
||||
|
||||
u64 ThreadManager::PushCommand(CommandData&& command_data, bool block) {
|
||||
if (!is_async) {
|
||||
// In synchronous GPU mode, block the caller until the command has executed
|
||||
|
|
|
|||
|
|
@ -77,16 +77,12 @@ struct FlushAndInvalidateRegionCommand final {
|
|||
u64 size;
|
||||
};
|
||||
|
||||
/// Command called within the gpu, to schedule actions after a command list end
|
||||
struct OnCommandListEndCommand final {};
|
||||
|
||||
/// Command to make the gpu look into pending requests
|
||||
struct GPUTickCommand final {};
|
||||
|
||||
using CommandData =
|
||||
std::variant<std::monostate, SubmitListCommand, SwapBuffersCommand, FlushRegionCommand,
|
||||
InvalidateRegionCommand, FlushAndInvalidateRegionCommand, OnCommandListEndCommand,
|
||||
GPUTickCommand>;
|
||||
InvalidateRegionCommand, FlushAndInvalidateRegionCommand, GPUTickCommand>;
|
||||
|
||||
struct CommandDataContainer {
|
||||
CommandDataContainer() = default;
|
||||
|
|
@ -134,8 +130,6 @@ public:
|
|||
/// Notify rasterizer that any caches of the specified region should be flushed and invalidated
|
||||
void FlushAndInvalidateRegion(VAddr addr, u64 size);
|
||||
|
||||
void OnCommandListEnd();
|
||||
|
||||
void TickGPU();
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -22,6 +22,8 @@ set(SHADER_FILES
|
|||
convert_d24s8_to_abgr8.frag
|
||||
convert_depth_to_float.frag
|
||||
convert_float_to_depth.frag
|
||||
convert_msaa_to_non_msaa.comp
|
||||
convert_non_msaa_to_msaa.comp
|
||||
convert_s8d24_to_abgr8.frag
|
||||
full_screen_triangle.vert
|
||||
fxaa.frag
|
||||
|
|
|
|||
30
src/video_core/host_shaders/convert_msaa_to_non_msaa.comp
Executable file
30
src/video_core/host_shaders/convert_msaa_to_non_msaa.comp
Executable file
|
|
@ -0,0 +1,30 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#version 450 core
|
||||
layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
|
||||
|
||||
layout (binding = 0, rgba8) uniform readonly restrict image2DMSArray msaa_in;
|
||||
layout (binding = 1, rgba8) uniform writeonly restrict image2DArray output_img;
|
||||
|
||||
void main() {
|
||||
const ivec3 coords = ivec3(gl_GlobalInvocationID);
|
||||
if (any(greaterThanEqual(coords, imageSize(msaa_in)))) {
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO: Specialization constants for num_samples?
|
||||
const int num_samples = imageSamples(msaa_in);
|
||||
for (int curr_sample = 0; curr_sample < num_samples; ++curr_sample) {
|
||||
const vec4 pixel = imageLoad(msaa_in, coords, curr_sample);
|
||||
|
||||
const int single_sample_x = 2 * coords.x + (curr_sample & 1);
|
||||
const int single_sample_y = 2 * coords.y + ((curr_sample / 2) & 1);
|
||||
const ivec3 dest_coords = ivec3(single_sample_x, single_sample_y, coords.z);
|
||||
|
||||
if (any(greaterThanEqual(dest_coords, imageSize(output_img)))) {
|
||||
continue;
|
||||
}
|
||||
imageStore(output_img, dest_coords, pixel);
|
||||
}
|
||||
}
|
||||
29
src/video_core/host_shaders/convert_non_msaa_to_msaa.comp
Executable file
29
src/video_core/host_shaders/convert_non_msaa_to_msaa.comp
Executable file
|
|
@ -0,0 +1,29 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#version 450 core
|
||||
layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
|
||||
|
||||
layout (binding = 0, rgba8) uniform readonly restrict image2DArray img_in;
|
||||
layout (binding = 1, rgba8) uniform writeonly restrict image2DMSArray output_msaa;
|
||||
|
||||
void main() {
|
||||
const ivec3 coords = ivec3(gl_GlobalInvocationID);
|
||||
if (any(greaterThanEqual(coords, imageSize(output_msaa)))) {
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO: Specialization constants for num_samples?
|
||||
const int num_samples = imageSamples(output_msaa);
|
||||
for (int curr_sample = 0; curr_sample < num_samples; ++curr_sample) {
|
||||
const int single_sample_x = 2 * coords.x + (curr_sample & 1);
|
||||
const int single_sample_y = 2 * coords.y + ((curr_sample / 2) & 1);
|
||||
const ivec3 single_coords = ivec3(single_sample_x, single_sample_y, coords.z);
|
||||
|
||||
if (any(greaterThanEqual(single_coords, imageSize(img_in)))) {
|
||||
continue;
|
||||
}
|
||||
const vec4 pixel = imageLoad(img_in, single_coords);
|
||||
imageStore(output_msaa, coords, curr_sample, pixel);
|
||||
}
|
||||
}
|
||||
|
|
@ -557,6 +557,14 @@ void TextureCacheRuntime::CopyImage(Image& dst_image, Image& src_image,
|
|||
}
|
||||
}
|
||||
|
||||
void TextureCacheRuntime::CopyImageMSAA(Image& dst_image, Image& src_image,
|
||||
std::span<const VideoCommon::ImageCopy> copies) {
|
||||
LOG_DEBUG(Render_OpenGL, "Copying from {} samples to {} samples", src_image.info.num_samples,
|
||||
dst_image.info.num_samples);
|
||||
// TODO: Leverage the format conversion pass if possible/accurate.
|
||||
util_shaders.CopyMSAA(dst_image, src_image, copies);
|
||||
}
|
||||
|
||||
void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src,
|
||||
std::span<const VideoCommon::ImageCopy> copies) {
|
||||
LOG_DEBUG(Render_OpenGL, "Converting {} to {}", src.info.format, dst.info.format);
|
||||
|
|
|
|||
|
|
@ -93,12 +93,19 @@ public:
|
|||
return device.CanReportMemoryUsage();
|
||||
}
|
||||
|
||||
bool ShouldReinterpret([[maybe_unused]] Image& dst, [[maybe_unused]] Image& src) {
|
||||
bool ShouldReinterpret([[maybe_unused]] Image& dst,
|
||||
[[maybe_unused]] Image& src) const noexcept {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CanUploadMSAA() const noexcept {
|
||||
return true;
|
||||
}
|
||||
|
||||
void CopyImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
|
||||
|
||||
void CopyImageMSAA(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
|
||||
|
||||
void ReinterpretImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
|
||||
|
||||
void ConvertImage(Framebuffer* dst, ImageView& dst_view, ImageView& src_view) {
|
||||
|
|
|
|||
|
|
@ -12,6 +12,8 @@
|
|||
#include "video_core/host_shaders/astc_decoder_comp.h"
|
||||
#include "video_core/host_shaders/block_linear_unswizzle_2d_comp.h"
|
||||
#include "video_core/host_shaders/block_linear_unswizzle_3d_comp.h"
|
||||
#include "video_core/host_shaders/convert_msaa_to_non_msaa_comp.h"
|
||||
#include "video_core/host_shaders/convert_non_msaa_to_msaa_comp.h"
|
||||
#include "video_core/host_shaders/opengl_convert_s8d24_comp.h"
|
||||
#include "video_core/host_shaders/opengl_copy_bc4_comp.h"
|
||||
#include "video_core/host_shaders/pitch_unswizzle_comp.h"
|
||||
|
|
@ -51,7 +53,9 @@ UtilShaders::UtilShaders(ProgramManager& program_manager_)
|
|||
block_linear_unswizzle_3d_program(MakeProgram(BLOCK_LINEAR_UNSWIZZLE_3D_COMP)),
|
||||
pitch_unswizzle_program(MakeProgram(PITCH_UNSWIZZLE_COMP)),
|
||||
copy_bc4_program(MakeProgram(OPENGL_COPY_BC4_COMP)),
|
||||
convert_s8d24_program(MakeProgram(OPENGL_CONVERT_S8D24_COMP)) {
|
||||
convert_s8d24_program(MakeProgram(OPENGL_CONVERT_S8D24_COMP)),
|
||||
convert_ms_to_nonms_program(MakeProgram(CONVERT_MSAA_TO_NON_MSAA_COMP)),
|
||||
convert_nonms_to_ms_program(MakeProgram(CONVERT_NON_MSAA_TO_MSAA_COMP)) {
|
||||
const auto swizzle_table = Tegra::Texture::MakeSwizzleTable();
|
||||
swizzle_table_buffer.Create();
|
||||
glNamedBufferStorage(swizzle_table_buffer.handle, sizeof(swizzle_table), &swizzle_table, 0);
|
||||
|
|
@ -269,6 +273,33 @@ void UtilShaders::ConvertS8D24(Image& dst_image, std::span<const ImageCopy> copi
|
|||
program_manager.RestoreGuestCompute();
|
||||
}
|
||||
|
||||
void UtilShaders::CopyMSAA(Image& dst_image, Image& src_image,
|
||||
std::span<const VideoCommon::ImageCopy> copies) {
|
||||
const bool is_ms_to_non_ms = src_image.info.num_samples > 1 && dst_image.info.num_samples == 1;
|
||||
const auto program_handle =
|
||||
is_ms_to_non_ms ? convert_ms_to_nonms_program.handle : convert_nonms_to_ms_program.handle;
|
||||
program_manager.BindComputeProgram(program_handle);
|
||||
|
||||
for (const ImageCopy& copy : copies) {
|
||||
ASSERT(copy.src_subresource.base_layer == 0);
|
||||
ASSERT(copy.src_subresource.num_layers == 1);
|
||||
ASSERT(copy.dst_subresource.base_layer == 0);
|
||||
ASSERT(copy.dst_subresource.num_layers == 1);
|
||||
|
||||
glBindImageTexture(0, src_image.StorageHandle(), copy.src_subresource.base_level, GL_TRUE,
|
||||
0, GL_READ_ONLY, GL_RGBA8);
|
||||
glBindImageTexture(1, dst_image.StorageHandle(), copy.dst_subresource.base_level, GL_TRUE,
|
||||
0, GL_WRITE_ONLY, GL_RGBA8);
|
||||
|
||||
const u32 num_dispatches_x = Common::DivCeil(copy.extent.width, 8U);
|
||||
const u32 num_dispatches_y = Common::DivCeil(copy.extent.height, 8U);
|
||||
const u32 num_dispatches_z = copy.extent.depth;
|
||||
|
||||
glDispatchCompute(num_dispatches_x, num_dispatches_y, num_dispatches_z);
|
||||
}
|
||||
program_manager.RestoreGuestCompute();
|
||||
}
|
||||
|
||||
GLenum StoreFormat(u32 bytes_per_block) {
|
||||
switch (bytes_per_block) {
|
||||
case 1:
|
||||
|
|
|
|||
|
|
@ -40,6 +40,9 @@ public:
|
|||
|
||||
void ConvertS8D24(Image& dst_image, std::span<const VideoCommon::ImageCopy> copies);
|
||||
|
||||
void CopyMSAA(Image& dst_image, Image& src_image,
|
||||
std::span<const VideoCommon::ImageCopy> copies);
|
||||
|
||||
private:
|
||||
ProgramManager& program_manager;
|
||||
|
||||
|
|
@ -51,6 +54,8 @@ private:
|
|||
OGLProgram pitch_unswizzle_program;
|
||||
OGLProgram copy_bc4_program;
|
||||
OGLProgram convert_s8d24_program;
|
||||
OGLProgram convert_ms_to_nonms_program;
|
||||
OGLProgram convert_nonms_to_ms_program;
|
||||
};
|
||||
|
||||
GLenum StoreFormat(u32 bytes_per_block);
|
||||
|
|
|
|||
|
|
@ -548,31 +548,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
|
|||
static_vector<VkVertexInputBindingDescription, 32> vertex_bindings;
|
||||
static_vector<VkVertexInputBindingDivisorDescriptionEXT, 32> vertex_binding_divisors;
|
||||
static_vector<VkVertexInputAttributeDescription, 32> vertex_attributes;
|
||||
if (key.state.dynamic_vertex_input) {
|
||||
const size_t num_vertex_arrays = std::min(
|
||||
key.state.attributes.size(), static_cast<size_t>(device.GetMaxVertexInputBindings()));
|
||||
for (size_t index = 0; index < num_vertex_arrays; ++index) {
|
||||
const u32 type = key.state.DynamicAttributeType(index);
|
||||
if (!stage_infos[0].loads.Generic(index) || type == 0) {
|
||||
continue;
|
||||
}
|
||||
vertex_attributes.push_back({
|
||||
.location = static_cast<u32>(index),
|
||||
.binding = 0,
|
||||
.format = type == 1 ? VK_FORMAT_R32_SFLOAT
|
||||
: type == 2 ? VK_FORMAT_R32_SINT
|
||||
: VK_FORMAT_R32_UINT,
|
||||
.offset = 0,
|
||||
});
|
||||
}
|
||||
if (!vertex_attributes.empty()) {
|
||||
vertex_bindings.push_back({
|
||||
.binding = 0,
|
||||
.stride = 4,
|
||||
.inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
|
||||
});
|
||||
}
|
||||
} else {
|
||||
if (!key.state.dynamic_vertex_input) {
|
||||
const size_t num_vertex_arrays = std::min(
|
||||
Maxwell::NumVertexArrays, static_cast<size_t>(device.GetMaxVertexInputBindings()));
|
||||
for (size_t index = 0; index < num_vertex_arrays; ++index) {
|
||||
|
|
|
|||
|
|
@ -1230,6 +1230,11 @@ void TextureCacheRuntime::CopyImage(Image& dst, Image& src,
|
|||
});
|
||||
}
|
||||
|
||||
void TextureCacheRuntime::CopyImageMSAA(Image& dst, Image& src,
|
||||
std::span<const VideoCommon::ImageCopy> copies) {
|
||||
UNIMPLEMENTED_MSG("Copying images with different samples is not implemented in Vulkan.");
|
||||
}
|
||||
|
||||
u64 TextureCacheRuntime::GetDeviceLocalMemory() const {
|
||||
return device.GetDeviceLocalMemory();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,6 +70,8 @@ public:
|
|||
|
||||
void CopyImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
|
||||
|
||||
void CopyImageMSAA(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
|
||||
|
||||
bool ShouldReinterpret(Image& dst, Image& src);
|
||||
|
||||
void ReinterpretImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
|
||||
|
|
@ -80,6 +82,11 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
bool CanUploadMSAA() const noexcept {
|
||||
// TODO: Implement buffer to MSAA uploads
|
||||
return false;
|
||||
}
|
||||
|
||||
void AccelerateImageUpload(Image&, const StagingBufferRef&,
|
||||
std::span<const VideoCommon::SwizzleParameters>);
|
||||
|
||||
|
|
|
|||
|
|
@ -22,6 +22,9 @@ std::string Name(const ImageBase& image) {
|
|||
const u32 num_layers = image.info.resources.layers;
|
||||
const u32 num_levels = image.info.resources.levels;
|
||||
std::string resource;
|
||||
if (image.info.num_samples > 1) {
|
||||
resource += fmt::format(":{}xMSAA", image.info.num_samples);
|
||||
}
|
||||
if (num_layers > 1) {
|
||||
resource += fmt::format(":L{}", num_layers);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -773,7 +773,7 @@ void TextureCache<P>::RefreshContents(Image& image, ImageId image_id) {
|
|||
image.flags &= ~ImageFlagBits::CpuModified;
|
||||
TrackImage(image, image_id);
|
||||
|
||||
if (image.info.num_samples > 1) {
|
||||
if (image.info.num_samples > 1 && !runtime.CanUploadMSAA()) {
|
||||
LOG_WARNING(HW_GPU, "MSAA image uploads are not implemented");
|
||||
return;
|
||||
}
|
||||
|
|
@ -1167,14 +1167,14 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
|
|||
if (True(overlap.flags & ImageFlagBits::GpuModified)) {
|
||||
new_image.flags |= ImageFlagBits::GpuModified;
|
||||
}
|
||||
const auto& resolution = Settings::values.resolution_info;
|
||||
const SubresourceBase base = new_image.TryFindBase(overlap.gpu_addr).value();
|
||||
const u32 up_scale = can_rescale ? resolution.up_scale : 1;
|
||||
const u32 down_shift = can_rescale ? resolution.down_shift : 0;
|
||||
auto copies = MakeShrinkImageCopies(new_info, overlap.info, base, up_scale, down_shift);
|
||||
if (overlap.info.num_samples != new_image.info.num_samples) {
|
||||
LOG_WARNING(HW_GPU, "Copying between images with different samples is not implemented");
|
||||
runtime.CopyImageMSAA(new_image, overlap, std::move(copies));
|
||||
} else {
|
||||
const auto& resolution = Settings::values.resolution_info;
|
||||
const SubresourceBase base = new_image.TryFindBase(overlap.gpu_addr).value();
|
||||
const u32 up_scale = can_rescale ? resolution.up_scale : 1;
|
||||
const u32 down_shift = can_rescale ? resolution.down_shift : 0;
|
||||
auto copies = MakeShrinkImageCopies(new_info, overlap.info, base, up_scale, down_shift);
|
||||
runtime.CopyImage(new_image, overlap, std::move(copies));
|
||||
}
|
||||
if (True(overlap.flags & ImageFlagBits::Tracked)) {
|
||||
|
|
|
|||
|
|
@ -573,10 +573,6 @@ u32 CalculateUnswizzledSizeBytes(const ImageInfo& info) noexcept {
|
|||
if (info.type == ImageType::Buffer) {
|
||||
return info.size.width * BytesPerBlock(info.format);
|
||||
}
|
||||
if (info.num_samples > 1) {
|
||||
// Multisample images can't be uploaded or downloaded to the host
|
||||
return 0;
|
||||
}
|
||||
if (info.type == ImageType::Linear) {
|
||||
return info.pitch * Common::DivCeil(info.size.height, DefaultBlockHeight(info.format));
|
||||
}
|
||||
|
|
@ -703,7 +699,7 @@ ImageViewType RenderTargetImageViewType(const ImageInfo& info) noexcept {
|
|||
std::vector<ImageCopy> MakeShrinkImageCopies(const ImageInfo& dst, const ImageInfo& src,
|
||||
SubresourceBase base, u32 up_scale, u32 down_shift) {
|
||||
ASSERT(dst.resources.levels >= src.resources.levels);
|
||||
ASSERT(dst.num_samples == src.num_samples);
|
||||
// ASSERT(dst.num_samples == src.num_samples);
|
||||
|
||||
const bool is_dst_3d = dst.type == ImageType::e3D;
|
||||
if (is_dst_3d) {
|
||||
|
|
|
|||
|
|
@ -353,7 +353,7 @@ if (USE_DISCORD_PRESENCE)
|
|||
discord_impl.cpp
|
||||
discord_impl.h
|
||||
)
|
||||
target_link_libraries(yuzu PRIVATE DiscordRPC::discord-rpc)
|
||||
target_link_libraries(yuzu PRIVATE DiscordRPC::discord-rpc httplib::httplib)
|
||||
target_compile_definitions(yuzu PRIVATE -DUSE_DISCORD_PRESENCE)
|
||||
endif()
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,10 @@
|
|||
#include <chrono>
|
||||
#include <string>
|
||||
#include <discord_rpc.h>
|
||||
#include <fmt/format.h>
|
||||
#include <httplib.h>
|
||||
#include "common/common_types.h"
|
||||
#include "common/string_util.h"
|
||||
#include "core/core.h"
|
||||
#include "core/loader/loader.h"
|
||||
#include "yuzu/discord_impl.h"
|
||||
|
|
@ -14,7 +17,6 @@ namespace DiscordRPC {
|
|||
|
||||
DiscordImpl::DiscordImpl(Core::System& system_) : system{system_} {
|
||||
DiscordEventHandlers handlers{};
|
||||
|
||||
// The number is the client ID for yuzu, it's used for images and the
|
||||
// application name
|
||||
Discord_Initialize("712465656758665259", &handlers, 1, nullptr);
|
||||
|
|
@ -29,23 +31,74 @@ void DiscordImpl::Pause() {
|
|||
Discord_ClearPresence();
|
||||
}
|
||||
|
||||
static std::string GetGameString(const std::string& title) {
|
||||
// Convert to lowercase
|
||||
std::string icon_name = Common::ToLower(title);
|
||||
|
||||
// Replace spaces with dashes
|
||||
std::replace(icon_name.begin(), icon_name.end(), ' ', '-');
|
||||
|
||||
// Remove non-alphanumeric characters but keep dashes
|
||||
std::erase_if(icon_name, [](char c) { return !std::isalnum(c) && c != '-'; });
|
||||
|
||||
// Remove dashes from the start and end of the string
|
||||
icon_name.erase(icon_name.begin(), std::find_if(icon_name.begin(), icon_name.end(),
|
||||
[](int ch) { return ch != '-'; }));
|
||||
icon_name.erase(
|
||||
std::find_if(icon_name.rbegin(), icon_name.rend(), [](int ch) { return ch != '-'; }).base(),
|
||||
icon_name.end());
|
||||
|
||||
// Remove double dashes
|
||||
icon_name.erase(std::unique(icon_name.begin(), icon_name.end(),
|
||||
[](char a, char b) { return a == '-' && b == '-'; }),
|
||||
icon_name.end());
|
||||
|
||||
return icon_name;
|
||||
}
|
||||
|
||||
void DiscordImpl::Update() {
|
||||
s64 start_time = std::chrono::duration_cast<std::chrono::seconds>(
|
||||
std::chrono::system_clock::now().time_since_epoch())
|
||||
.count();
|
||||
const std::string default_text = "yuzu is an emulator for the Nintendo Switch";
|
||||
const std::string default_image = "yuzu_logo_ea";
|
||||
std::string game_cover_url = "https://yuzu-emu.org";
|
||||
std::string title;
|
||||
|
||||
DiscordRichPresence presence{};
|
||||
|
||||
if (system.IsPoweredOn()) {
|
||||
system.GetAppLoader().ReadTitle(title);
|
||||
}
|
||||
DiscordRichPresence presence{};
|
||||
presence.largeImageKey = "yuzu_logo_ea";
|
||||
presence.largeImageText = "yuzu is an emulator for the Nintendo Switch";
|
||||
if (system.IsPoweredOn()) {
|
||||
|
||||
// Used to format Icon URL for yuzu website game compatibility page
|
||||
std::string icon_name = GetGameString(title);
|
||||
|
||||
// New Check for game cover
|
||||
httplib::Client cli(game_cover_url);
|
||||
|
||||
if (auto res = cli.Head(fmt::format("/images/game/boxart/{}.png", icon_name).c_str())) {
|
||||
if (res->status == 200) {
|
||||
game_cover_url += fmt::format("/images/game/boxart/{}.png", icon_name);
|
||||
} else {
|
||||
game_cover_url = "yuzu_logo_ea";
|
||||
}
|
||||
} else {
|
||||
game_cover_url = "yuzu_logo_ea";
|
||||
}
|
||||
|
||||
presence.largeImageKey = game_cover_url.c_str();
|
||||
presence.largeImageText = title.c_str();
|
||||
|
||||
presence.smallImageKey = default_image.c_str();
|
||||
presence.smallImageText = default_text.c_str();
|
||||
presence.state = title.c_str();
|
||||
presence.details = "Currently in game";
|
||||
} else {
|
||||
presence.details = "Not in game";
|
||||
presence.largeImageKey = default_image.c_str();
|
||||
presence.largeImageText = default_text.c_str();
|
||||
presence.details = "Currently not in game";
|
||||
}
|
||||
|
||||
presence.startTimestamp = start_time;
|
||||
Discord_UpdatePresence(&presence);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -286,11 +286,14 @@ vulkan_device =
|
|||
# 0: 0.5x (360p/540p) [EXPERIMENTAL]
|
||||
# 1: 0.75x (540p/810p) [EXPERIMENTAL]
|
||||
# 2 (default): 1x (720p/1080p)
|
||||
# 3: 2x (1440p/2160p)
|
||||
# 4: 3x (2160p/3240p)
|
||||
# 5: 4x (2880p/4320p)
|
||||
# 6: 5x (3600p/5400p)
|
||||
# 7: 6x (4320p/6480p)
|
||||
# 3: 1.5x (1080p/1620p) [EXPERIMENTAL]
|
||||
# 4: 2x (1440p/2160p)
|
||||
# 5: 3x (2160p/3240p)
|
||||
# 6: 4x (2880p/4320p)
|
||||
# 7: 5x (3600p/5400p)
|
||||
# 8: 6x (4320p/6480p)
|
||||
# 9: 7x (5040p/7560p)
|
||||
# 10: 8x (5760/8640p)
|
||||
resolution_setup =
|
||||
|
||||
# Pixel filter to use when up- or down-sampling rendered frames.
|
||||
|
|
@ -299,11 +302,11 @@ resolution_setup =
|
|||
# 2: Bicubic
|
||||
# 3: Gaussian
|
||||
# 4: ScaleForce
|
||||
# 5: AMD FidelityFX™️ Super Resolution [Vulkan Only]
|
||||
# 5: AMD FidelityFX™️ Super Resolution
|
||||
scaling_filter =
|
||||
|
||||
# Anti-Aliasing (AA)
|
||||
# 0 (default): None, 1: FXAA
|
||||
# 0 (default): None, 1: FXAA, 2: SMAA
|
||||
anti_aliasing =
|
||||
|
||||
# Whether to use fullscreen or borderless window mode
|
||||
|
|
|
|||
Loading…
Reference in a new issue