1
0
Fork 0
forked from suyu/suyu
suyu/src/core/hle/kernel/kernel.cpp

203 lines
6.1 KiB
C++
Raw Normal View History

2014-12-17 06:38:14 +01:00
// Copyright 2014 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
2014-05-10 04:11:18 +02:00
2014-12-04 01:55:45 +01:00
#include <algorithm>
2015-05-06 09:06:12 +02:00
#include "common/assert.h"
#include "common/logging/log.h"
#include "core/hle/config_mem.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/memory.h"
#include "core/hle/kernel/process.h"
#include "core/hle/kernel/resource_limit.h"
2014-05-10 04:11:18 +02:00
#include "core/hle/kernel/thread.h"
#include "core/hle/kernel/timer.h"
#include "core/hle/shared_page.h"
2014-05-10 04:11:18 +02:00
namespace Kernel {
2014-05-10 04:11:18 +02:00
unsigned int Object::next_object_id;
2014-12-14 00:16:13 +01:00
HandleTable g_handle_table;
2014-05-10 04:11:18 +02:00
void WaitObject::AddWaitingThread(SharedPtr<Thread> thread) {
auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
if (itr == waiting_threads.end())
waiting_threads.push_back(std::move(thread));
}
void WaitObject::RemoveWaitingThread(Thread* thread) {
auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
if (itr != waiting_threads.end())
waiting_threads.erase(itr);
}
SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
// Remove the threads that are ready or already running from our waitlist
waiting_threads.erase(std::remove_if(waiting_threads.begin(), waiting_threads.end(), [](const SharedPtr<Thread>& thread) -> bool {
return thread->status == THREADSTATUS_RUNNING || thread->status == THREADSTATUS_READY;
}), waiting_threads.end());
if (waiting_threads.empty())
return nullptr;
SharedPtr<Thread> candidate = nullptr;
s32 candidate_priority = THREADPRIO_LOWEST + 1;
for (const auto& thread : waiting_threads) {
if (thread->current_priority >= candidate_priority)
continue;
bool ready_to_run = std::none_of(thread->wait_objects.begin(), thread->wait_objects.end(), [](const SharedPtr<WaitObject>& object) {
return object->ShouldWait();
});
if (ready_to_run) {
candidate = thread;
candidate_priority = thread->current_priority;
}
}
return candidate;
}
void WaitObject::WakeupAllWaitingThreads() {
// Wake up all threads that can be awoken, in priority order
while (auto thread = GetHighestPriorityReadyThread()) {
if (thread->wait_objects.empty()) {
Acquire();
// Set the output index of the WaitSynchronizationN call to the index of this object.
if (thread->wait_set_output) {
thread->SetWaitSynchronizationOutput(thread->GetWaitObjectIndex(this));
thread->wait_set_output = false;
}
} else {
for (auto object : thread->wait_objects) {
object->Acquire();
// Remove the thread from the object's waitlist
object->RemoveWaitingThread(thread.get());
}
// Note: This case doesn't update the output index of WaitSynchronizationN.
// Clear the thread's waitlist
thread->wait_objects.clear();
}
// Set the result of the call to WaitSynchronization to RESULT_SUCCESS
thread->SetWaitSynchronizationResult(RESULT_SUCCESS);
thread->ResumeFromWait();
// Note: Removing the thread from the object's waitlist will be done by GetHighestPriorityReadyThread
}
}
2016-04-08 18:28:54 +02:00
const std::vector<SharedPtr<Thread>>& WaitObject::GetWaitingThreads() const {
return waiting_threads;
}
2014-12-14 00:16:13 +01:00
HandleTable::HandleTable() {
next_generation = 1;
Clear();
2014-05-10 04:11:18 +02:00
}
ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
DEBUG_ASSERT(obj != nullptr);
u16 slot = next_free_slot;
if (slot >= generations.size()) {
LOG_ERROR(Kernel, "Unable to allocate Handle, too many slots in use.");
return ERR_OUT_OF_HANDLES;
2014-05-10 04:11:18 +02:00
}
next_free_slot = generations[slot];
2014-05-10 04:11:18 +02:00
u16 generation = next_generation++;
2014-05-10 04:11:18 +02:00
// Overflow count so it fits in the 15 bits dedicated to the generation in the handle.
// CTR-OS doesn't use generation 0, so skip straight to 1.
if (next_generation >= (1 << 15))
next_generation = 1;
generations[slot] = generation;
objects[slot] = std::move(obj);
Handle handle = generation | (slot << 15);
return MakeResult<Handle>(handle);
2014-05-10 04:11:18 +02:00
}
ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
SharedPtr<Object> object = GetGeneric(handle);
if (object == nullptr) {
LOG_ERROR(Kernel, "Tried to duplicate invalid handle: %08X", handle);
return ERR_INVALID_HANDLE;
2014-05-10 04:11:18 +02:00
}
return Create(std::move(object));
2014-05-10 04:11:18 +02:00
}
ResultCode HandleTable::Close(Handle handle) {
if (!IsValid(handle))
return ERR_INVALID_HANDLE;
2015-02-01 21:31:21 +01:00
u16 slot = GetSlot(handle);
objects[slot] = nullptr;
2015-01-31 19:12:20 +01:00
generations[slot] = next_free_slot;
next_free_slot = slot;
return RESULT_SUCCESS;
2014-05-10 04:11:18 +02:00
}
bool HandleTable::IsValid(Handle handle) const {
size_t slot = GetSlot(handle);
u16 generation = GetGeneration(handle);
return slot < MAX_COUNT && objects[slot] != nullptr && generations[slot] == generation;
2014-05-10 04:11:18 +02:00
}
SharedPtr<Object> HandleTable::GetGeneric(Handle handle) const {
if (handle == CurrentThread) {
return GetCurrentThread();
} else if (handle == CurrentProcess) {
return g_current_process;
}
if (!IsValid(handle)) {
return nullptr;
}
return objects[GetSlot(handle)];
2014-05-10 04:11:18 +02:00
}
void HandleTable::Clear() {
2015-02-01 21:31:21 +01:00
for (u16 i = 0; i < MAX_COUNT; ++i) {
generations[i] = i + 1;
objects[i] = nullptr;
}
next_free_slot = 0;
2014-05-10 04:11:18 +02:00
}
/// Initialize the kernel
void Init(u32 system_mode) {
ConfigMem::Init();
SharedPage::Init();
Kernel::MemoryInit(system_mode);
Kernel::ResourceLimitsInit();
Kernel::ThreadingInit();
Kernel::TimersInit();
Object::next_object_id = 0;
2015-05-12 01:23:45 +02:00
// TODO(Subv): Start the process ids from 10 for now, as lower PIDs are
// reserved for low-level services
Process::next_process_id = 10;
}
/// Shutdown the kernel
void Shutdown() {
g_handle_table.Clear(); // Free all kernel objects
Kernel::ThreadingShutdown();
g_current_process = nullptr;
Kernel::TimersShutdown();
Kernel::ResourceLimitsShutdown();
Kernel::MemoryShutdown();
}
} // namespace