// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later

#include <random>
#include "common/scope_exit.h"
#include "common/settings.h"
#include "core/core.h"
#include "core/hle/kernel/k_process.h"
#include "core/hle/kernel/k_scoped_resource_reservation.h"
#include "core/hle/kernel/k_shared_memory.h"
#include "core/hle/kernel/k_shared_memory_info.h"
#include "core/hle/kernel/k_thread_local_page.h"
#include "core/hle/kernel/k_thread_queue.h"
#include "core/hle/kernel/k_worker_task_manager.h"

namespace Kernel {

namespace {

Result TerminateChildren(KernelCore& kernel, KProcess* process,
                         const KThread* thread_to_not_terminate) {
    // Request that all children threads terminate.
    {
        KScopedLightLock proc_lk(process->GetListLock());
        KScopedSchedulerLock sl(kernel);

        if (thread_to_not_terminate != nullptr &&
            process->GetPinnedThread(GetCurrentCoreId(kernel)) == thread_to_not_terminate) {
            // NOTE: Here Nintendo unpins the current thread instead of the thread_to_not_terminate.
            // This is valid because the only caller which uses non-nullptr as argument uses
            // GetCurrentThreadPointer(), but it's still notable because it seems incorrect at
            // first glance.
            process->UnpinCurrentThread();
        }

        auto& thread_list = process->GetThreadList();
        for (auto it = thread_list.begin(); it != thread_list.end(); ++it) {
            if (KThread* thread = std::addressof(*it); thread != thread_to_not_terminate) {
                if (thread->GetState() != ThreadState::Terminated) {
                    thread->RequestTerminate();
                }
            }
        }
    }

    // Wait for all children threads to terminate.
    while (true) {
        // Get the next child.
        KThread* cur_child = nullptr;
        {
            KScopedLightLock proc_lk(process->GetListLock());

            auto& thread_list = process->GetThreadList();
            for (auto it = thread_list.begin(); it != thread_list.end(); ++it) {
                if (KThread* thread = std::addressof(*it); thread != thread_to_not_terminate) {
                    if (thread->GetState() != ThreadState::Terminated) {
                        if (thread->Open()) {
                            cur_child = thread;
                            break;
                        }
                    }
                }
            }
        }

        // If we didn't find any non-terminated children, we're done.
        if (cur_child == nullptr) {
            break;
        }

        // Terminate and close the thread.
        SCOPE_EXIT({ cur_child->Close(); });

        if (const Result terminate_result = cur_child->Terminate();
            ResultTerminationRequested == terminate_result) {
            R_THROW(terminate_result);
        }
    }

    R_SUCCEED();
}

class ThreadQueueImplForKProcessEnterUserException final : public KThreadQueue {
private:
    KThread** m_exception_thread;

public:
    explicit ThreadQueueImplForKProcessEnterUserException(KernelCore& kernel, KThread** t)
        : KThreadQueue(kernel), m_exception_thread(t) {}

    virtual void EndWait(KThread* waiting_thread, Result wait_result) override {
        // Set the exception thread.
        *m_exception_thread = waiting_thread;

        // Invoke the base end wait handler.
        KThreadQueue::EndWait(waiting_thread, wait_result);
    }

    virtual void CancelWait(KThread* waiting_thread, Result wait_result,
                            bool cancel_timer_task) override {
        // Remove the thread as a waiter on its mutex owner.
        waiting_thread->GetLockOwner()->RemoveWaiter(waiting_thread);

        // Invoke the base cancel wait handler.
        KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
    }
};

void GenerateRandom(std::span<u64> out_random) {
    std::mt19937 rng(Settings::values.rng_seed_enabled ? Settings::values.rng_seed.GetValue()
                                                       : static_cast<u32>(std::time(nullptr)));
    std::uniform_int_distribution<u64> distribution;
    std::generate(out_random.begin(), out_random.end(), [&] { return distribution(rng); });
}

} // namespace

void KProcess::Finalize() {
    // Delete the process local region.
    this->DeleteThreadLocalRegion(m_plr_address);

    // Get the used memory size.
    const size_t used_memory_size = this->GetUsedNonSystemUserPhysicalMemorySize();

    // Finalize the page table.
    m_page_table.Finalize();

    // Finish using our system resource.
    if (m_system_resource) {
        if (m_system_resource->IsSecureResource()) {
            // Finalize optimized memory. If memory wasn't optimized, this is a no-op.
            m_kernel.MemoryManager().FinalizeOptimizedMemory(this->GetId(), m_memory_pool);
        }

        m_system_resource->Close();
        m_system_resource = nullptr;
    }

    // Free all shared memory infos.
    {
        auto it = m_shared_memory_list.begin();
        while (it != m_shared_memory_list.end()) {
            KSharedMemoryInfo* info = std::addressof(*it);
            KSharedMemory* shmem = info->GetSharedMemory();

            while (!info->Close()) {
                shmem->Close();
            }
            shmem->Close();

            it = m_shared_memory_list.erase(it);
            KSharedMemoryInfo::Free(m_kernel, info);
        }
    }

    // Our thread local page list must be empty at this point.
    ASSERT(m_partially_used_tlp_tree.empty());
    ASSERT(m_fully_used_tlp_tree.empty());

    // Release memory to the resource limit.
    if (m_resource_limit != nullptr) {
        ASSERT(used_memory_size >= m_memory_release_hint);
        m_resource_limit->Release(Svc::LimitableResource::PhysicalMemoryMax, used_memory_size,
                                  used_memory_size - m_memory_release_hint);
        m_resource_limit->Close();
    }

    // Perform inherited finalization.
    KSynchronizationObject::Finalize();
}

Result KProcess::Initialize(const Svc::CreateProcessParameter& params, KResourceLimit* res_limit,
                            bool is_real) {
    // TODO: remove this special case
    if (is_real) {
        // Create and clear the process local region.
        R_TRY(this->CreateThreadLocalRegion(std::addressof(m_plr_address)));
        this->GetMemory().ZeroBlock(m_plr_address, Svc::ThreadLocalRegionSize);
    }

    // Copy in the name from parameters.
    static_assert(sizeof(params.name) < sizeof(m_name));
    std::memcpy(m_name.data(), params.name.data(), sizeof(params.name));
    m_name[sizeof(params.name)] = 0;

    // Set misc fields.
    m_state = State::Created;
    m_main_thread_stack_size = 0;
    m_used_kernel_memory_size = 0;
    m_ideal_core_id = 0;
    m_flags = params.flags;
    m_version = params.version;
    m_program_id = params.program_id;
    m_code_address = params.code_address;
    m_code_size = params.code_num_pages * PageSize;
    m_is_application = True(params.flags & Svc::CreateProcessFlag::IsApplication);

    // Set thread fields.
    for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
        m_running_threads[i] = nullptr;
        m_pinned_threads[i] = nullptr;
        m_running_thread_idle_counts[i] = 0;
        m_running_thread_switch_counts[i] = 0;
    }

