nold/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere synced 2024-11-14 00:56:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

mesosphere: hard enforcement of TODOs

Browse source
This commit is contained in:
Michael Scire 2020-02-08 03:18:08 -08:00
parent 919b8124dc
commit 4b6b06fcaa
14 changed files with 57 additions and 53 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
libraries/libmesosphere/include/mesosphere/kern_common.hpp
View file

@ -15,8 +15,6 @@
*/ */
#pragma once #pragma once
#include <vapours.hpp> #include <vapours.hpp>
#include <mesosphere/kern_panic.hpp>
#include <mesosphere/svc/kern_svc_results.hpp>
namespace ams::kern { namespace ams::kern {
@ -36,3 +34,5 @@ namespace ams::kern {
#define MESOSPHERE_ENABLE_ASSERTIONS #define MESOSPHERE_ENABLE_ASSERTIONS
#define MESOSPHERE_ENABLE_DEBUG_PRINT #define MESOSPHERE_ENABLE_DEBUG_PRINT
#endif #endif
#include <mesosphere/svc/kern_svc_results.hpp>

9
libraries/libmesosphere/include/mesosphere/kern_k_process.hpp
View file

@ -14,6 +14,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#pragma once #pragma once
#include <mesosphere/kern_common.hpp>
#include <mesosphere/kern_select_cpu.hpp> #include <mesosphere/kern_select_cpu.hpp>
#include <mesosphere/kern_slab_helpers.hpp> #include <mesosphere/kern_slab_helpers.hpp>
#include <mesosphere/kern_k_synchronization_object.hpp> #include <mesosphere/kern_k_synchronization_object.hpp>
@ -27,12 +28,12 @@ namespace ams::kern {
MESOSPHERE_AUTOOBJECT_TRAITS(KProcess, KSynchronizationObject); MESOSPHERE_AUTOOBJECT_TRAITS(KProcess, KSynchronizationObject);
/* TODO: This is a placeholder definition. */ /* TODO: This is a placeholder definition. */
public: public:
constexpr ALWAYS_INLINE u64 GetCoreMask() const { /* TODO */ return 0; } u64 GetCoreMask() const { MESOSPHERE_TODO_IMPLEMENT(); }
constexpr ALWAYS_INLINE u64 GetPriorityMask() const { /* TODO */ return 0; } u64 GetPriorityMask() const { MESOSPHERE_TODO_IMPLEMENT();}
constexpr ALWAYS_INLINE bool Is64Bit() const { /* TODO */ return true; } bool Is64Bit() const { MESOSPHERE_TODO_IMPLEMENT(); }
ALWAYS_INLINE KThread *GetPreemptionStatePinnedThread(s32 core_id) { /* TODO */ return nullptr; } KThread *GetPreemptionStatePinnedThread(s32 core_id) { MESOSPHERE_TODO_IMPLEMENT(); }
void SetPreemptionState(); void SetPreemptionState();
}; };

3
libraries/libmesosphere/include/mesosphere/kern_panic.hpp
View file

@ -52,6 +52,9 @@ namespace ams::kern {
#define MESOSPHERE_ASSERT_THIS() #define MESOSPHERE_ASSERT_THIS()
#endif #endif
#define MESOSPHERE_TODO(arg) ({ constexpr const char *__mesosphere_todo = arg; MESOSPHERE_PANIC("TODO (%s): %s", __PRETTY_FUNCTION__, __mesosphere_todo); })
#define MESOSPHERE_TODO_IMPLEMENT() MESOSPHERE_TODO("Implement")
#define MESOSPHERE_ABORT() MESOSPHERE_PANIC("Abort()"); #define MESOSPHERE_ABORT() MESOSPHERE_PANIC("Abort()");
#define MESOSPHERE_INIT_ABORT() do { /* ... */ } while (true) #define MESOSPHERE_INIT_ABORT() do { /* ... */ } while (true)

1
libraries/libmesosphere/include/mesosphere/kern_select_cpu.hpp
View file

@ -14,6 +14,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#pragma once #pragma once
#include <mesosphere/kern_common.hpp>
#ifdef ATMOSPHERE_ARCH_ARM64 #ifdef ATMOSPHERE_ARCH_ARM64
#include <mesosphere/arch/arm64/kern_cpu.hpp> #include <mesosphere/arch/arm64/kern_cpu.hpp>

13
libraries/libmesosphere/source/arch/arm64/kern_exception_handlers.cpp
View file

@ -55,25 +55,26 @@ namespace ams::kern::arm64 {
break; break;
default: default:
{ {
/* TODO: Get memory state. */ MESOSPHERE_TODO("Get memory state.");
/* If state is KMemoryState_Code and the user can't read it, set should_process_user_exception = true; */ /* If state is KMemoryState_Code and the user can't read it, set should_process_user_exception = true; */
} }
break; break;
} }
if (should_process_user_exception) { if (should_process_user_exception) {
/* TODO: Process the user exception. */ MESOSPHERE_TODO("Process the user exception.");
} }
{ {
/* TODO: Process for KDebug. */ MESOSPHERE_TODO("Process for KDebug.");
MESOSPHERE_RELEASE_LOG("Exception occurred. %016lx\n", 0ul /* TODO: cur_process->GetProgramId() */); MESOSPHERE_TODO("cur_process->GetProgramId()");
MESOSPHERE_RELEASE_LOG("Exception occurred. %016lx\n", 0ul);
/* TODO: if (!svc::ResultNotHandled::Includes(res)) { debug process } */ MESOSPHERE_TODO("if (!svc::ResultNotHandled::Includes(res)) { debug process }.");
} }
/* TODO: cur_process->Exit(); */ MESOSPHERE_TODO("cur_process->Exit();");
(void)cur_process; (void)cur_process;
} }

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 the task isn't the dummy task, we should add it to the queue. */
if (task != GetDummyInterruptTask()) { if (task != GetDummyInterruptTask()) {
/* TODO: Kernel::GetInterruptTaskManager().Enqueue(task); */ MESOSPHERE_TODO("Kernel::GetInterruptTaskManager().Enqueue(task);");
} }
return true; return true;

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

