kern: implement KWorkerTaskManager

This commit is contained in:
Michael Scire 2020-02-14 02:56:42 -08:00
parent c91386b0fa
commit 5b98426171
5 changed files with 171 additions and 1 deletions

View file

@ -0,0 +1,51 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <mesosphere/kern_common.hpp>
#include <mesosphere/kern_k_worker_task.hpp>
#include <mesosphere/kern_k_thread.hpp>
namespace ams::kern {
class KWorkerTaskManager {
public:
static constexpr s32 ExitWorkerPriority = 11;
enum WorkerType {
WorkerType_Exit,
WorkerType_Count,
};
private:
KWorkerTask *head_task;
KWorkerTask *tail_task;
KThread *thread;
WorkerType type;
bool active;
private:
static void ThreadFunction(uintptr_t arg);
void ThreadFunctionImpl();
KWorkerTask *GetTask();
void AddTask(KWorkerTask *task);
public:
constexpr KWorkerTaskManager() : head_task(), tail_task(), thread(), type(WorkerType_Count), active() { /* ... */ }
NOINLINE void Initialize(WorkerType wt, s32 priority);
static void AddTask(WorkerType type, KWorkerTask *task);
};
}

View file

@ -20,6 +20,7 @@
#include <mesosphere/kern_k_memory_layout.hpp> #include <mesosphere/kern_k_memory_layout.hpp>
#include <mesosphere/kern_k_memory_manager.hpp> #include <mesosphere/kern_k_memory_manager.hpp>
#include <mesosphere/kern_k_core_local_region.hpp> #include <mesosphere/kern_k_core_local_region.hpp>
#include <mesosphere/kern_k_worker_task_manager.hpp>
namespace ams::kern { namespace ams::kern {
@ -69,6 +70,7 @@ namespace ams::kern {
static KMemoryBlockSlabManager s_sys_memory_block_manager; static KMemoryBlockSlabManager s_sys_memory_block_manager;
static KBlockInfoManager s_block_info_manager; static KBlockInfoManager s_block_info_manager;
static KSupervisorPageTable s_supervisor_page_table; static KSupervisorPageTable s_supervisor_page_table;
static KWorkerTaskManager s_worker_task_managers[KWorkerTaskManager::WorkerType_Count];
private: private:
static ALWAYS_INLINE KCoreLocalContext &GetCoreLocalContext() { static ALWAYS_INLINE KCoreLocalContext &GetCoreLocalContext() {
return reinterpret_cast<KCoreLocalRegion *>(cpu::GetCoreLocalRegionAddress())->current.context; return reinterpret_cast<KCoreLocalRegion *>(cpu::GetCoreLocalRegionAddress())->current.context;
@ -135,6 +137,11 @@ namespace ams::kern {
static ALWAYS_INLINE KSupervisorPageTable &GetKernelPageTable() { static ALWAYS_INLINE KSupervisorPageTable &GetKernelPageTable() {
return s_supervisor_page_table; return s_supervisor_page_table;
} }
static ALWAYS_INLINE KWorkerTaskManager &GetWorkerTaskManager(KWorkerTaskManager::WorkerType type) {
MESOSPHERE_ASSERT(type <= KWorkerTaskManager::WorkerType_Count);
return s_worker_task_managers[type];
}
}; };
} }

View file

@ -0,0 +1,111 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <mesosphere.hpp>
namespace ams::kern {
void KWorkerTaskManager::Initialize(WorkerType wt, s32 priority) {
/* Set type, other members already initialized in constructor. */
this->type = wt;
/* Reserve a thread from the system limit. */
MESOSPHERE_ABORT_UNLESS(Kernel::GetSystemResourceLimit().Reserve(ams::svc::LimitableResource_ThreadCountMax, 1));
/* Create a new thread. */
this->thread = KThread::Create();
MESOSPHERE_ABORT_UNLESS(this->thread != nullptr);
/* Launch the new thread. */
MESOSPHERE_R_ABORT_UNLESS(KThread::InitializeKernelThread(this->thread, ThreadFunction, reinterpret_cast<uintptr_t>(this), priority, cpu::NumCores - 1));
/* Register the new thread. */
KThread::Register(this->thread);
/* Run the thread. */
this->thread->Run();
}
void KWorkerTaskManager::AddTask(WorkerType type, KWorkerTask *task) {
MESOSPHERE_ASSERT(type <= WorkerType_Count);
Kernel::GetWorkerTaskManager(type).AddTask(task);
}
void KWorkerTaskManager::ThreadFunction(uintptr_t arg) {
reinterpret_cast<KWorkerTaskManager *>(arg)->ThreadFunctionImpl();
}
void KWorkerTaskManager::ThreadFunctionImpl() {
while (true) {
KWorkerTask *task = nullptr;
/* Get a worker task. */
{
KScopedSchedulerLock sl;
task = this->GetTask();
if (task == nullptr) {
/* If there's nothing to do, set ourselves as waiting. */
this->active = false;
this->thread->SetState(KThread::ThreadState_Waiting);
continue;
}
this->active = true;
}
/* Do the task. */
task->DoWorkerTask();
}
}
KWorkerTask *KWorkerTaskManager::GetTask() {
MESOSPHERE_ASSERT(KScheduler::IsSchedulerLockedByCurrentThread());
KWorkerTask *next = this->head_task;
if (next) {
/* Advance the list. */
if (this->head_task == this->tail_task) {
this->head_task = nullptr;
this->tail_task = nullptr;
} else {
this->head_task = this->head_task->GetNextTask();
}
/* Clear the next task's next. */
next->SetNextTask(nullptr);
}
return next;
}
void KWorkerTaskManager::AddTask(KWorkerTask *task) {
KScopedSchedulerLock sl;
MESOSPHERE_ASSERT(task->GetNextTask() == nullptr);
/* Insert the task. */
if (this->tail_task) {
this->tail_task->SetNextTask(task);
this->tail_task = task;
} else {
this->head_task = task;
this->tail_task = task;
/* Make ourselves active if we need to. */
if (!this->active) {
this->thread->SetState(KThread::ThreadState_Runnable);
}
}
}
}

View file

@ -107,7 +107,7 @@ namespace ams::kern {
/* Perform more core-0 specific initialization. */ /* Perform more core-0 specific initialization. */
if (core_id == 0) { if (core_id == 0) {
MESOSPHERE_TODO("Initialize KWorkerThreadManager"); Kernel::GetWorkerTaskManager(KWorkerTaskManager::WorkerType_Exit).Initialize(KWorkerTaskManager::WorkerType_Exit, KWorkerTaskManager::ExitWorkerPriority);
MESOSPHERE_TODO("KSystemControl::InitializeSleepManagerAndAppletSecureMemory();"); MESOSPHERE_TODO("KSystemControl::InitializeSleepManagerAndAppletSecureMemory();");

View file

@ -26,6 +26,7 @@ namespace ams::kern {
KMemoryBlockSlabManager Kernel::s_sys_memory_block_manager; KMemoryBlockSlabManager Kernel::s_sys_memory_block_manager;
KBlockInfoManager Kernel::s_block_info_manager; KBlockInfoManager Kernel::s_block_info_manager;
KSupervisorPageTable Kernel::s_supervisor_page_table; KSupervisorPageTable Kernel::s_supervisor_page_table;
KWorkerTaskManager Kernel::s_worker_task_managers[KWorkerTaskManager::WorkerType_Count];
namespace { namespace {