    // Set max memory based on address space type.
    switch ((params.flags & Svc::CreateProcessFlag::AddressSpaceMask)) {
    case Svc::CreateProcessFlag::AddressSpace32Bit:
    case Svc::CreateProcessFlag::AddressSpace64BitDeprecated:
    case Svc::CreateProcessFlag::AddressSpace64Bit:
        m_max_process_memory = m_page_table.GetHeapRegionSize();
        break;
    case Svc::CreateProcessFlag::AddressSpace32BitWithoutAlias:
        m_max_process_memory = m_page_table.GetHeapRegionSize() + m_page_table.GetAliasRegionSize();
        break;
    default:
        UNREACHABLE();
    }

    // Generate random entropy.
    GenerateRandom(m_entropy);

    // Clear remaining fields.
    m_num_running_threads = 0;
    m_num_process_switches = 0;
    m_num_thread_switches = 0;
    m_num_fpu_switches = 0;
    m_num_supervisor_calls = 0;
    m_num_ipc_messages = 0;

    m_is_signaled = false;
    m_exception_thread = nullptr;
    m_is_suspended = false;
    m_memory_release_hint = 0;
    m_schedule_count = 0;
    m_is_handle_table_initialized = false;

    // Open a reference to our resource limit.
    m_resource_limit = res_limit;
    m_resource_limit->Open();

    // We're initialized!
    m_is_initialized = true;

    R_SUCCEED();
}

Result KProcess::Initialize(const Svc::CreateProcessParameter& params, const KPageGroup& pg,
                            std::span<const u32> caps, KResourceLimit* res_limit,
                            KMemoryManager::Pool pool, bool immortal) {
    ASSERT(res_limit != nullptr);
    ASSERT((params.code_num_pages * PageSize) / PageSize ==
           static_cast<size_t>(params.code_num_pages));

    // Set members.
    m_memory_pool = pool;
    m_is_default_application_system_resource = false;
    m_is_immortal = immortal;

    // Setup our system resource.
    if (const size_t system_resource_num_pages = params.system_resource_num_pages;
        system_resource_num_pages != 0) {
        // Create a secure system resource.
        KSecureSystemResource* secure_resource = KSecureSystemResource::Create(m_kernel);
        R_UNLESS(secure_resource != nullptr, ResultOutOfResource);

        ON_RESULT_FAILURE {
            secure_resource->Close();
        };

        // Initialize the secure resource.
        R_TRY(secure_resource->Initialize(system_resource_num_pages * PageSize, res_limit,
                                          m_memory_pool));

        // Set our system resource.
        m_system_resource = secure_resource;
    } else {
        // Use the system-wide system resource.
        const bool is_app = True(params.flags & Svc::CreateProcessFlag::IsApplication);
        m_system_resource = std::addressof(is_app ? m_kernel.GetAppSystemResource()
                                                  : m_kernel.GetSystemSystemResource());

        m_is_default_application_system_resource = is_app;

        // Open reference to the system resource.
        m_system_resource->Open();
    }

    // Ensure we clean up our secure resource, if we fail.
    ON_RESULT_FAILURE {
        m_system_resource->Close();
        m_system_resource = nullptr;
    };

    // Setup page table.
    {
        const auto as_type = params.flags & Svc::CreateProcessFlag::AddressSpaceMask;
        const bool enable_aslr = True(params.flags & Svc::CreateProcessFlag::EnableAslr);
        const bool enable_das_merge =
            False(params.flags & Svc::CreateProcessFlag::DisableDeviceAddressSpaceMerge);
        R_TRY(m_page_table.InitializeForProcess(
            as_type, enable_aslr, enable_das_merge, !enable_aslr, pool, params.code_address,
            params.code_num_pages * PageSize, m_system_resource, res_limit, this->GetMemory()));
    }
    ON_RESULT_FAILURE_2 {
        m_page_table.Finalize();
    };

    // Ensure we can insert the code region.
    R_UNLESS(m_page_table.CanContain(params.code_address, params.code_num_pages * PageSize,
                                     KMemoryState::Code),
             ResultInvalidMemoryRegion);

    // Map the code region.
    R_TRY(m_page_table.MapPageGroup(params.code_address, pg, KMemoryState::Code,
                                    KMemoryPermission::KernelRead));

    // Initialize capabilities.
    R_TRY(m_capabilities.InitializeForKip(caps, std::addressof(m_page_table)));

    // Initialize the process id.
    m_process_id = m_kernel.CreateNewUserProcessID();
    ASSERT(InitialProcessIdMin <= m_process_id);
    ASSERT(m_process_id <= InitialProcessIdMax);

    // Initialize the rest of the process.
    R_TRY(this->Initialize(params, res_limit, true));

    // We succeeded!
    R_SUCCEED();
}

