mirror of
https://github.com/yuzu-emu/yuzu.git
synced 2024-11-14 10:04:57 +00:00
Merge pull request #398 from lioncash/kernel
kernel: Migrate logging macros to fmt-compatible ones
This commit is contained in:
commit
dd6c67c627
11 changed files with 110 additions and 107 deletions
|
@ -26,7 +26,7 @@ ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
|
||||||
|
|
||||||
u16 slot = next_free_slot;
|
u16 slot = next_free_slot;
|
||||||
if (slot >= generations.size()) {
|
if (slot >= generations.size()) {
|
||||||
LOG_ERROR(Kernel, "Unable to allocate Handle, too many slots in use.");
|
NGLOG_ERROR(Kernel, "Unable to allocate Handle, too many slots in use.");
|
||||||
return ERR_OUT_OF_HANDLES;
|
return ERR_OUT_OF_HANDLES;
|
||||||
}
|
}
|
||||||
next_free_slot = generations[slot];
|
next_free_slot = generations[slot];
|
||||||
|
@ -48,7 +48,7 @@ ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
|
||||||
ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
|
ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
|
||||||
SharedPtr<Object> object = GetGeneric(handle);
|
SharedPtr<Object> object = GetGeneric(handle);
|
||||||
if (object == nullptr) {
|
if (object == nullptr) {
|
||||||
LOG_ERROR(Kernel, "Tried to duplicate invalid handle: %08X", handle);
|
NGLOG_ERROR(Kernel, "Tried to duplicate invalid handle: {:08X}", handle);
|
||||||
return ERR_INVALID_HANDLE;
|
return ERR_INVALID_HANDLE;
|
||||||
}
|
}
|
||||||
return Create(std::move(object));
|
return Create(std::move(object));
|
||||||
|
|
|
@ -118,7 +118,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
|
||||||
std::make_shared<IPC::DomainMessageHeader>(rp.PopRaw<IPC::DomainMessageHeader>());
|
std::make_shared<IPC::DomainMessageHeader>(rp.PopRaw<IPC::DomainMessageHeader>());
|
||||||
} else {
|
} else {
|
||||||
if (Session()->IsDomain())
|
if (Session()->IsDomain())
|
||||||
LOG_WARNING(IPC, "Domain request has no DomainMessageHeader!");
|
NGLOG_WARNING(IPC, "Domain request has no DomainMessageHeader!");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -270,7 +270,8 @@ size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size) const {
|
||||||
const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
|
const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
|
||||||
const size_t buffer_size{GetWriteBufferSize()};
|
const size_t buffer_size{GetWriteBufferSize()};
|
||||||
if (size > buffer_size) {
|
if (size > buffer_size) {
|
||||||
LOG_CRITICAL(Core, "size (%016zx) is greater than buffer_size (%016zx)", size, buffer_size);
|
NGLOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
|
||||||
|
buffer_size);
|
||||||
size = buffer_size; // TODO(bunnei): This needs to be HW tested
|
size = buffer_size; // TODO(bunnei): This needs to be HW tested
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -54,7 +54,7 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
|
||||||
continue;
|
continue;
|
||||||
} else if ((type & 0xF00) == 0xE00) { // 0x0FFF
|
} else if ((type & 0xF00) == 0xE00) { // 0x0FFF
|
||||||
// Allowed interrupts list
|
// Allowed interrupts list
|
||||||
LOG_WARNING(Loader, "ExHeader allowed interrupts list ignored");
|
NGLOG_WARNING(Loader, "ExHeader allowed interrupts list ignored");
|
||||||
} else if ((type & 0xF80) == 0xF00) { // 0x07FF
|
} else if ((type & 0xF80) == 0xF00) { // 0x07FF
|
||||||
// Allowed syscalls mask
|
// Allowed syscalls mask
|
||||||
unsigned int index = ((descriptor >> 24) & 7) * 24;
|
unsigned int index = ((descriptor >> 24) & 7) * 24;
|
||||||
|
@ -74,7 +74,7 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
|
||||||
} else if ((type & 0xFFE) == 0xFF8) { // 0x001F
|
} else if ((type & 0xFFE) == 0xFF8) { // 0x001F
|
||||||
// Mapped memory range
|
// Mapped memory range
|
||||||
if (i + 1 >= len || ((kernel_caps[i + 1] >> 20) & 0xFFE) != 0xFF8) {
|
if (i + 1 >= len || ((kernel_caps[i + 1] >> 20) & 0xFFE) != 0xFF8) {
|
||||||
LOG_WARNING(Loader, "Incomplete exheader memory range descriptor ignored.");
|
NGLOG_WARNING(Loader, "Incomplete exheader memory range descriptor ignored.");
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
u32 end_desc = kernel_caps[i + 1];
|
u32 end_desc = kernel_caps[i + 1];
|
||||||
|
@ -109,9 +109,9 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
|
||||||
|
|
||||||
int minor = kernel_version & 0xFF;
|
int minor = kernel_version & 0xFF;
|
||||||
int major = (kernel_version >> 8) & 0xFF;
|
int major = (kernel_version >> 8) & 0xFF;
|
||||||
LOG_INFO(Loader, "ExHeader kernel version: %d.%d", major, minor);
|
NGLOG_INFO(Loader, "ExHeader kernel version: {}.{}", major, minor);
|
||||||
} else {
|
} else {
|
||||||
LOG_ERROR(Loader, "Unhandled kernel caps descriptor: 0x%08X", descriptor);
|
NGLOG_ERROR(Loader, "Unhandled kernel caps descriptor: {:#010X}", descriptor);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -29,7 +29,7 @@ SharedPtr<ResourceLimit> ResourceLimit::GetForCategory(ResourceLimitCategory cat
|
||||||
case ResourceLimitCategory::OTHER:
|
case ResourceLimitCategory::OTHER:
|
||||||
return resource_limits[static_cast<u8>(category)];
|
return resource_limits[static_cast<u8>(category)];
|
||||||
default:
|
default:
|
||||||
LOG_CRITICAL(Kernel, "Unknown resource limit category");
|
NGLOG_CRITICAL(Kernel, "Unknown resource limit category");
|
||||||
UNREACHABLE();
|
UNREACHABLE();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -55,7 +55,7 @@ s32 ResourceLimit::GetCurrentResourceValue(ResourceType resource) const {
|
||||||
case ResourceType::CPUTime:
|
case ResourceType::CPUTime:
|
||||||
return current_cpu_time;
|
return current_cpu_time;
|
||||||
default:
|
default:
|
||||||
LOG_ERROR(Kernel, "Unknown resource type=%08X", static_cast<u32>(resource));
|
NGLOG_ERROR(Kernel, "Unknown resource type={:08X}", static_cast<u32>(resource));
|
||||||
UNIMPLEMENTED();
|
UNIMPLEMENTED();
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -84,7 +84,7 @@ u32 ResourceLimit::GetMaxResourceValue(ResourceType resource) const {
|
||||||
case ResourceType::CPUTime:
|
case ResourceType::CPUTime:
|
||||||
return max_cpu_time;
|
return max_cpu_time;
|
||||||
default:
|
default:
|
||||||
LOG_ERROR(Kernel, "Unknown resource type=%08X", static_cast<u32>(resource));
|
NGLOG_ERROR(Kernel, "Unknown resource type={:08X}", static_cast<u32>(resource));
|
||||||
UNIMPLEMENTED();
|
UNIMPLEMENTED();
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -94,11 +94,11 @@ void Scheduler::Reschedule() {
|
||||||
Thread* next = PopNextReadyThread();
|
Thread* next = PopNextReadyThread();
|
||||||
|
|
||||||
if (cur && next) {
|
if (cur && next) {
|
||||||
LOG_TRACE(Kernel, "context switch %u -> %u", cur->GetObjectId(), next->GetObjectId());
|
NGLOG_TRACE(Kernel, "context switch {} -> {}", cur->GetObjectId(), next->GetObjectId());
|
||||||
} else if (cur) {
|
} else if (cur) {
|
||||||
LOG_TRACE(Kernel, "context switch %u -> idle", cur->GetObjectId());
|
NGLOG_TRACE(Kernel, "context switch {} -> idle", cur->GetObjectId());
|
||||||
} else if (next) {
|
} else if (next) {
|
||||||
LOG_TRACE(Kernel, "context switch idle -> %u", next->GetObjectId());
|
NGLOG_TRACE(Kernel, "context switch idle -> {}", next->GetObjectId());
|
||||||
}
|
}
|
||||||
|
|
||||||
SwitchContext(next);
|
SwitchContext(next);
|
||||||
|
|
|
@ -68,7 +68,7 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
|
||||||
return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
|
return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
|
||||||
|
|
||||||
case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
|
case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
|
||||||
LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x%08X", object_id);
|
NGLOG_DEBUG(IPC, "CloseVirtualHandle, object_id={:#010X}", object_id);
|
||||||
|
|
||||||
domain_request_handlers[object_id - 1] = nullptr;
|
domain_request_handlers[object_id - 1] = nullptr;
|
||||||
|
|
||||||
|
@ -78,8 +78,8 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
LOG_CRITICAL(IPC, "Unknown domain command=%d",
|
NGLOG_CRITICAL(IPC, "Unknown domain command={}",
|
||||||
static_cast<int>(domain_message_header->command.Value()));
|
static_cast<int>(domain_message_header->command.Value()));
|
||||||
ASSERT(false);
|
ASSERT(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -107,16 +107,16 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
|
||||||
|
|
||||||
// Error out if the requested permissions don't match what the creator process allows.
|
// Error out if the requested permissions don't match what the creator process allows.
|
||||||
if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
|
if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
|
||||||
LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, permissions don't match",
|
NGLOG_ERROR(Kernel, "cannot map id={}, address={:#X} name={}, permissions don't match",
|
||||||
GetObjectId(), address, name.c_str());
|
GetObjectId(), address, name);
|
||||||
return ERR_INVALID_COMBINATION;
|
return ERR_INVALID_COMBINATION;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Error out if the provided permissions are not compatible with what the creator process needs.
|
// Error out if the provided permissions are not compatible with what the creator process needs.
|
||||||
if (other_permissions != MemoryPermission::DontCare &&
|
if (other_permissions != MemoryPermission::DontCare &&
|
||||||
static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
|
static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
|
||||||
LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, permissions don't match",
|
NGLOG_ERROR(Kernel, "cannot map id={}, address={:#X} name={}, permissions don't match",
|
||||||
GetObjectId(), address, name.c_str());
|
GetObjectId(), address, name);
|
||||||
return ERR_WRONG_PERMISSION;
|
return ERR_WRONG_PERMISSION;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -131,9 +131,10 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
|
||||||
auto result = target_process->vm_manager.MapMemoryBlock(
|
auto result = target_process->vm_manager.MapMemoryBlock(
|
||||||
target_address, backing_block, backing_block_offset, size, MemoryState::Shared);
|
target_address, backing_block, backing_block_offset, size, MemoryState::Shared);
|
||||||
if (result.Failed()) {
|
if (result.Failed()) {
|
||||||
LOG_ERROR(Kernel,
|
NGLOG_ERROR(
|
||||||
"cannot map id=%u, target_address=0x%lx name=%s, error mapping to virtual memory",
|
Kernel,
|
||||||
GetObjectId(), target_address, name.c_str());
|
"cannot map id={}, target_address={:#X} name={}, error mapping to virtual memory",
|
||||||
|
GetObjectId(), target_address, name);
|
||||||
return result.Code();
|
return result.Code();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -151,7 +152,7 @@ VMAPermission SharedMemory::ConvertPermissions(MemoryPermission permission) {
|
||||||
u32 masked_permissions =
|
u32 masked_permissions =
|
||||||
static_cast<u32>(permission) & static_cast<u32>(MemoryPermission::ReadWriteExecute);
|
static_cast<u32>(permission) & static_cast<u32>(MemoryPermission::ReadWriteExecute);
|
||||||
return static_cast<VMAPermission>(masked_permissions);
|
return static_cast<VMAPermission>(masked_permissions);
|
||||||
};
|
}
|
||||||
|
|
||||||
u8* SharedMemory::GetPointer(u32 offset) {
|
u8* SharedMemory::GetPointer(u32 offset) {
|
||||||
return backing_block->data() + backing_block_offset + offset;
|
return backing_block->data() + backing_block_offset + offset;
|
||||||
|
|
|
@ -31,7 +31,7 @@ namespace Kernel {
|
||||||
|
|
||||||
/// Set the process heap to a given Size. It can both extend and shrink the heap.
|
/// Set the process heap to a given Size. It can both extend and shrink the heap.
|
||||||
static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
|
static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
|
||||||
LOG_TRACE(Kernel_SVC, "called, heap_size=0x%llx", heap_size);
|
NGLOG_TRACE(Kernel_SVC, "called, heap_size={:#X}", heap_size);
|
||||||
auto& process = *Core::CurrentProcess();
|
auto& process = *Core::CurrentProcess();
|
||||||
CASCADE_RESULT(*heap_addr,
|
CASCADE_RESULT(*heap_addr,
|
||||||
process.HeapAllocate(Memory::HEAP_VADDR, heap_size, VMAPermission::ReadWrite));
|
process.HeapAllocate(Memory::HEAP_VADDR, heap_size, VMAPermission::ReadWrite));
|
||||||
|
@ -39,21 +39,21 @@ static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
|
||||||
}
|
}
|
||||||
|
|
||||||
static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
|
static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
|
||||||
LOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x%lx", addr);
|
NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, addr={:#X}", addr);
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Maps a memory range into a different range.
|
/// Maps a memory range into a different range.
|
||||||
static ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
|
static ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
|
||||||
LOG_TRACE(Kernel_SVC, "called, dst_addr=0x%llx, src_addr=0x%llx, size=0x%llx", dst_addr,
|
NGLOG_TRACE(Kernel_SVC, "called, dst_addr={:#X}, src_addr={:#X}, size={:#X}", dst_addr,
|
||||||
src_addr, size);
|
src_addr, size);
|
||||||
return Core::CurrentProcess()->MirrorMemory(dst_addr, src_addr, size);
|
return Core::CurrentProcess()->MirrorMemory(dst_addr, src_addr, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Unmaps a region that was previously mapped with svcMapMemory
|
/// Unmaps a region that was previously mapped with svcMapMemory
|
||||||
static ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
|
static ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
|
||||||
LOG_TRACE(Kernel_SVC, "called, dst_addr=0x%llx, src_addr=0x%llx, size=0x%llx", dst_addr,
|
NGLOG_TRACE(Kernel_SVC, "called, dst_addr={:#X}, src_addr={:#X}, size={:#X}", dst_addr,
|
||||||
src_addr, size);
|
src_addr, size);
|
||||||
return Core::CurrentProcess()->UnmapMemory(dst_addr, src_addr, size);
|
return Core::CurrentProcess()->UnmapMemory(dst_addr, src_addr, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -68,11 +68,11 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
|
||||||
if (port_name.size() > PortNameMaxLength)
|
if (port_name.size() > PortNameMaxLength)
|
||||||
return ERR_PORT_NAME_TOO_LONG;
|
return ERR_PORT_NAME_TOO_LONG;
|
||||||
|
|
||||||
LOG_TRACE(Kernel_SVC, "called port_name=%s", port_name.c_str());
|
NGLOG_TRACE(Kernel_SVC, "called port_name={}", port_name);
|
||||||
|
|
||||||
auto it = Service::g_kernel_named_ports.find(port_name);
|
auto it = Service::g_kernel_named_ports.find(port_name);
|
||||||
if (it == Service::g_kernel_named_ports.end()) {
|
if (it == Service::g_kernel_named_ports.end()) {
|
||||||
LOG_WARNING(Kernel_SVC, "tried to connect to unknown port: %s", port_name.c_str());
|
NGLOG_WARNING(Kernel_SVC, "tried to connect to unknown port: {}", port_name);
|
||||||
return ERR_NOT_FOUND;
|
return ERR_NOT_FOUND;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -90,11 +90,11 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
|
||||||
static ResultCode SendSyncRequest(Handle handle) {
|
static ResultCode SendSyncRequest(Handle handle) {
|
||||||
SharedPtr<ClientSession> session = g_handle_table.Get<ClientSession>(handle);
|
SharedPtr<ClientSession> session = g_handle_table.Get<ClientSession>(handle);
|
||||||
if (!session) {
|
if (!session) {
|
||||||
LOG_ERROR(Kernel_SVC, "called with invalid handle=0x%08X", handle);
|
NGLOG_ERROR(Kernel_SVC, "called with invalid handle={:#010X}", handle);
|
||||||
return ERR_INVALID_HANDLE;
|
return ERR_INVALID_HANDLE;
|
||||||
}
|
}
|
||||||
|
|
||||||
LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s)", handle, session->GetName().c_str());
|
NGLOG_TRACE(Kernel_SVC, "called handle={:#010X}({})", handle, session->GetName());
|
||||||
|
|
||||||
Core::System::GetInstance().PrepareReschedule();
|
Core::System::GetInstance().PrepareReschedule();
|
||||||
|
|
||||||
|
@ -105,7 +105,7 @@ static ResultCode SendSyncRequest(Handle handle) {
|
||||||
|
|
||||||
/// Get the ID for the specified thread.
|
/// Get the ID for the specified thread.
|
||||||
static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
|
static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
|
||||||
LOG_TRACE(Kernel_SVC, "called thread=0x%08X", thread_handle);
|
NGLOG_TRACE(Kernel_SVC, "called thread={:#010X}", thread_handle);
|
||||||
|
|
||||||
const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
|
const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
|
||||||
if (!thread) {
|
if (!thread) {
|
||||||
|
@ -118,7 +118,7 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
|
||||||
|
|
||||||
/// Get the ID of the specified process
|
/// Get the ID of the specified process
|
||||||
static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
|
static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
|
||||||
LOG_TRACE(Kernel_SVC, "called process=0x%08X", process_handle);
|
NGLOG_TRACE(Kernel_SVC, "called process={:#010X}", process_handle);
|
||||||
|
|
||||||
const SharedPtr<Process> process = g_handle_table.Get<Process>(process_handle);
|
const SharedPtr<Process> process = g_handle_table.Get<Process>(process_handle);
|
||||||
if (!process) {
|
if (!process) {
|
||||||
|
@ -178,8 +178,8 @@ static ResultCode WaitSynchronization1(
|
||||||
/// Wait for the given handles to synchronize, timeout after the specified nanoseconds
|
/// Wait for the given handles to synchronize, timeout after the specified nanoseconds
|
||||||
static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64 handle_count,
|
static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64 handle_count,
|
||||||
s64 nano_seconds) {
|
s64 nano_seconds) {
|
||||||
LOG_TRACE(Kernel_SVC, "called handles_address=0x%llx, handle_count=%d, nano_seconds=%d",
|
NGLOG_TRACE(Kernel_SVC, "called handles_address={:#X}, handle_count={}, nano_seconds={}",
|
||||||
handles_address, handle_count, nano_seconds);
|
handles_address, handle_count, nano_seconds);
|
||||||
|
|
||||||
if (!Memory::IsValidVirtualAddress(handles_address))
|
if (!Memory::IsValidVirtualAddress(handles_address))
|
||||||
return ERR_INVALID_POINTER;
|
return ERR_INVALID_POINTER;
|
||||||
|
@ -239,7 +239,7 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
|
||||||
|
|
||||||
/// Resumes a thread waiting on WaitSynchronization
|
/// Resumes a thread waiting on WaitSynchronization
|
||||||
static ResultCode CancelSynchronization(Handle thread_handle) {
|
static ResultCode CancelSynchronization(Handle thread_handle) {
|
||||||
LOG_TRACE(Kernel_SVC, "called thread=0x%08X", thread_handle);
|
NGLOG_TRACE(Kernel_SVC, "called thread={:#X}", thread_handle);
|
||||||
|
|
||||||
const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
|
const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
|
||||||
if (!thread) {
|
if (!thread) {
|
||||||
|
@ -256,38 +256,38 @@ static ResultCode CancelSynchronization(Handle thread_handle) {
|
||||||
/// Attempts to locks a mutex, creating it if it does not already exist
|
/// Attempts to locks a mutex, creating it if it does not already exist
|
||||||
static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
|
static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
|
||||||
Handle requesting_thread_handle) {
|
Handle requesting_thread_handle) {
|
||||||
LOG_TRACE(Kernel_SVC,
|
NGLOG_TRACE(Kernel_SVC,
|
||||||
"called holding_thread_handle=0x%08X, mutex_addr=0x%llx, "
|
"called holding_thread_handle={:#010X}, mutex_addr={:#X}, "
|
||||||
"requesting_current_thread_handle=0x%08X",
|
"requesting_current_thread_handle={:#010X}",
|
||||||
holding_thread_handle, mutex_addr, requesting_thread_handle);
|
holding_thread_handle, mutex_addr, requesting_thread_handle);
|
||||||
|
|
||||||
return Mutex::TryAcquire(mutex_addr, holding_thread_handle, requesting_thread_handle);
|
return Mutex::TryAcquire(mutex_addr, holding_thread_handle, requesting_thread_handle);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Unlock a mutex
|
/// Unlock a mutex
|
||||||
static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
|
static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
|
||||||
LOG_TRACE(Kernel_SVC, "called mutex_addr=0x%llx", mutex_addr);
|
NGLOG_TRACE(Kernel_SVC, "called mutex_addr={:#X}", mutex_addr);
|
||||||
|
|
||||||
return Mutex::Release(mutex_addr);
|
return Mutex::Release(mutex_addr);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Break program execution
|
/// Break program execution
|
||||||
static void Break(u64 unk_0, u64 unk_1, u64 unk_2) {
|
static void Break(u64 unk_0, u64 unk_1, u64 unk_2) {
|
||||||
LOG_CRITICAL(Debug_Emulated, "Emulated program broke execution!");
|
NGLOG_CRITICAL(Debug_Emulated, "Emulated program broke execution!");
|
||||||
ASSERT(false);
|
ASSERT(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Used to output a message on a debug hardware unit - does nothing on a retail unit
|
/// Used to output a message on a debug hardware unit - does nothing on a retail unit
|
||||||
static void OutputDebugString(VAddr address, s32 len) {
|
static void OutputDebugString(VAddr address, s32 len) {
|
||||||
std::vector<char> string(len);
|
std::string str(len, '\0');
|
||||||
Memory::ReadBlock(address, string.data(), len);
|
Memory::ReadBlock(address, str.data(), str.size());
|
||||||
LOG_DEBUG(Debug_Emulated, "%.*s", len, string.data());
|
NGLOG_DEBUG(Debug_Emulated, "{}", str);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Gets system/memory information for the current process
|
/// Gets system/memory information for the current process
|
||||||
static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id) {
|
static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id) {
|
||||||
LOG_TRACE(Kernel_SVC, "called info_id=0x%X, info_sub_id=0x%X, handle=0x%08X", info_id,
|
NGLOG_TRACE(Kernel_SVC, "called info_id={:#X}, info_sub_id={:#X}, handle={:#010X}", info_id,
|
||||||
info_sub_id, handle);
|
info_sub_id, handle);
|
||||||
|
|
||||||
auto& vm_manager = Core::CurrentProcess()->vm_manager;
|
auto& vm_manager = Core::CurrentProcess()->vm_manager;
|
||||||
|
|
||||||
|
@ -338,12 +338,12 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
|
||||||
*result = Core::CurrentProcess()->is_virtual_address_memory_enabled;
|
*result = Core::CurrentProcess()->is_virtual_address_memory_enabled;
|
||||||
break;
|
break;
|
||||||
case GetInfoType::TitleId:
|
case GetInfoType::TitleId:
|
||||||
LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query titleid, returned 0");
|
NGLOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query titleid, returned 0");
|
||||||
*result = 0;
|
*result = 0;
|
||||||
break;
|
break;
|
||||||
case GetInfoType::PrivilegedProcessId:
|
case GetInfoType::PrivilegedProcessId:
|
||||||
LOG_WARNING(Kernel_SVC,
|
NGLOG_WARNING(Kernel_SVC,
|
||||||
"(STUBBED) Attempted to query priviledged process id bounds, returned 0");
|
"(STUBBED) Attempted to query privileged process id bounds, returned 0");
|
||||||
*result = 0;
|
*result = 0;
|
||||||
break;
|
break;
|
||||||
default:
|
default:
|
||||||
|
@ -355,13 +355,14 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
|
||||||
|
|
||||||
/// Sets the thread activity
|
/// Sets the thread activity
|
||||||
static ResultCode SetThreadActivity(Handle handle, u32 unknown) {
|
static ResultCode SetThreadActivity(Handle handle, u32 unknown) {
|
||||||
LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x%08X, unknown=0x%08X", handle, unknown);
|
NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle={:#010X}, unknown={:#010X}", handle,
|
||||||
|
unknown);
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Gets the thread context
|
/// Gets the thread context
|
||||||
static ResultCode GetThreadContext(Handle handle, VAddr addr) {
|
static ResultCode GetThreadContext(Handle handle, VAddr addr) {
|
||||||
LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x%08X, addr=0x%" PRIx64, handle, addr);
|
NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle={:#010X}, addr={:#X}", handle, addr);
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -400,15 +401,15 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
|
||||||
|
|
||||||
/// Get which CPU core is executing the current thread
|
/// Get which CPU core is executing the current thread
|
||||||
static u32 GetCurrentProcessorNumber() {
|
static u32 GetCurrentProcessorNumber() {
|
||||||
LOG_WARNING(Kernel_SVC, "(STUBBED) called, defaulting to processor 0");
|
NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, defaulting to processor 0");
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size,
|
static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size,
|
||||||
u32 permissions) {
|
u32 permissions) {
|
||||||
LOG_TRACE(Kernel_SVC,
|
NGLOG_TRACE(Kernel_SVC,
|
||||||
"called, shared_memory_handle=0x%08X, addr=0x%llx, size=0x%llx, permissions=0x%08X",
|
"called, shared_memory_handle={:#X}, addr={:#X}, size={:#X}, permissions={:#010X}",
|
||||||
shared_memory_handle, addr, size, permissions);
|
shared_memory_handle, addr, size, permissions);
|
||||||
|
|
||||||
SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
|
SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
|
||||||
if (!shared_memory) {
|
if (!shared_memory) {
|
||||||
|
@ -428,16 +429,15 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
|
||||||
return shared_memory->Map(Core::CurrentProcess().get(), addr, permissions_type,
|
return shared_memory->Map(Core::CurrentProcess().get(), addr, permissions_type,
|
||||||
MemoryPermission::DontCare);
|
MemoryPermission::DontCare);
|
||||||
default:
|
default:
|
||||||
LOG_ERROR(Kernel_SVC, "unknown permissions=0x%08X", permissions);
|
NGLOG_ERROR(Kernel_SVC, "unknown permissions={:#010X}", permissions);
|
||||||
}
|
}
|
||||||
|
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
|
static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
|
||||||
LOG_WARNING(Kernel_SVC,
|
NGLOG_WARNING(Kernel_SVC, "called, shared_memory_handle={:#010X}, addr={:#X}, size={:#X}",
|
||||||
"called, shared_memory_handle=0x%08X, addr=0x%" PRIx64 ", size=0x%" PRIx64 "",
|
shared_memory_handle, addr, size);
|
||||||
shared_memory_handle, addr, size);
|
|
||||||
|
|
||||||
SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
|
SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
|
||||||
|
|
||||||
|
@ -465,19 +465,19 @@ static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_i
|
||||||
memory_info->type = static_cast<u32>(vma->second.meminfo_state);
|
memory_info->type = static_cast<u32>(vma->second.meminfo_state);
|
||||||
}
|
}
|
||||||
|
|
||||||
LOG_TRACE(Kernel_SVC, "called process=0x%08X addr=%llx", process_handle, addr);
|
NGLOG_TRACE(Kernel_SVC, "called process={:#010X} addr={:X}", process_handle, addr);
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Query memory
|
/// Query memory
|
||||||
static ResultCode QueryMemory(MemoryInfo* memory_info, PageInfo* page_info, VAddr addr) {
|
static ResultCode QueryMemory(MemoryInfo* memory_info, PageInfo* page_info, VAddr addr) {
|
||||||
LOG_TRACE(Kernel_SVC, "called, addr=%llx", addr);
|
NGLOG_TRACE(Kernel_SVC, "called, addr={:X}", addr);
|
||||||
return QueryProcessMemory(memory_info, page_info, CurrentProcess, addr);
|
return QueryProcessMemory(memory_info, page_info, CurrentProcess, addr);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Exits the current process
|
/// Exits the current process
|
||||||
static void ExitProcess() {
|
static void ExitProcess() {
|
||||||
LOG_INFO(Kernel_SVC, "Process %u exiting", Core::CurrentProcess()->process_id);
|
NGLOG_INFO(Kernel_SVC, "Process {} exiting", Core::CurrentProcess()->process_id);
|
||||||
|
|
||||||
ASSERT_MSG(Core::CurrentProcess()->status == ProcessStatus::Running,
|
ASSERT_MSG(Core::CurrentProcess()->status == ProcessStatus::Running,
|
||||||
"Process has already exited");
|
"Process has already exited");
|
||||||
|
@ -534,9 +534,9 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
|
||||||
case THREADPROCESSORID_2:
|
case THREADPROCESSORID_2:
|
||||||
case THREADPROCESSORID_3:
|
case THREADPROCESSORID_3:
|
||||||
// TODO(bunnei): Implement support for other processor IDs
|
// TODO(bunnei): Implement support for other processor IDs
|
||||||
LOG_ERROR(Kernel_SVC,
|
NGLOG_ERROR(Kernel_SVC,
|
||||||
"Newly created thread must run in another thread (%u), unimplemented.",
|
"Newly created thread must run in another thread ({}), unimplemented.",
|
||||||
processor_id);
|
processor_id);
|
||||||
break;
|
break;
|
||||||
default:
|
default:
|
||||||
ASSERT_MSG(false, "Unsupported thread processor ID: %d", processor_id);
|
ASSERT_MSG(false, "Unsupported thread processor ID: %d", processor_id);
|
||||||
|
@ -551,17 +551,17 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
|
||||||
|
|
||||||
Core::System::GetInstance().PrepareReschedule();
|
Core::System::GetInstance().PrepareReschedule();
|
||||||
|
|
||||||
LOG_TRACE(Kernel_SVC,
|
NGLOG_TRACE(Kernel_SVC,
|
||||||
"called entrypoint=0x%08X (%s), arg=0x%08X, stacktop=0x%08X, "
|
"called entrypoint={:#010X} ({}), arg={:#010X}, stacktop={:#010X}, "
|
||||||
"threadpriority=0x%08X, processorid=0x%08X : created handle=0x%08X",
|
"threadpriority={:#010X}, processorid={:#010X} : created handle={:#010X}",
|
||||||
entry_point, name.c_str(), arg, stack_top, priority, processor_id, *out_handle);
|
entry_point, name, arg, stack_top, priority, processor_id, *out_handle);
|
||||||
|
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Starts the thread for the provided handle
|
/// Starts the thread for the provided handle
|
||||||
static ResultCode StartThread(Handle thread_handle) {
|
static ResultCode StartThread(Handle thread_handle) {
|
||||||
LOG_TRACE(Kernel_SVC, "called thread=0x%08X", thread_handle);
|
NGLOG_TRACE(Kernel_SVC, "called thread={:#010X}", thread_handle);
|
||||||
|
|
||||||
const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
|
const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
|
||||||
if (!thread) {
|
if (!thread) {
|
||||||
|
@ -575,7 +575,7 @@ static ResultCode StartThread(Handle thread_handle) {
|
||||||
|
|
||||||
/// Called when a thread exits
|
/// Called when a thread exits
|
||||||
static void ExitThread() {
|
static void ExitThread() {
|
||||||
LOG_TRACE(Kernel_SVC, "called, pc=0x%08X", Core::CPU().GetPC());
|
NGLOG_TRACE(Kernel_SVC, "called, pc={:#010X}", Core::CPU().GetPC());
|
||||||
|
|
||||||
ExitCurrentThread();
|
ExitCurrentThread();
|
||||||
Core::System::GetInstance().PrepareReschedule();
|
Core::System::GetInstance().PrepareReschedule();
|
||||||
|
@ -583,7 +583,7 @@ static void ExitThread() {
|
||||||
|
|
||||||
/// Sleep the current thread
|
/// Sleep the current thread
|
||||||
static void SleepThread(s64 nanoseconds) {
|
static void SleepThread(s64 nanoseconds) {
|
||||||
LOG_TRACE(Kernel_SVC, "called nanoseconds=%lld", nanoseconds);
|
NGLOG_TRACE(Kernel_SVC, "called nanoseconds={}", nanoseconds);
|
||||||
|
|
||||||
// Don't attempt to yield execution if there are no available threads to run,
|
// Don't attempt to yield execution if there are no available threads to run,
|
||||||
// this way we avoid a useless reschedule to the idle thread.
|
// this way we avoid a useless reschedule to the idle thread.
|
||||||
|
@ -602,9 +602,9 @@ static void SleepThread(s64 nanoseconds) {
|
||||||
/// Signal process wide key atomic
|
/// Signal process wide key atomic
|
||||||
static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_variable_addr,
|
static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_variable_addr,
|
||||||
Handle thread_handle, s64 nano_seconds) {
|
Handle thread_handle, s64 nano_seconds) {
|
||||||
LOG_TRACE(
|
NGLOG_TRACE(
|
||||||
Kernel_SVC,
|
Kernel_SVC,
|
||||||
"called mutex_addr=%llx, condition_variable_addr=%llx, thread_handle=0x%08X, timeout=%d",
|
"called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle={:#010X}, timeout={}",
|
||||||
mutex_addr, condition_variable_addr, thread_handle, nano_seconds);
|
mutex_addr, condition_variable_addr, thread_handle, nano_seconds);
|
||||||
|
|
||||||
SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
|
SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
|
||||||
|
@ -629,8 +629,8 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
|
||||||
|
|
||||||
/// Signal process wide key
|
/// Signal process wide key
|
||||||
static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target) {
|
static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target) {
|
||||||
LOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x%llx, target=0x%08x",
|
NGLOG_TRACE(Kernel_SVC, "called, condition_variable_addr={:#X}, target={:#010X}",
|
||||||
condition_variable_addr, target);
|
condition_variable_addr, target);
|
||||||
|
|
||||||
u32 processed = 0;
|
u32 processed = 0;
|
||||||
auto& thread_list = Core::System::GetInstance().Scheduler().GetThreadList();
|
auto& thread_list = Core::System::GetInstance().Scheduler().GetThreadList();
|
||||||
|
@ -696,13 +696,13 @@ static u64 GetSystemTick() {
|
||||||
|
|
||||||
/// Close a handle
|
/// Close a handle
|
||||||
static ResultCode CloseHandle(Handle handle) {
|
static ResultCode CloseHandle(Handle handle) {
|
||||||
LOG_TRACE(Kernel_SVC, "Closing handle 0x%08X", handle);
|
NGLOG_TRACE(Kernel_SVC, "Closing handle {:#010X}", handle);
|
||||||
return g_handle_table.Close(handle);
|
return g_handle_table.Close(handle);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Reset an event
|
/// Reset an event
|
||||||
static ResultCode ResetSignal(Handle handle) {
|
static ResultCode ResetSignal(Handle handle) {
|
||||||
LOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x%08X", handle);
|
NGLOG_WARNING(Kernel_SVC, "(STUBBED) called handle {:#010X}", handle);
|
||||||
auto event = g_handle_table.Get<Event>(handle);
|
auto event = g_handle_table.Get<Event>(handle);
|
||||||
ASSERT(event != nullptr);
|
ASSERT(event != nullptr);
|
||||||
event->Clear();
|
event->Clear();
|
||||||
|
@ -711,29 +711,29 @@ static ResultCode ResetSignal(Handle handle) {
|
||||||
|
|
||||||
/// Creates a TransferMemory object
|
/// Creates a TransferMemory object
|
||||||
static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32 permissions) {
|
static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32 permissions) {
|
||||||
LOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x%lx, size=0x%lx, perms=%08X", addr, size,
|
NGLOG_WARNING(Kernel_SVC, "(STUBBED) called addr={:#X}, size={:#X}, perms={:010X}", addr, size,
|
||||||
permissions);
|
permissions);
|
||||||
*handle = 0;
|
*handle = 0;
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
static ResultCode GetThreadCoreMask(Handle handle, u32* mask, u64* unknown) {
|
static ResultCode GetThreadCoreMask(Handle handle, u32* mask, u64* unknown) {
|
||||||
LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x%08X", handle);
|
NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle={:010X}", handle);
|
||||||
*mask = 0x0;
|
*mask = 0x0;
|
||||||
*unknown = 0xf;
|
*unknown = 0xf;
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
static ResultCode SetThreadCoreMask(Handle handle, u32 mask, u64 unknown) {
|
static ResultCode SetThreadCoreMask(Handle handle, u32 mask, u64 unknown) {
|
||||||
LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x%08X, mask=0x%08X, unknown=0x%lx", handle,
|
NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle={:#010X}, mask={:#010X}, unknown={:#X}",
|
||||||
mask, unknown);
|
handle, mask, unknown);
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permissions,
|
static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permissions,
|
||||||
u32 remote_permissions) {
|
u32 remote_permissions) {
|
||||||
LOG_TRACE(Kernel_SVC, "called, size=0x%llx, localPerms=0x%08x, remotePerms=0x%08x", size,
|
NGLOG_TRACE(Kernel_SVC, "called, size={:#X}, localPerms={:#010X}, remotePerms={:#010X}", size,
|
||||||
local_permissions, remote_permissions);
|
local_permissions, remote_permissions);
|
||||||
auto sharedMemHandle =
|
auto sharedMemHandle =
|
||||||
SharedMemory::Create(g_handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
|
SharedMemory::Create(g_handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
|
||||||
static_cast<MemoryPermission>(local_permissions),
|
static_cast<MemoryPermission>(local_permissions),
|
||||||
|
@ -744,7 +744,7 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
|
||||||
}
|
}
|
||||||
|
|
||||||
static ResultCode ClearEvent(Handle handle) {
|
static ResultCode ClearEvent(Handle handle) {
|
||||||
LOG_TRACE(Kernel_SVC, "called, event=0xX", handle);
|
NGLOG_TRACE(Kernel_SVC, "called, event={:010X}", handle);
|
||||||
|
|
||||||
SharedPtr<Event> evt = g_handle_table.Get<Event>(handle);
|
SharedPtr<Event> evt = g_handle_table.Get<Event>(handle);
|
||||||
if (evt == nullptr)
|
if (evt == nullptr)
|
||||||
|
@ -896,7 +896,7 @@ static const FunctionDef SVC_Table[] = {
|
||||||
|
|
||||||
static const FunctionDef* GetSVCInfo(u32 func_num) {
|
static const FunctionDef* GetSVCInfo(u32 func_num) {
|
||||||
if (func_num >= std::size(SVC_Table)) {
|
if (func_num >= std::size(SVC_Table)) {
|
||||||
LOG_ERROR(Kernel_SVC, "unknown svc=0x%02X", func_num);
|
NGLOG_ERROR(Kernel_SVC, "Unknown svc={:#04X}", func_num);
|
||||||
return nullptr;
|
return nullptr;
|
||||||
}
|
}
|
||||||
return &SVC_Table[func_num];
|
return &SVC_Table[func_num];
|
||||||
|
@ -915,10 +915,10 @@ void CallSVC(u32 immediate) {
|
||||||
if (info->func) {
|
if (info->func) {
|
||||||
info->func();
|
info->func();
|
||||||
} else {
|
} else {
|
||||||
LOG_CRITICAL(Kernel_SVC, "unimplemented SVC function %s(..)", info->name);
|
NGLOG_CRITICAL(Kernel_SVC, "Unimplemented SVC function {}(..)", info->name);
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
LOG_CRITICAL(Kernel_SVC, "unknown SVC function 0x%x", immediate);
|
NGLOG_CRITICAL(Kernel_SVC, "Unknown SVC function {:#X}", immediate);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -101,9 +101,10 @@ void ExitCurrentThread() {
|
||||||
* @param cycles_late The number of CPU cycles that have passed since the desired wakeup time
|
* @param cycles_late The number of CPU cycles that have passed since the desired wakeup time
|
||||||
*/
|
*/
|
||||||
static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
|
static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
|
||||||
SharedPtr<Thread> thread = wakeup_callback_handle_table.Get<Thread>((Handle)thread_handle);
|
const auto proper_handle = static_cast<Handle>(thread_handle);
|
||||||
|
SharedPtr<Thread> thread = wakeup_callback_handle_table.Get<Thread>(proper_handle);
|
||||||
if (thread == nullptr) {
|
if (thread == nullptr) {
|
||||||
LOG_CRITICAL(Kernel, "Callback fired for invalid thread %08X", (Handle)thread_handle);
|
NGLOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -238,19 +239,19 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
|
||||||
SharedPtr<Process> owner_process) {
|
SharedPtr<Process> owner_process) {
|
||||||
// Check if priority is in ranged. Lowest priority -> highest priority id.
|
// Check if priority is in ranged. Lowest priority -> highest priority id.
|
||||||
if (priority > THREADPRIO_LOWEST) {
|
if (priority > THREADPRIO_LOWEST) {
|
||||||
LOG_ERROR(Kernel_SVC, "Invalid thread priority: %u", priority);
|
NGLOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
|
||||||
return ERR_OUT_OF_RANGE;
|
return ERR_OUT_OF_RANGE;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (processor_id > THREADPROCESSORID_MAX) {
|
if (processor_id > THREADPROCESSORID_MAX) {
|
||||||
LOG_ERROR(Kernel_SVC, "Invalid processor id: %d", processor_id);
|
NGLOG_ERROR(Kernel_SVC, "Invalid processor id: {}", processor_id);
|
||||||
return ERR_OUT_OF_RANGE_KERNEL;
|
return ERR_OUT_OF_RANGE_KERNEL;
|
||||||
}
|
}
|
||||||
|
|
||||||
// TODO(yuriks): Other checks, returning 0xD9001BEA
|
// TODO(yuriks): Other checks, returning 0xD9001BEA
|
||||||
|
|
||||||
if (!Memory::IsValidVirtualAddress(*owner_process, entry_point)) {
|
if (!Memory::IsValidVirtualAddress(*owner_process, entry_point)) {
|
||||||
LOG_ERROR(Kernel_SVC, "(name=%s): invalid entry %016" PRIx64, name.c_str(), entry_point);
|
NGLOG_ERROR(Kernel_SVC, "(name={}): invalid entry {:016X}", name, entry_point);
|
||||||
// TODO (bunnei): Find the correct error code to use here
|
// TODO (bunnei): Find the correct error code to use here
|
||||||
return ResultCode(-1);
|
return ResultCode(-1);
|
||||||
}
|
}
|
||||||
|
@ -289,8 +290,8 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
|
||||||
auto& linheap_memory = memory_region->linear_heap_memory;
|
auto& linheap_memory = memory_region->linear_heap_memory;
|
||||||
|
|
||||||
if (linheap_memory->size() + Memory::PAGE_SIZE > memory_region->size) {
|
if (linheap_memory->size() + Memory::PAGE_SIZE > memory_region->size) {
|
||||||
LOG_ERROR(Kernel_SVC,
|
NGLOG_ERROR(Kernel_SVC,
|
||||||
"Not enough space in region to allocate a new TLS page for thread");
|
"Not enough space in region to allocate a new TLS page for thread");
|
||||||
return ERR_OUT_OF_MEMORY;
|
return ERR_OUT_OF_MEMORY;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -77,7 +77,7 @@ void Timer::WakeupAllWaitingThreads() {
|
||||||
}
|
}
|
||||||
|
|
||||||
void Timer::Signal(int cycles_late) {
|
void Timer::Signal(int cycles_late) {
|
||||||
LOG_TRACE(Kernel, "Timer %u fired", GetObjectId());
|
NGLOG_TRACE(Kernel, "Timer {} fired", GetObjectId());
|
||||||
|
|
||||||
signaled = true;
|
signaled = true;
|
||||||
|
|
||||||
|
@ -97,7 +97,7 @@ static void TimerCallback(u64 timer_handle, int cycles_late) {
|
||||||
timer_callback_handle_table.Get<Timer>(static_cast<Handle>(timer_handle));
|
timer_callback_handle_table.Get<Timer>(static_cast<Handle>(timer_handle));
|
||||||
|
|
||||||
if (timer == nullptr) {
|
if (timer == nullptr) {
|
||||||
LOG_CRITICAL(Kernel, "Callback fired for invalid timer %08" PRIx64, timer_handle);
|
NGLOG_CRITICAL(Kernel, "Callback fired for invalid timer {:016X}", timer_handle);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -379,22 +379,22 @@ void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) {
|
||||||
}
|
}
|
||||||
|
|
||||||
u64 VMManager::GetTotalMemoryUsage() {
|
u64 VMManager::GetTotalMemoryUsage() {
|
||||||
LOG_WARNING(Kernel, "(STUBBED) called");
|
NGLOG_WARNING(Kernel, "(STUBBED) called");
|
||||||
return 0xF8000000;
|
return 0xF8000000;
|
||||||
}
|
}
|
||||||
|
|
||||||
u64 VMManager::GetTotalHeapUsage() {
|
u64 VMManager::GetTotalHeapUsage() {
|
||||||
LOG_WARNING(Kernel, "(STUBBED) called");
|
NGLOG_WARNING(Kernel, "(STUBBED) called");
|
||||||
return 0x0;
|
return 0x0;
|
||||||
}
|
}
|
||||||
|
|
||||||
VAddr VMManager::GetAddressSpaceBaseAddr() {
|
VAddr VMManager::GetAddressSpaceBaseAddr() {
|
||||||
LOG_WARNING(Kernel, "(STUBBED) called");
|
NGLOG_WARNING(Kernel, "(STUBBED) called");
|
||||||
return 0x8000000;
|
return 0x8000000;
|
||||||
}
|
}
|
||||||
|
|
||||||
u64 VMManager::GetAddressSpaceSize() {
|
u64 VMManager::GetAddressSpaceSize() {
|
||||||
LOG_WARNING(Kernel, "(STUBBED) called");
|
NGLOG_WARNING(Kernel, "(STUBBED) called");
|
||||||
return MAX_ADDRESS;
|
return MAX_ADDRESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
Loading…
Reference in a new issue