2014-12-16 21:38:14 -08:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
2014-11-19 00:49:13 -08:00
|
|
|
// Refer to the license.txt file included.
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2016-09-20 08:21:23 -07:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2014-12-03 16:55:45 -08:00
|
|
|
#include <algorithm>
|
2015-05-06 00:06:12 -07:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/logging/log.h"
|
2015-08-05 17:26:52 -07:00
|
|
|
#include "core/hle/config_mem.h"
|
|
|
|
#include "core/hle/kernel/memory.h"
|
2015-05-03 20:01:16 -07:00
|
|
|
#include "core/hle/kernel/process.h"
|
2015-08-05 17:26:52 -07:00
|
|
|
#include "core/hle/kernel/resource_limit.h"
|
2014-05-09 19:11:18 -07:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2014-12-04 11:45:47 -08:00
|
|
|
#include "core/hle/kernel/timer.h"
|
2015-08-05 17:26:52 -07:00
|
|
|
#include "core/hle/shared_page.h"
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
namespace Kernel {
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2015-04-27 19:12:35 -07:00
|
|
|
unsigned int Object::next_object_id;
|
2014-12-13 15:16:13 -08:00
|
|
|
HandleTable g_handle_table;
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2015-01-31 17:26:16 -08:00
|
|
|
void WaitObject::AddWaitingThread(SharedPtr<Thread> thread) {
|
2015-01-14 20:19:22 -08:00
|
|
|
auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
|
|
|
|
if (itr == waiting_threads.end())
|
2015-01-31 17:26:16 -08:00
|
|
|
waiting_threads.push_back(std::move(thread));
|
2015-01-14 20:19:22 -08: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-14 16:22:50 -08:00
|
|
|
}
|
|
|
|
|
2015-01-18 10:25:51 -08:00
|
|
|
void WaitObject::WakeupAllWaitingThreads() {
|
2015-06-07 20:39:37 -07:00
|
|
|
for (auto thread : waiting_threads)
|
|
|
|
thread->ResumeFromWait();
|
2015-01-14 16:22:50 -08:00
|
|
|
|
2015-06-07 20:39:37 -07:00
|
|
|
waiting_threads.clear();
|
2015-01-14 16:22:50 -08:00
|
|
|
|
2015-06-07 20:39:37 -07:00
|
|
|
HLE::Reschedule(__func__);
|
2015-01-14 16:22:50 -08:00
|
|
|
}
|
|
|
|
|
2014-12-13 15:16:13 -08:00
|
|
|
HandleTable::HandleTable() {
|
2014-12-21 04:04:08 -08:00
|
|
|
next_generation = 1;
|
|
|
|
Clear();
|
2014-05-09 19:11:18 -07:00
|
|
|
}
|
|
|
|
|
2014-12-29 04:55:30 -08:00
|
|
|
ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
|
2015-01-20 17:16:47 -08:00
|
|
|
DEBUG_ASSERT(obj != nullptr);
|
2014-12-21 04:04:08 -08:00
|
|
|
|
|
|
|
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-09 19:11:18 -07:00
|
|
|
}
|
2014-12-21 04:04:08 -08:00
|
|
|
next_free_slot = generations[slot];
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2014-12-21 04:04:08 -08:00
|
|
|
u16 generation = next_generation++;
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2014-12-21 04:04:08 -08: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.
|
2016-09-17 17:38:01 -07:00
|
|
|
if (next_generation >= (1 << 15))
|
|
|
|
next_generation = 1;
|
2014-12-21 04:04:08 -08:00
|
|
|
|
2014-12-29 04:55:30 -08:00
|
|
|
generations[slot] = generation;
|
|
|
|
objects[slot] = std::move(obj);
|
|
|
|
|
2015-01-31 08:57:32 -08:00
|
|
|
Handle handle = generation | (slot << 15);
|
2014-12-21 04:04:08 -08:00
|
|
|
return MakeResult<Handle>(handle);
|
2014-05-09 19:11:18 -07:00
|
|
|
}
|
|
|
|
|
2014-12-21 04:04:08 -08:00
|
|
|
ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
|
2014-12-29 04:55:30 -08:00
|
|
|
SharedPtr<Object> object = GetGeneric(handle);
|
2014-12-21 04:04:08 -08:00
|
|
|
if (object == nullptr) {
|
|
|
|
LOG_ERROR(Kernel, "Tried to duplicate invalid handle: %08X", handle);
|
|
|
|
return ERR_INVALID_HANDLE;
|
2014-05-09 19:11:18 -07:00
|
|
|
}
|
2014-12-29 04:55:30 -08:00
|
|
|
return Create(std::move(object));
|
2014-05-09 19:11:18 -07:00
|
|
|
}
|
|
|
|
|
2014-12-21 04:04:08 -08:00
|
|
|
ResultCode HandleTable::Close(Handle handle) {
|
|
|
|
if (!IsValid(handle))
|
|
|
|
return ERR_INVALID_HANDLE;
|
|
|
|
|
2015-02-01 12:31:21 -08:00
|
|
|
u16 slot = GetSlot(handle);
|
2014-12-21 04:04:08 -08:00
|
|
|
|
|
|
|
objects[slot] = nullptr;
|
|
|
|
|
2015-01-31 10:12:20 -08:00
|
|
|
generations[slot] = next_free_slot;
|
2014-12-21 04:04:08 -08:00
|
|
|
next_free_slot = slot;
|
|
|
|
return RESULT_SUCCESS;
|
2014-05-09 19:11:18 -07:00
|
|
|
}
|
|
|
|
|
2014-12-21 04:04:08 -08: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-09 19:11:18 -07:00
|
|
|
}
|
|
|
|
|
2014-12-29 04:55:30 -08:00
|
|
|
SharedPtr<Object> HandleTable::GetGeneric(Handle handle) const {
|
2014-12-21 04:04:08 -08:00
|
|
|
if (handle == CurrentThread) {
|
2014-12-21 22:32:03 -08:00
|
|
|
return GetCurrentThread();
|
2014-12-21 04:04:08 -08:00
|
|
|
} else if (handle == CurrentProcess) {
|
2015-05-11 07:15:10 -07:00
|
|
|
return g_current_process;
|
2014-12-21 04:04:08 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!IsValid(handle)) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return objects[GetSlot(handle)];
|
2014-05-09 19:11:18 -07:00
|
|
|
}
|
|
|
|
|
2014-12-21 04:04:08 -08:00
|
|
|
void HandleTable::Clear() {
|
2015-02-01 12:31:21 -08:00
|
|
|
for (u16 i = 0; i < MAX_COUNT; ++i) {
|
2014-12-21 04:04:08 -08:00
|
|
|
generations[i] = i + 1;
|
|
|
|
objects[i] = nullptr;
|
|
|
|
}
|
|
|
|
next_free_slot = 0;
|
2014-05-09 19:11:18 -07:00
|
|
|
}
|
2014-05-13 18:57:12 -07:00
|
|
|
|
2014-06-10 19:43:50 -07:00
|
|
|
/// Initialize the kernel
|
2014-05-20 15:13:25 -07:00
|
|
|
void Init() {
|
2015-08-05 17:26:52 -07:00
|
|
|
ConfigMem::Init();
|
|
|
|
SharedPage::Init();
|
|
|
|
|
|
|
|
// TODO(yuriks): The memory type parameter needs to be determined by the ExHeader field instead
|
|
|
|
// For now it defaults to the one with a largest allocation to the app
|
|
|
|
Kernel::MemoryInit(2); // Allocates 96MB to the application
|
|
|
|
|
2015-05-12 13:25:15 -07:00
|
|
|
Kernel::ResourceLimitsInit();
|
2014-05-20 16:37:46 -07:00
|
|
|
Kernel::ThreadingInit();
|
2014-12-04 11:45:47 -08:00
|
|
|
Kernel::TimersInit();
|
2015-04-27 19:12:35 -07:00
|
|
|
|
|
|
|
Object::next_object_id = 0;
|
2015-05-11 16:23:45 -07: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;
|
2014-05-20 15:13:25 -07:00
|
|
|
}
|
|
|
|
|
2014-06-10 19:43:50 -07:00
|
|
|
/// Shutdown the kernel
|
2014-05-20 15:13:25 -07:00
|
|
|
void Shutdown() {
|
2015-08-05 17:26:52 -07:00
|
|
|
g_handle_table.Clear(); // Free all kernel objects
|
|
|
|
|
2014-05-20 16:37:46 -07:00
|
|
|
Kernel::ThreadingShutdown();
|
2015-08-05 17:26:52 -07:00
|
|
|
g_current_process = nullptr;
|
|
|
|
|
2014-12-04 11:45:47 -08:00
|
|
|
Kernel::TimersShutdown();
|
2015-05-12 13:25:15 -07:00
|
|
|
Kernel::ResourceLimitsShutdown();
|
2015-08-05 17:26:52 -07:00
|
|
|
Kernel::MemoryShutdown();
|
2014-05-13 18:57:12 -07:00
|
|
|
}
|
2014-05-22 16:06:12 -07:00
|
|
|
|
|
|
|
} // namespace
|