Result KProcess::Initialize(const Svc::CreateProcessParameter& params,
                            std::span<const u32> user_caps, KResourceLimit* res_limit,
                            KMemoryManager::Pool pool) {
    ASSERT(res_limit != nullptr);

    // Set members.
    m_memory_pool = pool;
    m_is_default_application_system_resource = false;
    m_is_immortal = false;

    // Get the memory sizes.
    const size_t code_num_pages = params.code_num_pages;
    const size_t system_resource_num_pages = params.system_resource_num_pages;
    const size_t code_size = code_num_pages * PageSize;
    const size_t system_resource_size = system_resource_num_pages * PageSize;

    // Reserve memory for our code resource.
    KScopedResourceReservation memory_reservation(
        res_limit, Svc::LimitableResource::PhysicalMemoryMax, code_size);
    R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

    // Setup our system resource.
    if (system_resource_num_pages != 0) {
        // Create a secure system resource.
        KSecureSystemResource* secure_resource = KSecureSystemResource::Create(m_kernel);
        R_UNLESS(secure_resource != nullptr, ResultOutOfResource);

        ON_RESULT_FAILURE {
            secure_resource->Close();
        };

        // Initialize the secure resource.
        R_TRY(secure_resource->Initialize(system_resource_size, res_limit, m_memory_pool));

        // Set our system resource.
        m_system_resource = secure_resource;

    } else {
        // Use the system-wide system resource.
        const bool is_app = True(params.flags & Svc::CreateProcessFlag::IsApplication);
        m_system_resource = std::addressof(is_app ? m_kernel.GetAppSystemResource()
                                                  : m_kernel.GetSystemSystemResource());

        m_is_default_application_system_resource = is_app;

        // Open reference to the system resource.
        m_system_resource->Open();
    }

    // Ensure we clean up our secure resource, if we fail.
    ON_RESULT_FAILURE {
        m_system_resource->Close();
        m_system_resource = nullptr;
    };

    // Setup page table.
    {
        const auto as_type = params.flags & Svc::CreateProcessFlag::AddressSpaceMask;
        const bool enable_aslr = True(params.flags & Svc::CreateProcessFlag::EnableAslr);
        const bool enable_das_merge =
            False(params.flags & Svc::CreateProcessFlag::DisableDeviceAddressSpaceMerge);
        R_TRY(m_page_table.InitializeForProcess(as_type, enable_aslr, enable_das_merge,
                                                !enable_aslr, pool, params.code_address, code_size,
                                                m_system_resource, res_limit, this->GetMemory()));
    }
    ON_RESULT_FAILURE_2 {
        m_page_table.Finalize();
    };

    // Ensure we can insert the code region.
    R_UNLESS(m_page_table.CanContain(params.code_address, code_size, KMemoryState::Code),
             ResultInvalidMemoryRegion);

    // Map the code region.
    R_TRY(m_page_table.MapPages(params.code_address, code_num_pages, KMemoryState::Code,
                                KMemoryPermission::KernelRead | KMemoryPermission::NotMapped));

    // Initialize capabilities.
    R_TRY(m_capabilities.InitializeForUser(user_caps, std::addressof(m_page_table)));

    // Initialize the process id.
    m_process_id = m_kernel.CreateNewUserProcessID();
    ASSERT(ProcessIdMin <= m_process_id);
    ASSERT(m_process_id <= ProcessIdMax);

    // If we should optimize memory allocations, do so.
    if (m_system_resource->IsSecureResource() &&
        True(params.flags & Svc::CreateProcessFlag::OptimizeMemoryAllocation)) {
        R_TRY(m_kernel.MemoryManager().InitializeOptimizedMemory(m_process_id, pool));
    }

    // Initialize the rest of the process.
    R_TRY(this->Initialize(params, res_limit, true));

    // We succeeded, so commit our memory reservation.
    memory_reservation.Commit();
    R_SUCCEED();
}

void KProcess::DoWorkerTaskImpl() {
    // Terminate child threads.
    TerminateChildren(m_kernel, this, nullptr);

    // Finalize the handle table, if we're not immortal.
    if (!m_is_immortal && m_is_handle_table_initialized) {
        this->FinalizeHandleTable();
    }

    // Finish termination.
    this->FinishTermination();
}

Result KProcess::StartTermination() {
    // Finalize the handle table when we're done, if the process isn't immortal.
    SCOPE_EXIT({
        if (!m_is_immortal) {
            this->FinalizeHandleTable();
        }
    });

    // Terminate child threads other than the current one.
    R_RETURN(TerminateChildren(m_kernel, this, GetCurrentThreadPointer(m_kernel)));
}

