2014-05-09 19:11:18 -07:00
|
|
|
// Copyright 2014 Citra Emulator Project / PPSSPP Project
|
|
|
|
// Licensed under GPLv2
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#include "common/common.h"
|
|
|
|
|
2014-05-13 18:57:12 -07:00
|
|
|
#include "core/core.h"
|
2014-05-09 19:11:18 -07:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
|
|
|
#include "core/hle/kernel/thread.h"
|
2014-07-04 10:38:12 -07:00
|
|
|
#include "core/hle/kernel/archive.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
|
|
|
|
2014-06-01 18:42:50 -07:00
|
|
|
Handle g_main_thread = 0;
|
2014-05-20 15:13:25 -07:00
|
|
|
ObjectPool g_object_pool;
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
ObjectPool::ObjectPool() {
|
2014-05-09 19:11:18 -07:00
|
|
|
next_id = INITIAL_NEXT_ID;
|
|
|
|
}
|
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
Handle ObjectPool::Create(Object* obj, int range_bottom, int range_top) {
|
2014-05-09 19:11:18 -07:00
|
|
|
if (range_top > MAX_COUNT) {
|
|
|
|
range_top = MAX_COUNT;
|
|
|
|
}
|
|
|
|
if (next_id >= range_bottom && next_id < range_top) {
|
|
|
|
range_bottom = next_id++;
|
|
|
|
}
|
|
|
|
for (int i = range_bottom; i < range_top; i++) {
|
|
|
|
if (!occupied[i]) {
|
|
|
|
occupied[i] = true;
|
|
|
|
pool[i] = obj;
|
2014-05-15 15:26:28 -07:00
|
|
|
pool[i]->handle = i + HANDLE_OFFSET;
|
2014-05-09 19:11:18 -07:00
|
|
|
return i + HANDLE_OFFSET;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ERROR_LOG(HLE, "Unable to allocate kernel object, too many objects slots in use.");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
bool ObjectPool::IsValid(Handle handle) {
|
2014-05-09 19:11:18 -07:00
|
|
|
int index = handle - HANDLE_OFFSET;
|
|
|
|
if (index < 0)
|
|
|
|
return false;
|
|
|
|
if (index >= MAX_COUNT)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return occupied[index];
|
|
|
|
}
|
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
void ObjectPool::Clear() {
|
|
|
|
for (int i = 0; i < MAX_COUNT; i++) {
|
2014-05-09 19:11:18 -07:00
|
|
|
//brutally clear everything, no validation
|
|
|
|
if (occupied[i])
|
|
|
|
delete pool[i];
|
|
|
|
occupied[i] = false;
|
|
|
|
}
|
2014-08-18 21:20:56 -07:00
|
|
|
pool.fill(nullptr);
|
2014-05-09 19:11:18 -07:00
|
|
|
next_id = INITIAL_NEXT_ID;
|
|
|
|
}
|
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
Object* &ObjectPool::operator [](Handle handle)
|
2014-05-09 19:11:18 -07:00
|
|
|
{
|
|
|
|
_dbg_assert_msg_(KERNEL, IsValid(handle), "GRABBING UNALLOCED KERNEL OBJ");
|
|
|
|
return pool[handle - HANDLE_OFFSET];
|
|
|
|
}
|
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
void ObjectPool::List() {
|
2014-05-09 19:11:18 -07:00
|
|
|
for (int i = 0; i < MAX_COUNT; i++) {
|
|
|
|
if (occupied[i]) {
|
|
|
|
if (pool[i]) {
|
2014-08-17 20:03:22 -07:00
|
|
|
INFO_LOG(KERNEL, "KO %i: %s \"%s\"", i + HANDLE_OFFSET, pool[i]->GetTypeName().c_str(),
|
|
|
|
pool[i]->GetName().c_str());
|
2014-05-09 19:11:18 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
int ObjectPool::GetCount() {
|
2014-05-09 19:11:18 -07:00
|
|
|
int count = 0;
|
2014-05-20 15:13:25 -07:00
|
|
|
for (int i = 0; i < MAX_COUNT; i++) {
|
2014-05-09 19:11:18 -07:00
|
|
|
if (occupied[i])
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
Object* ObjectPool::CreateByIDType(int type) {
|
2014-05-09 19:11:18 -07:00
|
|
|
// Used for save states. This is ugly, but what other way is there?
|
|
|
|
switch (type) {
|
|
|
|
//case SCE_KERNEL_TMID_Alarm:
|
|
|
|
// return __KernelAlarmObject();
|
|
|
|
//case SCE_KERNEL_TMID_EventFlag:
|
|
|
|
// return __KernelEventFlagObject();
|
|
|
|
//case SCE_KERNEL_TMID_Mbox:
|
|
|
|
// return __KernelMbxObject();
|
|
|
|
//case SCE_KERNEL_TMID_Fpl:
|
|
|
|
// return __KernelMemoryFPLObject();
|
|
|
|
//case SCE_KERNEL_TMID_Vpl:
|
|
|
|
// return __KernelMemoryVPLObject();
|
|
|
|
//case PPSSPP_KERNEL_TMID_PMB:
|
|
|
|
// return __KernelMemoryPMBObject();
|
|
|
|
//case PPSSPP_KERNEL_TMID_Module:
|
|
|
|
// return __KernelModuleObject();
|
|
|
|
//case SCE_KERNEL_TMID_Mpipe:
|
|
|
|
// return __KernelMsgPipeObject();
|
|
|
|
//case SCE_KERNEL_TMID_Mutex:
|
|
|
|
// return __KernelMutexObject();
|
|
|
|
//case SCE_KERNEL_TMID_LwMutex:
|
|
|
|
// return __KernelLwMutexObject();
|
|
|
|
//case SCE_KERNEL_TMID_Semaphore:
|
|
|
|
// return __KernelSemaphoreObject();
|
|
|
|
//case SCE_KERNEL_TMID_Callback:
|
|
|
|
// return __KernelCallbackObject();
|
|
|
|
//case SCE_KERNEL_TMID_Thread:
|
|
|
|
// return __KernelThreadObject();
|
|
|
|
//case SCE_KERNEL_TMID_VTimer:
|
|
|
|
// return __KernelVTimerObject();
|
|
|
|
//case SCE_KERNEL_TMID_Tlspl:
|
|
|
|
// return __KernelTlsplObject();
|
|
|
|
//case PPSSPP_KERNEL_TMID_File:
|
|
|
|
// return __KernelFileNodeObject();
|
|
|
|
//case PPSSPP_KERNEL_TMID_DirList:
|
|
|
|
// return __KernelDirListingObject();
|
|
|
|
|
|
|
|
default:
|
|
|
|
ERROR_LOG(COMMON, "Unable to load state: could not find object type %d.", type);
|
2014-06-05 21:35:49 -07:00
|
|
|
return nullptr;
|
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() {
|
2014-05-20 16:37:46 -07:00
|
|
|
Kernel::ThreadingInit();
|
2014-07-04 10:38:12 -07:00
|
|
|
Kernel::ArchiveInit();
|
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() {
|
2014-05-20 16:37:46 -07:00
|
|
|
Kernel::ThreadingShutdown();
|
2014-07-04 10:38:12 -07:00
|
|
|
Kernel::ArchiveShutdown();
|
2014-06-10 19:43:50 -07:00
|
|
|
|
|
|
|
g_object_pool.Clear(); // Free all kernel objects
|
2014-05-20 15:13:25 -07:00
|
|
|
}
|
|
|
|
|
2014-05-22 16:06:12 -07: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) {
|
|
|
|
Init();
|
2014-05-13 18:57:12 -07:00
|
|
|
|
|
|
|
Core::g_app_core->SetPC(entry_point);
|
|
|
|
|
2014-05-14 17:49:27 -07:00
|
|
|
// 0x30 is the typical main thread priority I've seen used so far
|
2014-06-04 21:20:58 -07:00
|
|
|
g_main_thread = Kernel::SetupMainThread(0x30);
|
2014-05-13 18:57:12 -07:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2014-05-22 16:06:12 -07:00
|
|
|
|
|
|
|
} // namespace
|