2014-12-17 08:38:14 +03:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
2014-11-19 11:49:13 +03:00
|
|
|
// Refer to the license.txt file included.
|
2014-05-10 06:11:18 +04:00
|
|
|
|
2014-12-04 03:55:45 +03:00
|
|
|
#include <algorithm>
|
|
|
|
|
2014-05-10 06:11:18 +04:00
|
|
|
#include "common/common.h"
|
|
|
|
|
2014-12-22 09:30:09 +03:00
|
|
|
#include "core/arm/arm_interface.h"
|
2014-05-14 05:57:12 +04:00
|
|
|
#include "core/core.h"
|
2014-05-10 06:11:18 +04:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
|
|
|
#include "core/hle/kernel/thread.h"
|
2014-12-04 22:45:47 +03:00
|
|
|
#include "core/hle/kernel/timer.h"
|
2014-05-10 06:11:18 +04:00
|
|
|
|
2014-05-21 02:13:25 +04:00
|
|
|
namespace Kernel {
|
2014-05-10 06:11:18 +04:00
|
|
|
|
2014-12-29 15:55:30 +03:00
|
|
|
SharedPtr<Thread> g_main_thread = nullptr;
|
2014-12-14 02:16:13 +03:00
|
|
|
HandleTable g_handle_table;
|
2014-12-16 08:33:41 +03:00
|
|
|
u64 g_program_id = 0;
|
2014-05-10 06:11:18 +04:00
|
|
|
|
2015-01-15 03:22:50 +03:00
|
|
|
void WaitObject::AddWaitingThread(Thread* thread) {
|
2015-01-15 07:19:22 +03:00
|
|
|
auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
|
|
|
|
if (itr == waiting_threads.end())
|
2015-01-15 03:22:50 +03:00
|
|
|
waiting_threads.push_back(thread);
|
2015-01-15 07:19:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2015-01-15 03:22:50 +03:00
|
|
|
}
|
|
|
|
|
2015-01-17 10:03:44 +03:00
|
|
|
Thread* WaitObject::ReleaseNextThread() {
|
2015-01-15 07:19:22 +03:00
|
|
|
if (waiting_threads.empty())
|
|
|
|
return nullptr;
|
2015-01-15 03:22:50 +03:00
|
|
|
|
|
|
|
auto next_thread = waiting_threads.front();
|
2015-01-19 02:01:58 +03:00
|
|
|
waiting_threads.erase(waiting_threads.begin());
|
2015-01-15 03:22:50 +03:00
|
|
|
|
2015-01-18 21:56:40 +03:00
|
|
|
next_thread->ReleaseWaitObject(this);
|
2015-01-15 03:22:50 +03:00
|
|
|
|
|
|
|
return next_thread.get();
|
|
|
|
}
|
|
|
|
|
2015-01-18 21:25:51 +03:00
|
|
|
void WaitObject::WakeupAllWaitingThreads() {
|
2015-01-15 03:22:50 +03:00
|
|
|
auto waiting_threads_copy = waiting_threads;
|
|
|
|
|
2015-01-18 21:25:51 +03:00
|
|
|
// We use a copy because ReleaseWaitObject will remove the thread from this object's
|
|
|
|
// waiting_threads list
|
2015-01-15 03:22:50 +03:00
|
|
|
for (auto thread : waiting_threads_copy)
|
|
|
|
thread->ReleaseWaitObject(this);
|
|
|
|
|
2015-01-18 21:25:51 +03:00
|
|
|
_assert_msg_(Kernel, waiting_threads.empty(), "failed to awaken all waiting threads!");
|
2015-01-15 03:22:50 +03:00
|
|
|
}
|
|
|
|
|
2014-12-14 02:16:13 +03:00
|
|
|
HandleTable::HandleTable() {
|
2014-12-21 15:04:08 +03:00
|
|
|
next_generation = 1;
|
|
|
|
Clear();
|
2014-05-10 06:11:18 +04:00
|
|
|
}
|
|
|
|
|
2014-12-29 15:55:30 +03:00
|
|
|
ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
|
2014-12-21 15:04:08 +03:00
|
|
|
_dbg_assert_(Kernel, 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 06:11:18 +04:00
|
|
|
}
|
2014-12-21 15:04:08 +03:00
|
|
|
next_free_slot = generations[slot];
|
2014-05-10 06:11:18 +04:00
|
|
|
|
2014-12-21 15:04:08 +03:00
|
|
|
u16 generation = next_generation++;
|
2014-05-10 06:11:18 +04:00
|
|
|
|
2014-12-21 15:04:08 +03: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;
|
|
|
|
|
|
|
|
Handle handle = generation | (slot << 15);
|
2014-12-31 14:20:48 +03:00
|
|
|
if (obj->handle == INVALID_HANDLE)
|
|
|
|
obj->handle = handle;
|
2014-12-29 15:55:30 +03:00
|
|
|
|
|
|
|
generations[slot] = generation;
|
|
|
|
objects[slot] = std::move(obj);
|
|
|
|
|
2014-12-21 15:04:08 +03:00
|
|
|
return MakeResult<Handle>(handle);
|
2014-05-10 06:11:18 +04:00
|
|
|
}
|
|
|
|
|
2014-12-21 15:04:08 +03:00
|
|
|
ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
|
2014-12-29 15:55:30 +03:00
|
|
|
SharedPtr<Object> object = GetGeneric(handle);
|
2014-12-21 15:04:08 +03:00
|
|
|
if (object == nullptr) {
|
|
|
|
LOG_ERROR(Kernel, "Tried to duplicate invalid handle: %08X", handle);
|
|
|
|
return ERR_INVALID_HANDLE;
|
2014-05-10 06:11:18 +04:00
|
|
|
}
|
2014-12-29 15:55:30 +03:00
|
|
|
return Create(std::move(object));
|
2014-05-10 06:11:18 +04:00
|
|
|
}
|
|
|
|
|
2014-12-21 15:04:08 +03:00
|
|
|
ResultCode HandleTable::Close(Handle handle) {
|
|
|
|
if (!IsValid(handle))
|
|
|
|
return ERR_INVALID_HANDLE;
|
|
|
|
|
|
|
|
size_t slot = GetSlot(handle);
|
|
|
|
u16 generation = GetGeneration(handle);
|
|
|
|
|
|
|
|
objects[slot] = nullptr;
|
|
|
|
|
|
|
|
generations[generation] = next_free_slot;
|
|
|
|
next_free_slot = slot;
|
|
|
|
return RESULT_SUCCESS;
|
2014-05-10 06:11:18 +04:00
|
|
|
}
|
|
|
|
|
2014-12-21 15:04:08 +03: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 06:11:18 +04:00
|
|
|
}
|
|
|
|
|
2014-12-29 15:55:30 +03:00
|
|
|
SharedPtr<Object> HandleTable::GetGeneric(Handle handle) const {
|
2014-12-21 15:04:08 +03:00
|
|
|
if (handle == CurrentThread) {
|
2014-12-22 09:32:03 +03:00
|
|
|
return GetCurrentThread();
|
2014-12-21 15:04:08 +03:00
|
|
|
} else if (handle == CurrentProcess) {
|
|
|
|
LOG_ERROR(Kernel, "Current process (%08X) pseudo-handle not supported", CurrentProcess);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!IsValid(handle)) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return objects[GetSlot(handle)];
|
2014-05-10 06:11:18 +04:00
|
|
|
}
|
|
|
|
|
2014-12-21 15:04:08 +03:00
|
|
|
void HandleTable::Clear() {
|
|
|
|
for (size_t i = 0; i < MAX_COUNT; ++i) {
|
|
|
|
generations[i] = i + 1;
|
|
|
|
objects[i] = nullptr;
|
|
|
|
}
|
|
|
|
next_free_slot = 0;
|
2014-05-10 06:11:18 +04:00
|
|
|
}
|
2014-05-14 05:57:12 +04:00
|
|
|
|
2014-06-11 06:43:50 +04:00
|
|
|
/// Initialize the kernel
|
2014-05-21 02:13:25 +04:00
|
|
|
void Init() {
|
2014-05-21 03:37:46 +04:00
|
|
|
Kernel::ThreadingInit();
|
2014-12-04 22:45:47 +03:00
|
|
|
Kernel::TimersInit();
|
2014-05-21 02:13:25 +04:00
|
|
|
}
|
|
|
|
|
2014-06-11 06:43:50 +04:00
|
|
|
/// Shutdown the kernel
|
2014-05-21 02:13:25 +04:00
|
|
|
void Shutdown() {
|
2014-05-21 03:37:46 +04:00
|
|
|
Kernel::ThreadingShutdown();
|
2014-12-04 22:45:47 +03:00
|
|
|
Kernel::TimersShutdown();
|
2014-12-14 02:16:13 +03:00
|
|
|
g_handle_table.Clear(); // Free all kernel objects
|
2014-05-21 02:13:25 +04:00
|
|
|
}
|
|
|
|
|
2014-05-23 03:06:12 +04:00
|
|
|
/**
|
|
|
|
* Loads executable stored at specified address
|
|
|
|
* @entry_point Entry point in memory of loaded executable
|
|
|
|
* @return True on success, otherwise false
|
|
|
|
*/
|
|
|
|
bool LoadExec(u32 entry_point) {
|
2014-05-14 05:57:12 +04:00
|
|
|
Core::g_app_core->SetPC(entry_point);
|
|
|
|
|
2014-05-15 04:49:27 +04:00
|
|
|
// 0x30 is the typical main thread priority I've seen used so far
|
2014-12-29 15:55:30 +03:00
|
|
|
g_main_thread = Kernel::SetupMainThread(0x30, Kernel::DEFAULT_STACK_SIZE);
|
2015-01-07 18:10:58 +03:00
|
|
|
// Setup the idle thread
|
|
|
|
Kernel::SetupIdleThread();
|
2014-05-14 05:57:12 +04:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2014-05-23 03:06:12 +04:00
|
|
|
|
|
|
|
} // namespace
|