void KProcess::FinishTermination() {
    // Only allow termination to occur if the process isn't immortal.
    if (!m_is_immortal) {
        // Release resource limit hint.
        if (m_resource_limit != nullptr) {
            m_memory_release_hint = this->GetUsedNonSystemUserPhysicalMemorySize();
            m_resource_limit->Release(Svc::LimitableResource::PhysicalMemoryMax, 0,
                                      m_memory_release_hint);
        }

        // Change state.
        {
            KScopedSchedulerLock sl(m_kernel);
            this->ChangeState(State::Terminated);
        }

        // Close.
        this->Close();
    }
}

void KProcess::Exit() {
    // Determine whether we need to start terminating
    bool needs_terminate = false;
    {
        KScopedLightLock lk(m_state_lock);
        KScopedSchedulerLock sl(m_kernel);

        ASSERT(m_state != State::Created);
        ASSERT(m_state != State::CreatedAttached);
        ASSERT(m_state != State::Crashed);
        ASSERT(m_state != State::Terminated);
        if (m_state == State::Running || m_state == State::RunningAttached ||
            m_state == State::DebugBreak) {
            this->ChangeState(State::Terminating);
            needs_terminate = true;
        }
    }

    // If we need to start termination, do so.
    if (needs_terminate) {
        this->StartTermination();

        // Register the process as a work task.
        m_kernel.WorkerTaskManager().AddTask(m_kernel, KWorkerTaskManager::WorkerType::Exit, this);
    }

    // Exit the current thread.
    GetCurrentThread(m_kernel).Exit();
}

Result KProcess::Terminate() {
    // Determine whether we need to start terminating.
    bool needs_terminate = false;
    {
        KScopedLightLock lk(m_state_lock);

        // Check whether we're allowed to terminate.
        R_UNLESS(m_state != State::Created, ResultInvalidState);
        R_UNLESS(m_state != State::CreatedAttached, ResultInvalidState);

        KScopedSchedulerLock sl(m_kernel);

        if (m_state == State::Running || m_state == State::RunningAttached ||
            m_state == State::Crashed || m_state == State::DebugBreak) {
            this->ChangeState(State::Terminating);
            needs_terminate = true;
        }
    }

    // If we need to terminate, do so.
    if (needs_terminate) {
        // Start termination.
        if (R_SUCCEEDED(this->StartTermination())) {
            // Finish termination.
            this->FinishTermination();
        } else {
            // Register the process as a work task.
            m_kernel.WorkerTaskManager().AddTask(m_kernel, KWorkerTaskManager::WorkerType::Exit,
                                                 this);
        }
    }

    R_SUCCEED();
}

Result KProcess::AddSharedMemory(KSharedMemory* shmem, KProcessAddress address, size_t size) {
    // Lock ourselves, to prevent concurrent access.
    KScopedLightLock lk(m_state_lock);

    // Try to find an existing info for the memory.
    KSharedMemoryInfo* info = nullptr;
    for (auto it = m_shared_memory_list.begin(); it != m_shared_memory_list.end(); ++it) {
        if (it->GetSharedMemory() == shmem) {
            info = std::addressof(*it);
            break;
        }
    }

    // If we didn't find an info, create one.
    if (info == nullptr) {
        // Allocate a new info.
        info = KSharedMemoryInfo::Allocate(m_kernel);
        R_UNLESS(info != nullptr, ResultOutOfResource);

        // Initialize the info and add it to our list.
        info->Initialize(shmem);
        m_shared_memory_list.push_back(*info);
    }

    // Open a reference to the shared memory and its info.
    shmem->Open();
    info->Open();

    R_SUCCEED();
}

void KProcess::RemoveSharedMemory(KSharedMemory* shmem, KProcessAddress address, size_t size) {
    // Lock ourselves, to prevent concurrent access.
    KScopedLightLock lk(m_state_lock);

    // Find an existing info for the memory.
    KSharedMemoryInfo* info = nullptr;
    auto it = m_shared_memory_list.begin();
    for (; it != m_shared_memory_list.end(); ++it) {
        if (it->GetSharedMemory() == shmem) {
            info = std::addressof(*it);
            break;
        }
    }
    ASSERT(info != nullptr);

    // Close a reference to the info and its memory.
    if (info->Close()) {
        m_shared_memory_list.erase(it);
        KSharedMemoryInfo::Free(m_kernel, info);
    }

    shmem->Close();
}

Result KProcess::CreateThreadLocalRegion(KProcessAddress* out) {
    KThreadLocalPage* tlp = nullptr;
    KProcessAddress tlr = 0;

    // See if we can get a region from a partially used TLP.
    {
        KScopedSchedulerLock sl(m_kernel);

        if (auto it = m_partially_used_tlp_tree.begin(); it != m_partially_used_tlp_tree.end()) {
            tlr = it->Reserve();
            ASSERT(tlr != 0);

            if (it->IsAllUsed()) {
                tlp = std::addressof(*it);
                m_partially_used_tlp_tree.erase(it);
                m_fully_used_tlp_tree.insert(*tlp);
            }

            *out = tlr;
            R_SUCCEED();
        }
    }

    // Allocate a new page.
    tlp = KThreadLocalPage::Allocate(m_kernel);
    R_UNLESS(tlp != nullptr, ResultOutOfMemory);
    ON_RESULT_FAILURE {
        KThreadLocalPage::Free(m_kernel, tlp);
    };

    // Initialize the new page.
    R_TRY(tlp->Initialize(m_kernel, this));

    // Reserve a TLR.
    tlr = tlp->Reserve();
    ASSERT(tlr != 0);

    // Insert into our tree.
    {
        KScopedSchedulerLock sl(m_kernel);
        if (tlp->IsAllUsed()) {
            m_fully_used_tlp_tree.insert(*tlp);
        } else {
            m_partially_used_tlp_tree.insert(*tlp);
        }
    }

    // We succeeded!
    *out = tlr;
    R_SUCCEED();
}