@ -22,7 +22,7 @@ namespace ams::kern::arm64 {
void SupervisorModeThreadStarter(); void SupervisorModeThreadStarter();
void OnThreadStart() { void OnThreadStart() {
/* TODO: Implement this. */ MESOSPHERE_TODO_IMPLEMENT();
} }
namespace { namespace {

4
libraries/libmesosphere/source/kern_k_light_lock.cpp
View file

@ -18,11 +18,11 @@
namespace ams::kern { namespace ams::kern {
void KLightLock::LockSlowPath(uintptr_t owner, uintptr_t cur_thread) { void KLightLock::LockSlowPath(uintptr_t owner, uintptr_t cur_thread) {
/* TODO: Implement (requires KThread, KScheduler) */ MESOSPHERE_TODO_IMPLEMENT();
} }
void KLightLock::UnlockSlowPath(uintptr_t cur_thread) { void KLightLock::UnlockSlowPath(uintptr_t cur_thread) {
/* TODO: Implement (requires KThread, KScheduler) */ MESOSPHERE_TODO_IMPLEMENT();
} }
} }

2
libraries/libmesosphere/source/kern_k_process.cpp
View file

@ -18,7 +18,7 @@
namespace ams::kern { namespace ams::kern {
void KProcess::SetPreemptionState() { void KProcess::SetPreemptionState() {
/* TODO */ MESOSPHERE_TODO_IMPLEMENT();
} }
} }

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

@ -34,7 +34,7 @@ namespace ams::kern {
ALWAYS_INLINE void IncrementScheduledCount(KThread *thread) { ALWAYS_INLINE void IncrementScheduledCount(KThread *thread) {
if (KProcess *parent = thread->GetOwnerProcess(); parent != nullptr) { if (KProcess *parent = thread->GetOwnerProcess(); parent != nullptr) {
/* TODO: parent->IncrementScheduledCount(); */ MESOSPHERE_TODO("parent->IncrementScheduledCount();");
} }
} }
@ -66,7 +66,7 @@ namespace ams::kern {
void KScheduler::Activate() { void KScheduler::Activate() {
MESOSPHERE_ASSERT(GetCurrentThread().GetDisableDispatchCount() == 1); MESOSPHERE_ASSERT(GetCurrentThread().GetDisableDispatchCount() == 1);
this->state.should_count_idle = false /* TODO: Retrieve from KSystemControl. */; this->state.should_count_idle = KTargetSystem::IsDebugMode();
this->is_active = true; this->is_active = true;
RescheduleCurrentCore(); RescheduleCurrentCore();
} }
@ -230,7 +230,7 @@ namespace ams::kern {
const s64 tick_diff = cur_tick - prev_tick; const s64 tick_diff = cur_tick - prev_tick;
cur_thread->AddCpuTime(tick_diff); cur_thread->AddCpuTime(tick_diff);
if (cur_process != nullptr) { if (cur_process != nullptr) {
/* TODO: cur_process->AddCpuTime(tick_diff); */ MESOSPHERE_TODO("cur_process->AddCpuTime(tick_diff);");
} }
this->last_context_switch_time = cur_tick; this->last_context_switch_time = cur_tick;
@ -248,7 +248,7 @@ namespace ams::kern {
/* Switch the current process, if we're switching processes. */ /* Switch the current process, if we're switching processes. */
if (KProcess *next_process = next_thread->GetOwnerProcess(); next_process != cur_process) { if (KProcess *next_process = next_thread->GetOwnerProcess(); next_process != cur_process) {
/* TODO: KProcess::Switch */ MESOSPHERE_TODO("KProcess::Switch");
} }
/* Set the new Thread Local region. */ /* Set the new Thread Local region. */

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

@ -20,15 +20,13 @@ namespace ams::kern {
void NotifyAvailable() { void NotifyAvailable() {
MESOSPHERE_ASSERT_THIS(); MESOSPHERE_ASSERT_THIS();
/* TODO: Implement this. */ MESOSPHERE_TODO_IMPLEMENT();
MESOSPHERE_ABORT();
} }
void NotifyAbort(Result abort_reason) { void NotifyAbort(Result abort_reason) {
MESOSPHERE_ASSERT_THIS(); MESOSPHERE_ASSERT_THIS();
/* TODO: Implement this. */ MESOSPHERE_TODO_IMPLEMENT();
MESOSPHERE_ABORT();
} }
void KSynchronizationObject::Finalize() { void KSynchronizationObject::Finalize() {
@ -41,7 +39,7 @@ namespace ams::kern {
void KSynchronizationObject::DebugWaiters() { void KSynchronizationObject::DebugWaiters() {
MESOSPHERE_ASSERT_THIS(); MESOSPHERE_ASSERT_THIS();
/* TODO: Do useful debug operation here. */ MESOSPHERE_TODO("Do useful debug operation here.");
} }
KSynchronizationObject::iterator KSynchronizationObject::AddWaiterThread(KThread *thread) { KSynchronizationObject::iterator KSynchronizationObject::AddWaiterThread(KThread *thread) {

30
libraries/libmesosphere/source/kern_k_thread.cpp
View file

@ -23,10 +23,10 @@ namespace ams::kern {
const uintptr_t stack_bottom = stack_top - PageSize; const uintptr_t stack_bottom = stack_top - PageSize;
KPhysicalAddress stack_paddr = Null<KPhysicalAddress>; KPhysicalAddress stack_paddr = Null<KPhysicalAddress>;
/* TODO: MESOSPHERE_ABORT_UNLESS(Kernel::GetSupervisorPageTable().GetPhysicalAddress(&stack_paddr, stack_bottom)); */ MESOSPHERE_TODO("MESOSPHERE_ABORT_UNLESS(Kernel::GetSupervisorPageTable().GetPhysicalAddress(&stack_paddr, stack_bottom));");
(void)stack_bottom; (void)stack_bottom;
/* TODO: MESOSPHERE_R_ABORT_UNLESS(Kernel::GetSupervisorPageTable().Unmap(...) */ MESOSPHERE_TODO("MESOSPHERE_R_ABORT_UNLESS(Kernel::GetSupervisorPageTable().Unmap(...);");
(void)stack_paddr; (void)stack_paddr;
/* Free the stack page. */ /* Free the stack page. */
@ -149,8 +149,8 @@ namespace ams::kern {
/* Setup the TLS, if needed. */ /* Setup the TLS, if needed. */
if (type == ThreadType_User) { if (type == ThreadType_User) {
/* TODO: R_TRY(owner->CreateThreadLocalRegion(&this->tls_address)); */ MESOSPHERE_TODO("R_TRY(owner->CreateThreadLocalRegion(&this->tls_address));");
/* TODO: this->tls_heap_address = owner->GetThreadLocalRegionAddress(this->tls_address); */ MESOSPHERE_TODO("this->tls_heap_address = owner->GetThreadLocalRegionAddress(this->tls_address);");
std::memset(this->tls_heap_address, 0, ams::svc::ThreadLocalRegionSize); std::memset(this->tls_heap_address, 0, ams::svc::ThreadLocalRegionSize);
} }
@ -158,7 +158,7 @@ namespace ams::kern {
if (owner != nullptr) { if (owner != nullptr) {
this->parent = owner; this->parent = owner;
this->parent->Open(); this->parent->Open();
/* TODO: this->parent->IncrementThreadCount(); */ MESOSPHERE_TODO("this->parent->IncrementThreadCount();");
} }
/* Initialize thread context. */ /* Initialize thread context. */
@ -171,7 +171,7 @@ namespace ams::kern {
/* Setup the stack parameters. */ /* Setup the stack parameters. */
StackParameters &sp = this->GetStackParameters(); StackParameters &sp = this->GetStackParameters();
if (this->parent != nullptr) { if (this->parent != nullptr) {
/* TODO: this->parent->CopySvcPermissionTo(pos.svc_permission); */ MESOSPHERE_TODO("this->parent->CopySvcPermissionTo(sp.svc_permission);");
} }
sp.context = std::addressof(this->thread_context); sp.context = std::addressof(this->thread_context);
sp.disable_count = 1; sp.disable_count = 1;
@ -185,8 +185,8 @@ namespace ams::kern {
/* Register ourselves with our parent process. */ /* Register ourselves with our parent process. */
if (this->parent != nullptr) { if (this->parent != nullptr) {
/* TODO: this->parent->RegisterThread(this); */ MESOSPHERE_TODO("this->parent->RegisterThread(this);");
/* TODO: if (this->parent->IsSuspended()) { this->RequestSuspend(SuspendType_Process); } */ MESOSPHERE_TODO("if (this->parent->IsSuspended()) { this->RequestSuspend(SuspendType_Process);");
} }
return ResultSuccess(); return ResultSuccess();
@ -205,7 +205,7 @@ namespace ams::kern {
KProcessAddress stack_top = Null<KProcessAddress>; KProcessAddress stack_top = Null<KProcessAddress>;
{ {
auto page_guard = SCOPE_GUARD { KPageBuffer::Free(page); }; auto page_guard = SCOPE_GUARD { KPageBuffer::Free(page); };
/* TODO: R_TRY(Kernel::GetSupervisorPageTable().Map); ... */ MESOSPHERE_TODO("R_TRY(Kernel::GetSupervisorPageTable().Map); ...");
(void)(stack_region); (void)(stack_region);
page_guard.Cancel(); page_guard.Cancel();
} }
@ -222,16 +222,16 @@ namespace ams::kern {
KProcess *owner = reinterpret_cast<KProcess *>(arg & ~1ul); KProcess *owner = reinterpret_cast<KProcess *>(arg & ~1ul);
const bool resource_limit_release_hint = (arg & 1); const bool resource_limit_release_hint = (arg & 1);
if (owner != nullptr) { if (owner != nullptr) {
/* TODO: Release from owner resource limit. */ MESOSPHERE_TODO("Release from owner resource limit.");
(void)(resource_limit_release_hint); (void)(resource_limit_release_hint);
owner->Close(); owner->Close();
} else { } else {
/* TODO: Release from system resource limit. */ MESOSPHERE_TODO("Release from system resource limit.");
} }
} }
void KThread::Finalize() { void KThread::Finalize() {
/* TODO */ MESOSPHERE_TODO_IMPLEMENT();
} }
bool KThread::IsSignaled() const { bool KThread::IsSignaled() const {
@ -239,11 +239,11 @@ namespace ams::kern {
} }
void KThread::OnTimer() { void KThread::OnTimer() {
/* TODO */ MESOSPHERE_TODO_IMPLEMENT();
} }
void KThread::DoWorkerTask() { void KThread::DoWorkerTask() {
/* TODO */ MESOSPHERE_TODO_IMPLEMENT();
} }
Result KThread::SetPriorityToIdle() { Result KThread::SetPriorityToIdle() {
@ -335,7 +335,7 @@ namespace ams::kern {
void KThread::Exit() { void KThread::Exit() {
MESOSPHERE_ASSERT_THIS(); MESOSPHERE_ASSERT_THIS();
/* TODO */ MESOSPHERE_TODO_IMPLEMENT();
MESOSPHERE_PANIC("KThread::Exit() would return"); MESOSPHERE_PANIC("KThread::Exit() would return");
} }

6
libraries/libmesosphere/source/kern_k_thread_local_page.cpp
View file

@ -29,7 +29,7 @@ namespace ams::kern {
auto page_buf_guard = SCOPE_GUARD { KPageBuffer::Free(page_buf); }; auto page_buf_guard = SCOPE_GUARD { KPageBuffer::Free(page_buf); };
/* Map the address in. */ /* Map the address in. */
/* TODO: R_TRY(this->owner->GetPageTable().Map(...)); */ MESOSPHERE_TODO("R_TRY(this->owner->GetPageTable().Map(...));");
/* We succeeded. */ /* We succeeded. */
page_buf_guard.Cancel(); page_buf_guard.Cancel();
@ -41,10 +41,10 @@ namespace ams::kern {
/* Get the physical address of the page. */ /* Get the physical address of the page. */
KPhysicalAddress phys_addr = Null<KPhysicalAddress>; KPhysicalAddress phys_addr = Null<KPhysicalAddress>;
/* TODO: MESOSPHERE_ABORT_UNLESS(this->owner->GetPageTable().GetPhysicalAddress(&phys_addr, this->GetAddress())); */ MESOSPHERE_TODO("MESOSPHERE_ABORT_UNLESS(this->owner->GetPageTable().GetPhysicalAddress(&phys_addr, this->GetAddress()));");
/* Unmap the page. */ /* Unmap the page. */
/* TODO: R_TRY(this->owner->GetPageTable().Unmap(...); */ MESOSPHERE_TODO("R_TRY(this->owner->GetPageTable().Unmap(...);");
/* Free the page. */ /* Free the page. */
KPageBuffer::Free(KPageBuffer::FromPhysicalAddress(phys_addr)); KPageBuffer::Free(KPageBuffer::FromPhysicalAddress(phys_addr));

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

@ -71,13 +71,13 @@ namespace ams::kern {
/* Initialize the supervisor page table for each core. */ /* Initialize the supervisor page table for each core. */
DoOnEachCoreInOrder(core_id, [=]() ALWAYS_INLINE_LAMBDA { DoOnEachCoreInOrder(core_id, [=]() ALWAYS_INLINE_LAMBDA {
/* TODO: KPageTable::Initialize(); */ MESOSPHERE_TODO("KPageTable::Initialize();");
/* TODO: Kernel::GetSupervisorPageTable().Initialize(); */ MESOSPHERE_TODO("Kernel::GetSupervisorPageTable().Initialize();");
}); });
/* Set ttbr0 for each core. */ /* Set ttbr0 for each core. */
DoOnEachCoreInOrder(core_id, [=]() ALWAYS_INLINE_LAMBDA { DoOnEachCoreInOrder(core_id, [=]() ALWAYS_INLINE_LAMBDA {
/* TODO: SetTtbr0(); */ MESOSPHERE_TODO("SetTtbr0();");
}); });
/* NOTE: Kernel calls on each core a nullsub here on retail kernel. */ /* NOTE: Kernel calls on each core a nullsub here on retail kernel. */
@ -86,7 +86,7 @@ namespace ams::kern {
DoOnEachCoreInOrder(core_id, [=]() ALWAYS_INLINE_LAMBDA { DoOnEachCoreInOrder(core_id, [=]() ALWAYS_INLINE_LAMBDA {
KThread::Register(std::addressof(Kernel::GetMainThread(core_id))); KThread::Register(std::addressof(Kernel::GetMainThread(core_id)));
KThread::Register(std::addressof(Kernel::GetIdleThread(core_id))); KThread::Register(std::addressof(Kernel::GetIdleThread(core_id)));
/* TODO: Kernel::GetInterruptTaskManager().Initialize(); */ MESOSPHERE_TODO("Kernel::GetInterruptTaskManager().Initialize();");
}); });
/* Activate the scheduler and enable interrupts. */ /* Activate the scheduler and enable interrupts. */
@ -104,18 +104,18 @@ namespace ams::kern {
/* Perform more core-0 specific initialization. */ /* Perform more core-0 specific initialization. */
if (core_id == 0) { if (core_id == 0) {
/* TODO: Initialize KWorkerThreadManager */ MESOSPHERE_TODO("Initialize KWorkerThreadManager");
/* TODO: KSystemControl::InitializeSleepManagerAndAppletSecureMemory(); */ MESOSPHERE_TODO("KSystemControl::InitializeSleepManagerAndAppletSecureMemory();");
/* TODO: KDeviceAddressSpace::Initialize(); */ MESOSPHERE_TODO("KDeviceAddressSpace::Initialize();");
/* TODO: CreateAndRunInitialProcesses(); */ MESOSPHERE_TODO("CreateAndRunInitialProcesses();");
/* We're done initializing! */ /* We're done initializing! */
Kernel::SetState(Kernel::State::Initialized); Kernel::SetState(Kernel::State::Initialized);
/* TODO: KThread::ResumeThreadsSuspendedForInit(); */ MESOSPHERE_TODO("KThread::ResumeThreadsSuspendedForInit();");
} }
cpu::SynchronizeAllCores(); cpu::SynchronizeAllCores();