mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2025-05-27 13:14:15 -04:00
Code Issues Projects Releases Packages Wiki Activity

kern: implement init through InterruptTaskManager.Initialize()

Browse source
This commit is contained in:
Michael Scire 2020-02-10 02:26:00 -08:00
parent 3c78bc4dbf
commit 3bcc4adb5c
8 changed files with 87 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

2
libraries/libmesosphere/source/arch/arm64/kern_k_interrupt_manager.cpp
View file

@ -85,7 +85,7 @@ namespace ams::kern::arm64 {
/* If the task isn't the dummy task, we should add it to the queue. */
if (task != GetDummyInterruptTask()) {
MESOSPHERE_TODO("Kernel::GetInterruptTaskManager().Enqueue(task);");
Kernel::GetInterruptTaskManager().EnqueueTask(task);
}
return true;

8
libraries/libmesosphere/source/arch/arm64/kern_k_supervisor_page_table.cpp
View file

@ -39,6 +39,14 @@ namespace ams::kern::arm64 {
}
}
void KSupervisorPageTable::Activate() {
/* Initialize, using process id = 0xFFFFFFFF */
this->page_table.Initialize(0xFFFFFFFF);
/* Invalidate entire TLB. */
cpu::InvalidateEntireTlb();
}
void KSupervisorPageTable::Finalize(s32 core_id) {
MESOSPHERE_TODO_IMPLEMENT();
}

55
libraries/libmesosphere/source/kern_k_interrupt_task_manager.cpp
View file

@ -18,6 +18,10 @@
namespace ams::kern {
void KInterruptTaskManager::TaskQueue::Enqueue(KInterruptTask *task) {
MESOSPHERE_ASSERT(task->GetNextTask() == nullptr);
MESOSPHERE_ASSERT(task != this->head);
MESOSPHERE_ASSERT(task != this->tail);
/* Insert the task into the queue. */
if (this->tail != nullptr) {
this->tail->SetNextTask(task);
@ -29,6 +33,10 @@ namespace ams::kern {
}
void KInterruptTaskManager::TaskQueue::Dequeue() {
MESOSPHERE_ASSERT(this->head != nullptr);
MESOSPHERE_ASSERT(this->tail != nullptr);
/* Pop the task from the front of the queue. */
if (this->head == this->tail) {
this->head = nullptr;
this->tail = nullptr;
@ -37,4 +45,51 @@ namespace ams::kern {
}
}
void KInterruptTaskManager::ThreadFunction(uintptr_t arg) {
reinterpret_cast<KInterruptTaskManager *>(arg)->ThreadFunctionImpl();
}
void KInterruptTaskManager::ThreadFunctionImpl() {
MESOSPHERE_ASSERT_THIS();
while (true) {
/* Get a task. */
KInterruptTask *task = nullptr;
{
KScopedInterruptDisable di;
task = this->task_queue.GetHead();
if (task == nullptr) {
this->thread->SetState(KThread::ThreadState_Waiting);
continue;
}
this->task_queue.Dequeue();
}
/* Do the task. */
task->DoTask();
}
}
void KInterruptTaskManager::Initialize() {
/* Reserve a thread from the system limit. */
MESOSPHERE_ABORT_UNLESS(Kernel::GetSystemResourceLimit().Reserve(ams::svc::LimitableResource_ThreadCountMax, 1));
/* Create and initialize the thread. */
this->thread = KThread::Create();
MESOSPHERE_ABORT_UNLESS(this->thread != nullptr);
MESOSPHERE_R_ABORT_UNLESS(KThread::InitializeHighPriorityThread(this->thread, ThreadFunction, reinterpret_cast<uintptr_t>(this)));
KThread::Register(this->thread);
/* Run the thread. */
this->thread->Run();
}
void KInterruptTaskManager::EnqueueTask(KInterruptTask *task) {
MESOSPHERE_ASSERT(!KInterruptManager::AreInterruptsEnabled());
MESOSPHERE_TODO_IMPLEMENT();
}
}

8
libraries/libmesosphere/source/kern_main.cpp
View file

@ -78,9 +78,9 @@ namespace ams::kern {
Kernel::GetKernelPageTable().Initialize(core_id);
});
/* Set ttbr0 for each core. */
/* Activate the supervisor page table for each core. */
DoOnEachCoreInOrder(core_id, [=]() ALWAYS_INLINE_LAMBDA {
MESOSPHERE_TODO("SetTtbr0();");
Kernel::GetKernelPageTable().Activate();
});
/* NOTE: Kernel calls on each core a nullsub here on retail kernel. */
@ -89,7 +89,7 @@ namespace ams::kern {
DoOnEachCoreInOrder(core_id, [=]() ALWAYS_INLINE_LAMBDA {
KThread::Register(std::addressof(Kernel::GetMainThread(core_id)));
KThread::Register(std::addressof(Kernel::GetIdleThread(core_id)));
MESOSPHERE_TODO("Kernel::GetInterruptTaskManager().Initialize();");
Kernel::GetInterruptTaskManager().Initialize();
});
/* Activate the scheduler and enable interrupts. */
@ -99,7 +99,7 @@ namespace ams::kern {
});
/* Initialize cpu interrupt threads. */
/* TODO cpu::InitializeInterruptThreads(core_id); */
MESOSPHERE_TODO("cpu::InitializeInterruptThreads(core_id);");
/* Initialize the DPC manager. */
KDpcManager::Initialize();