Result KProcess::DeleteThreadLocalRegion(KProcessAddress addr) {
    KThreadLocalPage* page_to_free = nullptr;

    // Release the region.
    {
        KScopedSchedulerLock sl(m_kernel);

        // Try to find the page in the partially used list.
        auto it = m_partially_used_tlp_tree.find_key(Common::AlignDown(GetInteger(addr), PageSize));
        if (it == m_partially_used_tlp_tree.end()) {
            // If we don't find it, it has to be in the fully used list.
            it = m_fully_used_tlp_tree.find_key(Common::AlignDown(GetInteger(addr), PageSize));
            R_UNLESS(it != m_fully_used_tlp_tree.end(), ResultInvalidAddress);

            // Release the region.
            it->Release(addr);

            // Move the page out of the fully used list.
            KThreadLocalPage* tlp = std::addressof(*it);
            m_fully_used_tlp_tree.erase(it);
            if (tlp->IsAllFree()) {
                page_to_free = tlp;
            } else {
                m_partially_used_tlp_tree.insert(*tlp);
            }
        } else {
            // Release the region.
            it->Release(addr);

            // Handle the all-free case.
            KThreadLocalPage* tlp = std::addressof(*it);
            if (tlp->IsAllFree()) {
                m_partially_used_tlp_tree.erase(it);
                page_to_free = tlp;
            }
        }
    }

    // If we should free the page it was in, do so.
    if (page_to_free != nullptr) {
        page_to_free->Finalize();

        KThreadLocalPage::Free(m_kernel, page_to_free);
    }

    R_SUCCEED();
}

bool KProcess::ReserveResource(Svc::LimitableResource which, s64 value) {
    if (KResourceLimit* rl = this->GetResourceLimit(); rl != nullptr) {
        return rl->Reserve(which, value);
    } else {
        return true;
    }
}

bool KProcess::ReserveResource(Svc::LimitableResource which, s64 value, s64 timeout) {
    if (KResourceLimit* rl = this->GetResourceLimit(); rl != nullptr) {
        return rl->Reserve(which, value, timeout);
    } else {
        return true;
    }
}

void KProcess::ReleaseResource(Svc::LimitableResource which, s64 value) {
    if (KResourceLimit* rl = this->GetResourceLimit(); rl != nullptr) {
        rl->Release(which, value);
    }
}

void KProcess::ReleaseResource(Svc::LimitableResource which, s64 value, s64 hint) {
    if (KResourceLimit* rl = this->GetResourceLimit(); rl != nullptr) {
        rl->Release(which, value, hint);
    }
}

void KProcess::IncrementRunningThreadCount() {
    ASSERT(m_num_running_threads.load() >= 0);

    ++m_num_running_threads;
}

void KProcess::DecrementRunningThreadCount() {
    ASSERT(m_num_running_threads.load() > 0);

    if (const auto prev = m_num_running_threads--; prev == 1) {
        this->Terminate();
    }
}

bool KProcess::EnterUserException() {
    // Get the current thread.
    KThread* cur_thread = GetCurrentThreadPointer(m_kernel);
    ASSERT(this == cur_thread->GetOwnerProcess());

    // Check that we haven't already claimed the exception thread.
    if (m_exception_thread == cur_thread) {
        return false;
    }

    // Create the wait queue we'll be using.
    ThreadQueueImplForKProcessEnterUserException wait_queue(m_kernel,
                                                            std::addressof(m_exception_thread));

    // Claim the exception thread.
    {
        // Lock the scheduler.
        KScopedSchedulerLock sl(m_kernel);

        // Check that we're not terminating.
        if (cur_thread->IsTerminationRequested()) {
            return false;
        }

        // If we don't have an exception thread, we can just claim it directly.
        if (m_exception_thread == nullptr) {
            m_exception_thread = cur_thread;
            KScheduler::SetSchedulerUpdateNeeded(m_kernel);
            return true;
        }

        // Otherwise, we need to wait until we don't have an exception thread.

        // Add the current thread as a waiter on the current exception thread.
        cur_thread->SetKernelAddressKey(
            reinterpret_cast<uintptr_t>(std::addressof(m_exception_thread)) | 1);
        m_exception_thread->AddWaiter(cur_thread);

        // Wait to claim the exception thread.
        cur_thread->BeginWait(std::addressof(wait_queue));
    }

    // If our wait didn't end due to thread termination, we succeeded.
    return ResultTerminationRequested != cur_thread->GetWaitResult();
}

bool KProcess::LeaveUserException() {
    return this->ReleaseUserException(GetCurrentThreadPointer(m_kernel));
}

bool KProcess::ReleaseUserException(KThread* thread) {
    KScopedSchedulerLock sl(m_kernel);

    if (m_exception_thread == thread) {
        m_exception_thread = nullptr;

        // Remove waiter thread.
        bool has_waiters;
        if (KThread* next = thread->RemoveKernelWaiterByKey(
                std::addressof(has_waiters),
                reinterpret_cast<uintptr_t>(std::addressof(m_exception_thread)) | 1);
            next != nullptr) {
            next->EndWait(ResultSuccess);
        }

        KScheduler::SetSchedulerUpdateNeeded(m_kernel);

        return true;
    } else {
        return false;
    }
}

void KProcess::RegisterThread(KThread* thread) {
    KScopedLightLock lk(m_list_lock);

    m_thread_list.push_back(*thread);
}

void KProcess::UnregisterThread(KThread* thread) {
    KScopedLightLock lk(m_list_lock);

    m_thread_list.erase(m_thread_list.iterator_to(*thread));
}

size_t KProcess::GetUsedUserPhysicalMemorySize() const {
    const size_t norm_size = m_page_table.GetNormalMemorySize();
    const size_t other_size = m_code_size + m_main_thread_stack_size;
    const size_t sec_size = this->GetRequiredSecureMemorySizeNonDefault();

    return norm_size + other_size + sec_size;
}

size_t KProcess::GetTotalUserPhysicalMemorySize() const {
    // Get the amount of free and used size.
    const size_t free_size =
        m_resource_limit->GetFreeValue(Svc::LimitableResource::PhysicalMemoryMax);
    const size_t max_size = m_max_process_memory;

    // Determine used size.
    // NOTE: This does *not* check this->IsDefaultApplicationSystemResource(), unlike
    // GetUsedUserPhysicalMemorySize().
    const size_t norm_size = m_page_table.GetNormalMemorySize();
    const size_t other_size = m_code_size + m_main_thread_stack_size;
    const size_t sec_size = this->GetRequiredSecureMemorySize();
    const size_t used_size = norm_size + other_size + sec_size;

    // NOTE: These function calls will recalculate, introducing a race...it is unclear why Nintendo
    // does it this way.
    if (used_size + free_size > max_size) {
        return max_size;
    } else {
        return free_size + this->GetUsedUserPhysicalMemorySize();
    }
}

size_t KProcess::GetUsedNonSystemUserPhysicalMemorySize() const {
    const size_t norm_size = m_page_table.GetNormalMemorySize();
    const size_t other_size = m_code_size + m_main_thread_stack_size;

    return norm_size + other_size;
}

size_t KProcess::GetTotalNonSystemUserPhysicalMemorySize() const {
    // Get the amount of free and used size.
    const size_t free_size =
        m_resource_limit->GetFreeValue(Svc::LimitableResource::PhysicalMemoryMax);
    const size_t max_size = m_max_process_memory;

    // Determine used size.
    // NOTE: This does *not* check this->IsDefaultApplicationSystemResource(), unlike
    // GetUsedUserPhysicalMemorySize().
    const size_t norm_size = m_page_table.GetNormalMemorySize();
    const size_t other_size = m_code_size + m_main_thread_stack_size;
    const size_t sec_size = this->GetRequiredSecureMemorySize();
    const size_t used_size = norm_size + other_size + sec_size;

    // NOTE: These function calls will recalculate, introducing a race...it is unclear why Nintendo
    // does it this way.
    if (used_size + free_size > max_size) {
        return max_size - this->GetRequiredSecureMemorySizeNonDefault();
    } else {
        return free_size + this->GetUsedNonSystemUserPhysicalMemorySize();
    }
}

Result KProcess::Run(s32 priority, size_t stack_size) {
    // Lock ourselves, to prevent concurrent access.
    KScopedLightLock lk(m_state_lock);

    // Validate that we're in a state where we can initialize.
    const auto state = m_state;
    R_UNLESS(state == State::Created || state == State::CreatedAttached, ResultInvalidState);

    // Place a tentative reservation of a thread for this process.
    KScopedResourceReservation thread_reservation(this, Svc::LimitableResource::ThreadCountMax);
    R_UNLESS(thread_reservation.Succeeded(), ResultLimitReached);

    // Ensure that we haven't already allocated stack.
    ASSERT(m_main_thread_stack_size == 0);

    // Ensure that we're allocating a valid stack.
    stack_size = Common::AlignUp(stack_size, PageSize);
    R_UNLESS(stack_size + m_code_size <= m_max_process_memory, ResultOutOfMemory);
    R_UNLESS(stack_size + m_code_size >= m_code_size, ResultOutOfMemory);

    // Place a tentative reservation of memory for our new stack.
    KScopedResourceReservation mem_reservation(this, Svc::LimitableResource::PhysicalMemoryMax,
                                               stack_size);
    R_UNLESS(mem_reservation.Succeeded(), ResultLimitReached);

    // Allocate and map our stack.
    KProcessAddress stack_top = 0;
    if (stack_size) {
        KProcessAddress stack_bottom;
        R_TRY(m_page_table.MapPages(std::addressof(stack_bottom), stack_size / PageSize,
                                    KMemoryState::Stack, KMemoryPermission::UserReadWrite));

        stack_top = stack_bottom + stack_size;
        m_main_thread_stack_size = stack_size;
    }

    // Ensure our stack is safe to clean up on exit.
    ON_RESULT_FAILURE {
        if (m_main_thread_stack_size) {
            ASSERT(R_SUCCEEDED(m_page_table.UnmapPages(stack_top - m_main_thread_stack_size,
                                                       m_main_thread_stack_size / PageSize,
                                                       KMemoryState::Stack)));
            m_main_thread_stack_size = 0;
        }
    };

    // Set our maximum heap size.
    R_TRY(m_page_table.SetMaxHeapSize(m_max_process_memory -
                                      (m_main_thread_stack_size + m_code_size)));

    // Initialize our handle table.
    R_TRY(this->InitializeHandleTable(m_capabilities.GetHandleTableSize()));
    ON_RESULT_FAILURE_2 {
        this->FinalizeHandleTable();
    };

    // Create a new thread for the process.
    KThread* main_thread = KThread::Create(m_kernel);
    R_UNLESS(main_thread != nullptr, ResultOutOfResource);
    SCOPE_EXIT({ main_thread->Close(); });

    // Initialize the thread.
    R_TRY(KThread::InitializeUserThread(m_kernel.System(), main_thread, this->GetEntryPoint(), 0,
                                        stack_top, priority, m_ideal_core_id, this));

    // Register the thread, and commit our reservation.
    KThread::Register(m_kernel, main_thread);
    thread_reservation.Commit();

    // Add the thread to our handle table.
    Handle thread_handle;
    R_TRY(m_handle_table.Add(std::addressof(thread_handle), main_thread));

    // Set the thread arguments.
    main_thread->GetContext32().cpu_registers[0] = 0;
    main_thread->GetContext64().cpu_registers[0] = 0;
    main_thread->GetContext32().cpu_registers[1] = thread_handle;
    main_thread->GetContext64().cpu_registers[1] = thread_handle;

    // Update our state.
    this->ChangeState((state == State::Created) ? State::Running : State::RunningAttached);
    ON_RESULT_FAILURE_2 {
        this->ChangeState(state);
    };

    // Suspend for debug, if we should.
    if (m_kernel.System().DebuggerEnabled()) {
        main_thread->RequestSuspend(SuspendType::Debug);
    }

    // Run our thread.
    R_TRY(main_thread->Run());

    // Open a reference to represent that we're running.
    this->Open();

    // We succeeded! Commit our memory reservation.
    mem_reservation.Commit();

    R_SUCCEED();
}

Result KProcess::Reset() {
    // Lock the process and the scheduler.
    KScopedLightLock lk(m_state_lock);
    KScopedSchedulerLock sl(m_kernel);

    // Validate that we're in a state that we can reset.
    R_UNLESS(m_state != State::Terminated, ResultInvalidState);
    R_UNLESS(m_is_signaled, ResultInvalidState);

    // Clear signaled.
    m_is_signaled = false;
    R_SUCCEED();
}

Result KProcess::SetActivity(Svc::ProcessActivity activity) {
    // Lock ourselves and the scheduler.
    KScopedLightLock lk(m_state_lock);
    KScopedLightLock list_lk(m_list_lock);
    KScopedSchedulerLock sl(m_kernel);

    // Validate our state.
    R_UNLESS(m_state != State::Terminating, ResultInvalidState);
    R_UNLESS(m_state != State::Terminated, ResultInvalidState);

    // Either pause or resume.
    if (activity == Svc::ProcessActivity::Paused) {
        // Verify that we're not suspended.
        R_UNLESS(!m_is_suspended, ResultInvalidState);

        // Suspend all threads.
        auto end = this->GetThreadList().end();
        for (auto it = this->GetThreadList().begin(); it != end; ++it) {
            it->RequestSuspend(SuspendType::Process);
        }

        // Set ourselves as suspended.
        this->SetSuspended(true);
    } else {
        ASSERT(activity == Svc::ProcessActivity::Runnable);

        // Verify that we're suspended.
        R_UNLESS(m_is_suspended, ResultInvalidState);

        // Resume all threads.
        auto end = this->GetThreadList().end();
        for (auto it = this->GetThreadList().begin(); it != end; ++it) {
            it->Resume(SuspendType::Process);
        }

        // Set ourselves as resumed.
        this->SetSuspended(false);
    }

    R_SUCCEED();
}

void KProcess::PinCurrentThread() {
    ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));

    // Get the current thread.
    const s32 core_id = GetCurrentCoreId(m_kernel);
    KThread* cur_thread = GetCurrentThreadPointer(m_kernel);

    // If the thread isn't terminated, pin it.
    if (!cur_thread->IsTerminationRequested()) {
        // Pin it.
        this->PinThread(core_id, cur_thread);
        cur_thread->Pin(core_id);

        // An update is needed.
        KScheduler::SetSchedulerUpdateNeeded(m_kernel);
    }
}

void KProcess::UnpinCurrentThread() {
    ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));

    // Get the current thread.
    const s32 core_id = GetCurrentCoreId(m_kernel);
    KThread* cur_thread = GetCurrentThreadPointer(m_kernel);

    // Unpin it.
    cur_thread->Unpin();
    this->UnpinThread(core_id, cur_thread);

    // An update is needed.
    KScheduler::SetSchedulerUpdateNeeded(m_kernel);
}

void KProcess::UnpinThread(KThread* thread) {
    ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));

    // Get the thread's core id.
    const auto core_id = thread->GetActiveCore();

    // Unpin it.
    this->UnpinThread(core_id, thread);
    thread->Unpin();

    // An update is needed.
    KScheduler::SetSchedulerUpdateNeeded(m_kernel);
}

Result KProcess::GetThreadList(s32* out_num_threads, KProcessAddress out_thread_ids,
                               s32 max_out_count) {
    // TODO: use current memory reference
    auto& memory = m_kernel.System().ApplicationMemory();

    // Lock the list.
    KScopedLightLock lk(m_list_lock);

    // Iterate over the list.
    s32 count = 0;
    auto end = this->GetThreadList().end();
    for (auto it = this->GetThreadList().begin(); it != end; ++it) {
        // If we're within array bounds, write the id.
        if (count < max_out_count) {
            // Get the thread id.
            KThread* thread = std::addressof(*it);
            const u64 id = thread->GetId();

            // Copy the id to userland.
            memory.Write64(out_thread_ids + count * sizeof(u64), id);
        }

        // Increment the count.
        ++count;
    }

    // We successfully iterated the list.
    *out_num_threads = count;
    R_SUCCEED();
}

void KProcess::Switch(KProcess* cur_process, KProcess* next_process) {}

KProcess::KProcess(KernelCore& kernel)
    : KAutoObjectWithSlabHeapAndContainer(kernel), m_page_table{kernel.System()},
      m_state_lock{kernel}, m_list_lock{kernel}, m_cond_var{kernel.System()},
      m_address_arbiter{kernel.System()}, m_handle_table{kernel} {}
KProcess::~KProcess() = default;

Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,
                                  bool is_hbl) {
    // Create a resource limit for the process.
    const auto physical_memory_size =
        m_kernel.MemoryManager().GetSize(Kernel::KMemoryManager::Pool::Application);
    auto* res_limit =
        Kernel::CreateResourceLimitForProcess(m_kernel.System(), physical_memory_size);

    // Ensure we maintain a clean state on exit.
    SCOPE_EXIT({ res_limit->Close(); });

    // Declare flags and code address.
    Svc::CreateProcessFlag flag{};
    u64 code_address{};

    // We are an application.
    flag |= Svc::CreateProcessFlag::IsApplication;

    // If we are 64-bit, create as such.
    if (metadata.Is64BitProgram()) {
        flag |= Svc::CreateProcessFlag::Is64Bit;
    }

    // Set the address space type and code address.
    switch (metadata.GetAddressSpaceType()) {
    case FileSys::ProgramAddressSpaceType::Is39Bit:
        flag |= Svc::CreateProcessFlag::AddressSpace64Bit;

        // For 39-bit processes, the ASLR region starts at 0x800'0000 and is ~512GiB large.
        // However, some (buggy) programs/libraries like skyline incorrectly depend on the
        // existence of ASLR pages before the entry point, so we will adjust the load address
        // to point to about 2GiB into the ASLR region.
        code_address = 0x8000'0000;
        break;
    case FileSys::ProgramAddressSpaceType::Is36Bit:
        flag |= Svc::CreateProcessFlag::AddressSpace64BitDeprecated;
        code_address = 0x800'0000;
        break;
    case FileSys::ProgramAddressSpaceType::Is32Bit:
        flag |= Svc::CreateProcessFlag::AddressSpace32Bit;
        code_address = 0x20'0000;
        break;
    case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
        flag |= Svc::CreateProcessFlag::AddressSpace32BitWithoutAlias;
        code_address = 0x20'0000;
        break;
    }

    Svc::CreateProcessParameter params{
        .name = {},
        .version = {},
        .program_id = metadata.GetTitleID(),
        .code_address = code_address,
        .code_num_pages = static_cast<s32>(code_size / PageSize),
        .flags = flag,
        .reslimit = Svc::InvalidHandle,
        .system_resource_num_pages = static_cast<s32>(metadata.GetSystemResourceSize() / PageSize),
    };

    // Set the process name.
    const auto& name = metadata.GetName();
    static_assert(sizeof(params.name) <= sizeof(name));
    std::memcpy(params.name.data(), name.data(), sizeof(params.name));

    // Initialize for application process.
    R_TRY(this->Initialize(params, metadata.GetKernelCapabilities(), res_limit,
                           KMemoryManager::Pool::Application));

    // Assign remaining properties.
    m_is_hbl = is_hbl;
    m_ideal_core_id = metadata.GetMainThreadCore();

    // We succeeded.
    R_SUCCEED();
}

void KProcess::LoadModule(CodeSet code_set, KProcessAddress base_addr) {
    const auto ReprotectSegment = [&](const CodeSet::Segment& segment,
                                      Svc::MemoryPermission permission) {
        m_page_table.SetProcessMemoryPermission(segment.addr + base_addr, segment.size, permission);
    };

    this->GetMemory().WriteBlock(base_addr, code_set.memory.data(), code_set.memory.size());

    ReprotectSegment(code_set.CodeSegment(), Svc::MemoryPermission::ReadExecute);
    ReprotectSegment(code_set.RODataSegment(), Svc::MemoryPermission::Read);
    ReprotectSegment(code_set.DataSegment(), Svc::MemoryPermission::ReadWrite);
}

bool KProcess::InsertWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type) {
    const auto watch{std::find_if(m_watchpoints.begin(), m_watchpoints.end(), [&](const auto& wp) {
        return wp.type == DebugWatchpointType::None;
    })};

    if (watch == m_watchpoints.end()) {
        return false;
    }

    watch->start_address = addr;
    watch->end_address = addr + size;
    watch->type = type;

    for (KProcessAddress page = Common::AlignDown(GetInteger(addr), PageSize); page < addr + size;
         page += PageSize) {
        m_debug_page_refcounts[page]++;
        this->GetMemory().MarkRegionDebug(page, PageSize, true);
    }

    return true;
}

bool KProcess::RemoveWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type) {
    const auto watch{std::find_if(m_watchpoints.begin(), m_watchpoints.end(), [&](const auto& wp) {
        return wp.start_address == addr && wp.end_address == addr + size && wp.type == type;
    })};

    if (watch == m_watchpoints.end()) {
        return false;
    }

    watch->start_address = 0;
    watch->end_address = 0;
    watch->type = DebugWatchpointType::None;

    for (KProcessAddress page = Common::AlignDown(GetInteger(addr), PageSize); page < addr + size;
         page += PageSize) {
        m_debug_page_refcounts[page]--;
        if (!m_debug_page_refcounts[page]) {
            this->GetMemory().MarkRegionDebug(page, PageSize, false);
        }
    }

    return true;
}

Core::Memory::Memory& KProcess::GetMemory() const {
    // TODO: per-process memory
    return m_kernel.System().ApplicationMemory();
}

} // namespace Kernel
