chore: make yuzu REUSE compliant
[REUSE] is a specification that aims at making file copyright
information consistent, so that it can be both human and machine
readable. It basically requires that all files have a header containing
copyright and licensing information. When this isn't possible, like
when dealing with binary assets, generated files or embedded third-party
dependencies, it is permitted to insert copyright information in the
`.reuse/dep5` file.
Oh, and it also requires that all the licenses used in the project are
present in the `LICENSES` folder, that's why the diff is so huge.
This can be done automatically with `reuse download --all`.
The `reuse` tool also contains a handy subcommand that analyzes the
project and tells whether or not the project is (still) compliant,
`reuse lint`.
Following REUSE has a few advantages over the current approach:
- Copyright information is easy to access for users / downstream
- Files like `dist/license.md` do not need to exist anymore, as
`.reuse/dep5` is used instead
- `reuse lint` makes it easy to ensure that copyright information of
files like binary assets / images is always accurate and up to date
To add copyright information of files that didn't have it I looked up
who committed what and when, for each file. As yuzu contributors do not
have to sign a CLA or similar I couldn't assume that copyright ownership
was of the "yuzu Emulator Project", so I used the name and/or email of
the commit author instead.
[REUSE]: https://reuse.software
Follow-up to 01cf05bc75b1e47beb08937439f3ed9339e7b254
2022-05-14 20:06:02 -04:00
|
|
|
// SPDX-FileCopyrightText: 2015 Citra Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2015-05-03 23:01:16 -04:00
|
|
|
|
2018-01-01 14:38:34 -05:00
|
|
|
#include <algorithm>
|
2019-06-05 14:32:33 -04:00
|
|
|
#include <bitset>
|
2020-10-29 03:17:20 -04:00
|
|
|
#include <ctime>
|
2016-04-05 08:29:55 -04:00
|
|
|
#include <memory>
|
2018-11-20 17:46:17 -05:00
|
|
|
#include <random>
|
2019-03-28 18:24:56 -04:00
|
|
|
#include "common/alignment.h"
|
2015-05-03 23:01:16 -04:00
|
|
|
#include "common/assert.h"
|
2015-05-08 15:51:48 -04:00
|
|
|
#include "common/logging/log.h"
|
2021-06-28 19:58:40 -04:00
|
|
|
#include "common/scope_exit.h"
|
2021-04-14 19:07:40 -04:00
|
|
|
#include "common/settings.h"
|
2018-09-21 02:06:47 -04:00
|
|
|
#include "core/core.h"
|
2018-09-22 20:09:32 -04:00
|
|
|
#include "core/file_sys/program_metadata.h"
|
2019-03-20 12:40:09 -04:00
|
|
|
#include "core/hle/kernel/code_set.h"
|
2021-02-12 20:02:51 -05:00
|
|
|
#include "core/hle/kernel/k_memory_block_manager.h"
|
2021-02-12 20:58:31 -05:00
|
|
|
#include "core/hle/kernel/k_page_table.h"
|
2021-04-24 01:04:28 -04:00
|
|
|
#include "core/hle/kernel/k_process.h"
|
2021-01-30 04:40:49 -05:00
|
|
|
#include "core/hle/kernel/k_resource_limit.h"
|
2020-12-02 21:08:35 -05:00
|
|
|
#include "core/hle/kernel/k_scheduler.h"
|
2021-02-04 20:06:54 -05:00
|
|
|
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
2021-04-30 17:53:22 -04:00
|
|
|
#include "core/hle/kernel/k_shared_memory.h"
|
2021-09-25 11:01:53 -04:00
|
|
|
#include "core/hle/kernel/k_shared_memory_info.h"
|
2020-12-31 02:01:08 -05:00
|
|
|
#include "core/hle/kernel/k_thread.h"
|
2018-08-28 12:30:33 -04:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2021-01-31 19:55:11 -05:00
|
|
|
#include "core/hle/kernel/svc_results.h"
|
2015-05-12 21:38:29 -04:00
|
|
|
#include "core/memory.h"
|
2015-05-03 23:01:16 -04:00
|
|
|
|
|
|
|
namespace Kernel {
|
2018-12-27 20:28:15 -05:00
|
|
|
namespace {
|
|
|
|
/**
|
|
|
|
* Sets up the primary application thread
|
|
|
|
*
|
2020-02-24 21:04:12 -05:00
|
|
|
* @param system The system instance to create the main thread under.
|
2018-12-27 20:28:15 -05:00
|
|
|
* @param owner_process The parent process for the main thread
|
|
|
|
* @param priority The priority to give the main thread
|
|
|
|
*/
|
2023-03-17 21:26:04 -04:00
|
|
|
void SetupMainThread(Core::System& system, KProcess& owner_process, u32 priority,
|
|
|
|
KProcessAddress stack_top) {
|
|
|
|
const KProcessAddress entry_point = owner_process.PageTable().GetCodeRegionStart();
|
2022-11-03 10:22:05 -04:00
|
|
|
ASSERT(owner_process.GetResourceLimit()->Reserve(LimitableResource::ThreadCountMax, 1));
|
2018-12-27 20:28:15 -05:00
|
|
|
|
2021-04-10 01:42:23 -04:00
|
|
|
KThread* thread = KThread::Create(system.Kernel());
|
2021-06-28 19:58:40 -04:00
|
|
|
SCOPE_EXIT({ thread->Close(); });
|
|
|
|
|
2021-04-03 22:11:46 -04:00
|
|
|
ASSERT(KThread::InitializeUserThread(system, thread, entry_point, 0, stack_top, priority,
|
2023-03-07 12:01:07 -05:00
|
|
|
owner_process.GetIdealCoreId(),
|
|
|
|
std::addressof(owner_process))
|
2021-04-03 22:11:46 -04:00
|
|
|
.IsSuccess());
|
2018-12-27 20:28:15 -05:00
|
|
|
|
|
|
|
// Register 1 must be a handle to the main thread
|
2021-04-03 22:11:46 -04:00
|
|
|
Handle thread_handle{};
|
2023-03-07 12:01:07 -05:00
|
|
|
owner_process.GetHandleTable().Add(std::addressof(thread_handle), thread);
|
2021-04-04 01:22:36 -04:00
|
|
|
|
2020-03-20 22:39:07 -04:00
|
|
|
thread->GetContext32().cpu_registers[0] = 0;
|
|
|
|
thread->GetContext64().cpu_registers[0] = 0;
|
2020-03-01 23:46:10 -05:00
|
|
|
thread->GetContext32().cpu_registers[1] = thread_handle;
|
|
|
|
thread->GetContext64().cpu_registers[1] = thread_handle;
|
2018-12-27 20:28:15 -05:00
|
|
|
|
2022-06-15 20:53:49 -04:00
|
|
|
if (system.DebuggerEnabled()) {
|
|
|
|
thread->RequestSuspend(SuspendType::Debug);
|
2020-02-24 21:04:12 -05:00
|
|
|
}
|
2022-06-15 20:53:49 -04:00
|
|
|
|
|
|
|
// Run our thread.
|
|
|
|
void(thread->Run());
|
2018-12-27 20:28:15 -05:00
|
|
|
}
|
|
|
|
} // Anonymous namespace
|
2015-05-03 23:01:16 -04:00
|
|
|
|
2022-06-25 23:44:19 -04:00
|
|
|
Result KProcess::Initialize(KProcess* process, Core::System& system, std::string process_name,
|
|
|
|
ProcessType type, KResourceLimit* res_limit) {
|
2019-03-07 18:48:14 -05:00
|
|
|
auto& kernel = system.Kernel();
|
2015-05-03 23:01:16 -04:00
|
|
|
|
2021-05-08 12:11:36 -04:00
|
|
|
process->name = std::move(process_name);
|
2023-03-07 16:45:13 -05:00
|
|
|
process->m_resource_limit = res_limit;
|
|
|
|
process->m_system_resource_address = 0;
|
|
|
|
process->m_state = State::Created;
|
|
|
|
process->m_program_id = 0;
|
|
|
|
process->m_process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()
|
|
|
|
: kernel.CreateNewUserProcessID();
|
|
|
|
process->m_capabilities.InitializeForMetadatalessProcess();
|
|
|
|
process->m_is_initialized = true;
|
2015-05-08 16:53:19 -04:00
|
|
|
|
2020-10-26 21:42:11 -04:00
|
|
|
std::mt19937 rng(Settings::values.rng_seed.GetValue().value_or(std::time(nullptr)));
|
2018-11-13 12:25:43 -05:00
|
|
|
std::uniform_int_distribution<u64> distribution;
|
2023-03-07 16:45:13 -05:00
|
|
|
std::generate(process->m_random_entropy.begin(), process->m_random_entropy.end(),
|
2018-11-13 12:25:43 -05:00
|
|
|
[&] { return distribution(rng); });
|
|
|
|
|
2018-08-28 12:30:33 -04:00
|
|
|
kernel.AppendNewProcess(process);
|
2021-04-04 01:22:36 -04:00
|
|
|
|
2022-01-23 00:09:45 -05:00
|
|
|
// Clear remaining fields.
|
2023-03-07 16:45:13 -05:00
|
|
|
process->m_num_running_threads = 0;
|
|
|
|
process->m_is_signaled = false;
|
|
|
|
process->m_exception_thread = nullptr;
|
|
|
|
process->m_is_suspended = false;
|
|
|
|
process->m_schedule_count = 0;
|
|
|
|
process->m_is_handle_table_initialized = false;
|
2022-01-23 00:09:45 -05:00
|
|
|
|
2022-02-21 15:33:17 -05:00
|
|
|
// Open a reference to the resource limit.
|
2023-03-07 16:45:13 -05:00
|
|
|
process->m_resource_limit->Open();
|
2022-02-21 15:33:17 -05:00
|
|
|
|
2022-10-15 01:55:51 -04:00
|
|
|
R_SUCCEED();
|
2015-05-03 23:01:16 -04:00
|
|
|
}
|
|
|
|
|
2022-01-14 19:33:24 -05:00
|
|
|
void KProcess::DoWorkerTaskImpl() {
|
|
|
|
UNIMPLEMENTED();
|
|
|
|
}
|
|
|
|
|
2021-04-24 01:04:28 -04:00
|
|
|
KResourceLimit* KProcess::GetResourceLimit() const {
|
2023-03-07 16:45:13 -05:00
|
|
|
return m_resource_limit;
|
2018-12-04 00:29:15 -05:00
|
|
|
}
|
|
|
|
|
2022-01-23 00:09:45 -05:00
|
|
|
void KProcess::IncrementRunningThreadCount() {
|
2023-03-07 16:45:13 -05:00
|
|
|
ASSERT(m_num_running_threads.load() >= 0);
|
|
|
|
++m_num_running_threads;
|
2021-01-20 16:42:27 -05:00
|
|
|
}
|
|
|
|
|
2022-01-23 00:09:45 -05:00
|
|
|
void KProcess::DecrementRunningThreadCount() {
|
2023-03-07 16:45:13 -05:00
|
|
|
ASSERT(m_num_running_threads.load() > 0);
|
2021-01-20 16:42:27 -05:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
if (const auto prev = m_num_running_threads--; prev == 1) {
|
2022-01-23 00:09:45 -05:00
|
|
|
// TODO(bunnei): Process termination to be implemented when multiprocess is supported.
|
2021-01-20 16:42:27 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-02 17:26:30 -04:00
|
|
|
u64 KProcess::GetTotalPhysicalMemoryAvailable() {
|
2023-03-07 16:45:13 -05:00
|
|
|
const u64 capacity{m_resource_limit->GetFreeValue(LimitableResource::PhysicalMemoryMax) +
|
|
|
|
m_page_table.GetNormalMemorySize() + GetSystemResourceSize() + m_image_size +
|
|
|
|
m_main_thread_stack_size};
|
2023-03-07 10:49:41 -05:00
|
|
|
if (const auto pool_size = m_kernel.MemoryManager().GetSize(KMemoryManager::Pool::Application);
|
2021-04-21 00:28:11 -04:00
|
|
|
capacity != pool_size) {
|
|
|
|
LOG_WARNING(Kernel, "capacity {} != application pool size {}", capacity, pool_size);
|
|
|
|
}
|
2023-03-07 16:45:13 -05:00
|
|
|
if (capacity < m_memory_usage_capacity) {
|
2020-04-08 22:19:12 -04:00
|
|
|
return capacity;
|
|
|
|
}
|
2023-03-07 16:45:13 -05:00
|
|
|
return m_memory_usage_capacity;
|
2019-06-09 18:20:20 -04:00
|
|
|
}
|
|
|
|
|
2022-10-02 17:26:30 -04:00
|
|
|
u64 KProcess::GetTotalPhysicalMemoryAvailableWithoutSystemResource() {
|
2023-03-11 10:38:33 -05:00
|
|
|
return this->GetTotalPhysicalMemoryAvailable() - this->GetSystemResourceSize();
|
2019-06-09 18:20:20 -04:00
|
|
|
}
|
|
|
|
|
2022-10-02 17:26:30 -04:00
|
|
|
u64 KProcess::GetTotalPhysicalMemoryUsed() {
|
2023-03-07 16:45:13 -05:00
|
|
|
return m_image_size + m_main_thread_stack_size + m_page_table.GetNormalMemorySize() +
|
2023-03-11 10:38:33 -05:00
|
|
|
this->GetSystemResourceSize();
|
2019-03-28 22:59:17 -04:00
|
|
|
}
|
|
|
|
|
2022-10-02 17:26:30 -04:00
|
|
|
u64 KProcess::GetTotalPhysicalMemoryUsedWithoutSystemResource() {
|
2023-03-11 10:38:33 -05:00
|
|
|
return this->GetTotalPhysicalMemoryUsed() - this->GetSystemResourceUsage();
|
2019-06-09 18:20:20 -04:00
|
|
|
}
|
|
|
|
|
2021-04-24 01:04:28 -04:00
|
|
|
bool KProcess::ReleaseUserException(KThread* thread) {
|
2023-03-07 10:49:41 -05:00
|
|
|
KScopedSchedulerLock sl{m_kernel};
|
2021-01-20 16:42:27 -05:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
if (m_exception_thread == thread) {
|
|
|
|
m_exception_thread = nullptr;
|
2021-01-20 16:42:27 -05:00
|
|
|
|
|
|
|
// Remove waiter thread.
|
2023-02-23 15:49:42 -05:00
|
|
|
bool has_waiters{};
|
2023-02-23 20:32:03 -05:00
|
|
|
if (KThread* next = thread->RemoveKernelWaiterByKey(
|
2023-02-23 15:49:42 -05:00
|
|
|
std::addressof(has_waiters),
|
2023-03-07 16:45:13 -05:00
|
|
|
reinterpret_cast<uintptr_t>(std::addressof(m_exception_thread)));
|
2021-06-10 14:26:54 -04:00
|
|
|
next != nullptr) {
|
2022-06-25 13:36:14 -04:00
|
|
|
next->EndWait(ResultSuccess);
|
2021-01-20 16:42:27 -05:00
|
|
|
}
|
|
|
|
|
2023-03-07 10:49:41 -05:00
|
|
|
KScheduler::SetSchedulerUpdateNeeded(m_kernel);
|
2021-06-10 14:26:54 -04:00
|
|
|
|
2021-01-20 16:42:27 -05:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-30 00:40:38 -05:00
|
|
|
void KProcess::PinCurrentThread(s32 core_id) {
|
2023-03-07 16:45:13 -05:00
|
|
|
ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));
|
2021-01-20 16:42:27 -05:00
|
|
|
|
|
|
|
// Get the current thread.
|
2022-06-16 10:35:52 -04:00
|
|
|
KThread* cur_thread =
|
2023-03-07 10:49:41 -05:00
|
|
|
m_kernel.Scheduler(static_cast<std::size_t>(core_id)).GetSchedulerCurrentThread();
|
2021-01-20 16:42:27 -05:00
|
|
|
|
2021-11-11 02:02:45 -05:00
|
|
|
// If the thread isn't terminated, pin it.
|
|
|
|
if (!cur_thread->IsTerminationRequested()) {
|
|
|
|
// Pin it.
|
2023-03-11 10:38:33 -05:00
|
|
|
this->PinThread(core_id, cur_thread);
|
2021-12-30 00:40:38 -05:00
|
|
|
cur_thread->Pin(core_id);
|
2021-01-20 16:42:27 -05:00
|
|
|
|
2021-11-11 02:02:45 -05:00
|
|
|
// An update is needed.
|
2023-03-07 10:49:41 -05:00
|
|
|
KScheduler::SetSchedulerUpdateNeeded(m_kernel);
|
2021-11-11 02:02:45 -05:00
|
|
|
}
|
2021-01-20 16:42:27 -05:00
|
|
|
}
|
|
|
|
|
2021-12-30 00:40:38 -05:00
|
|
|
void KProcess::UnpinCurrentThread(s32 core_id) {
|
2023-03-07 16:45:13 -05:00
|
|
|
ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));
|
2021-01-20 16:42:27 -05:00
|
|
|
|
|
|
|
// Get the current thread.
|
2022-06-16 10:35:52 -04:00
|
|
|
KThread* cur_thread =
|
2023-03-07 10:49:41 -05:00
|
|
|
m_kernel.Scheduler(static_cast<std::size_t>(core_id)).GetSchedulerCurrentThread();
|
2021-01-20 16:42:27 -05:00
|
|
|
|
|
|
|
// Unpin it.
|
|
|
|
cur_thread->Unpin();
|
2023-03-11 10:38:33 -05:00
|
|
|
this->UnpinThread(core_id, cur_thread);
|
2021-01-20 16:42:27 -05:00
|
|
|
|
|
|
|
// An update is needed.
|
2023-03-07 10:49:41 -05:00
|
|
|
KScheduler::SetSchedulerUpdateNeeded(m_kernel);
|
2021-01-20 16:42:27 -05:00
|
|
|
}
|
|
|
|
|
2021-11-11 02:02:45 -05:00
|
|
|
void KProcess::UnpinThread(KThread* thread) {
|
2023-03-07 16:45:13 -05:00
|
|
|
ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));
|
2021-11-11 02:02:45 -05:00
|
|
|
|
|
|
|
// Get the thread's core id.
|
|
|
|
const auto core_id = thread->GetActiveCore();
|
|
|
|
|
|
|
|
// Unpin it.
|
2023-03-11 10:38:33 -05:00
|
|
|
this->UnpinThread(core_id, thread);
|
2021-11-11 02:02:45 -05:00
|
|
|
thread->Unpin();
|
|
|
|
|
|
|
|
// An update is needed.
|
2023-03-07 10:49:41 -05:00
|
|
|
KScheduler::SetSchedulerUpdateNeeded(m_kernel);
|
2021-11-11 02:02:45 -05:00
|
|
|
}
|
|
|
|
|
2023-03-17 21:26:04 -04:00
|
|
|
Result KProcess::AddSharedMemory(KSharedMemory* shmem, [[maybe_unused]] KProcessAddress address,
|
2022-06-25 23:44:19 -04:00
|
|
|
[[maybe_unused]] size_t size) {
|
2021-04-30 17:53:22 -04:00
|
|
|
// Lock ourselves, to prevent concurrent access.
|
2023-03-07 16:45:13 -05:00
|
|
|
KScopedLightLock lk(m_state_lock);
|
2021-04-30 17:53:22 -04:00
|
|
|
|
2021-09-25 11:01:53 -04:00
|
|
|
// Try to find an existing info for the memory.
|
|
|
|
KSharedMemoryInfo* shemen_info = nullptr;
|
|
|
|
const auto iter = std::find_if(
|
2023-03-07 16:45:13 -05:00
|
|
|
m_shared_memory_list.begin(), m_shared_memory_list.end(),
|
2021-09-25 11:01:53 -04:00
|
|
|
[shmem](const KSharedMemoryInfo* info) { return info->GetSharedMemory() == shmem; });
|
2023-03-07 16:45:13 -05:00
|
|
|
if (iter != m_shared_memory_list.end()) {
|
2021-09-25 11:01:53 -04:00
|
|
|
shemen_info = *iter;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (shemen_info == nullptr) {
|
2023-03-07 10:49:41 -05:00
|
|
|
shemen_info = KSharedMemoryInfo::Allocate(m_kernel);
|
2021-09-25 11:01:53 -04:00
|
|
|
R_UNLESS(shemen_info != nullptr, ResultOutOfMemory);
|
|
|
|
|
|
|
|
shemen_info->Initialize(shmem);
|
2023-03-07 16:45:13 -05:00
|
|
|
m_shared_memory_list.push_back(shemen_info);
|
2021-09-25 11:01:53 -04:00
|
|
|
}
|
2021-04-30 17:53:22 -04:00
|
|
|
|
2021-09-25 11:01:53 -04:00
|
|
|
// Open a reference to the shared memory and its info.
|
2021-04-30 17:53:22 -04:00
|
|
|
shmem->Open();
|
2021-09-25 11:01:53 -04:00
|
|
|
shemen_info->Open();
|
2021-04-30 17:53:22 -04:00
|
|
|
|
2022-10-15 01:55:51 -04:00
|
|
|
R_SUCCEED();
|
2021-04-30 17:53:22 -04:00
|
|
|
}
|
|
|
|
|
2023-03-17 21:26:04 -04:00
|
|
|
void KProcess::RemoveSharedMemory(KSharedMemory* shmem, [[maybe_unused]] KProcessAddress address,
|
2021-04-30 17:53:22 -04:00
|
|
|
[[maybe_unused]] size_t size) {
|
|
|
|
// Lock ourselves, to prevent concurrent access.
|
2023-03-07 16:45:13 -05:00
|
|
|
KScopedLightLock lk(m_state_lock);
|
2021-04-30 17:53:22 -04:00
|
|
|
|
2021-09-25 11:01:53 -04:00
|
|
|
KSharedMemoryInfo* shemen_info = nullptr;
|
|
|
|
const auto iter = std::find_if(
|
2023-03-07 16:45:13 -05:00
|
|
|
m_shared_memory_list.begin(), m_shared_memory_list.end(),
|
2021-09-25 11:01:53 -04:00
|
|
|
[shmem](const KSharedMemoryInfo* info) { return info->GetSharedMemory() == shmem; });
|
2023-03-07 16:45:13 -05:00
|
|
|
if (iter != m_shared_memory_list.end()) {
|
2021-09-25 11:01:53 -04:00
|
|
|
shemen_info = *iter;
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(shemen_info != nullptr);
|
|
|
|
|
|
|
|
if (shemen_info->Close()) {
|
2023-03-07 16:45:13 -05:00
|
|
|
m_shared_memory_list.erase(iter);
|
2023-03-07 10:49:41 -05:00
|
|
|
KSharedMemoryInfo::Free(m_kernel, shemen_info);
|
2021-09-25 11:01:53 -04:00
|
|
|
}
|
2021-04-30 17:53:22 -04:00
|
|
|
|
|
|
|
// Close a reference to the shared memory.
|
|
|
|
shmem->Close();
|
|
|
|
}
|
|
|
|
|
2022-06-13 18:36:30 -04:00
|
|
|
void KProcess::RegisterThread(KThread* thread) {
|
2023-03-07 16:45:13 -05:00
|
|
|
KScopedLightLock lk{m_list_lock};
|
2022-06-13 18:36:30 -04:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
m_thread_list.push_back(thread);
|
2019-03-20 18:53:48 -04:00
|
|
|
}
|
|
|
|
|
2022-06-13 18:36:30 -04:00
|
|
|
void KProcess::UnregisterThread(KThread* thread) {
|
2023-03-07 16:45:13 -05:00
|
|
|
KScopedLightLock lk{m_list_lock};
|
2022-06-13 18:36:30 -04:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
m_thread_list.remove(thread);
|
2019-03-20 18:53:48 -04:00
|
|
|
}
|
|
|
|
|
2022-12-15 14:22:07 -05:00
|
|
|
u64 KProcess::GetFreeThreadCount() const {
|
2023-03-07 16:45:13 -05:00
|
|
|
if (m_resource_limit != nullptr) {
|
2022-12-15 14:22:07 -05:00
|
|
|
const auto current_value =
|
2023-03-07 16:45:13 -05:00
|
|
|
m_resource_limit->GetCurrentValue(LimitableResource::ThreadCountMax);
|
|
|
|
const auto limit_value = m_resource_limit->GetLimitValue(LimitableResource::ThreadCountMax);
|
2022-12-15 14:22:07 -05:00
|
|
|
return limit_value - current_value;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-25 23:44:19 -04:00
|
|
|
Result KProcess::Reset() {
|
2021-01-31 19:55:11 -05:00
|
|
|
// Lock the process and the scheduler.
|
2023-03-07 16:45:13 -05:00
|
|
|
KScopedLightLock lk(m_state_lock);
|
2023-03-07 10:49:41 -05:00
|
|
|
KScopedSchedulerLock sl{m_kernel};
|
2018-12-04 19:08:56 -05:00
|
|
|
|
2021-01-31 19:55:11 -05:00
|
|
|
// Validate that we're in a state that we can reset.
|
2023-03-07 16:45:13 -05:00
|
|
|
R_UNLESS(m_state != State::Terminated, ResultInvalidState);
|
|
|
|
R_UNLESS(m_is_signaled, ResultInvalidState);
|
2018-12-04 19:08:56 -05:00
|
|
|
|
2021-01-31 19:55:11 -05:00
|
|
|
// Clear signaled.
|
2023-03-07 16:45:13 -05:00
|
|
|
m_is_signaled = false;
|
2022-10-15 01:55:51 -04:00
|
|
|
R_SUCCEED();
|
2018-12-04 19:08:56 -05:00
|
|
|
}
|
|
|
|
|
2022-06-25 23:44:19 -04:00
|
|
|
Result KProcess::SetActivity(ProcessActivity activity) {
|
2022-06-13 18:36:30 -04:00
|
|
|
// Lock ourselves and the scheduler.
|
2023-03-07 16:45:13 -05:00
|
|
|
KScopedLightLock lk{m_state_lock};
|
|
|
|
KScopedLightLock list_lk{m_list_lock};
|
2023-03-07 10:49:41 -05:00
|
|
|
KScopedSchedulerLock sl{m_kernel};
|
2022-06-13 18:36:30 -04:00
|
|
|
|
|
|
|
// Validate our state.
|
2023-03-07 16:45:13 -05:00
|
|
|
R_UNLESS(m_state != State::Terminating, ResultInvalidState);
|
|
|
|
R_UNLESS(m_state != State::Terminated, ResultInvalidState);
|
2022-06-13 18:36:30 -04:00
|
|
|
|
|
|
|
// Either pause or resume.
|
|
|
|
if (activity == ProcessActivity::Paused) {
|
|
|
|
// Verify that we're not suspended.
|
2023-03-07 16:45:13 -05:00
|
|
|
R_UNLESS(!m_is_suspended, ResultInvalidState);
|
2022-06-13 18:36:30 -04:00
|
|
|
|
|
|
|
// Suspend all threads.
|
2023-03-07 16:45:13 -05:00
|
|
|
for (auto* thread : this->GetThreadList()) {
|
2022-06-13 18:36:30 -04:00
|
|
|
thread->RequestSuspend(SuspendType::Process);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set ourselves as suspended.
|
2023-03-11 10:38:33 -05:00
|
|
|
this->SetSuspended(true);
|
2022-06-13 18:36:30 -04:00
|
|
|
} else {
|
|
|
|
ASSERT(activity == ProcessActivity::Runnable);
|
|
|
|
|
|
|
|
// Verify that we're suspended.
|
2023-03-07 16:45:13 -05:00
|
|
|
R_UNLESS(m_is_suspended, ResultInvalidState);
|
2022-06-13 18:36:30 -04:00
|
|
|
|
|
|
|
// Resume all threads.
|
2023-03-07 16:45:13 -05:00
|
|
|
for (auto* thread : this->GetThreadList()) {
|
2022-06-13 18:36:30 -04:00
|
|
|
thread->Resume(SuspendType::Process);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set ourselves as resumed.
|
2023-03-11 10:38:33 -05:00
|
|
|
this->SetSuspended(false);
|
2022-06-13 18:36:30 -04:00
|
|
|
}
|
|
|
|
|
2022-10-15 01:55:51 -04:00
|
|
|
R_SUCCEED();
|
2022-06-13 18:36:30 -04:00
|
|
|
}
|
|
|
|
|
2022-06-25 23:44:19 -04:00
|
|
|
Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size) {
|
2023-03-07 16:45:13 -05:00
|
|
|
m_program_id = metadata.GetTitleID();
|
|
|
|
m_ideal_core = metadata.GetMainThreadCore();
|
|
|
|
m_is_64bit_process = metadata.Is64BitProgram();
|
|
|
|
m_system_resource_size = metadata.GetSystemResourceSize();
|
|
|
|
m_image_size = code_size;
|
2020-04-08 22:19:12 -04:00
|
|
|
|
2022-11-03 10:22:05 -04:00
|
|
|
KScopedResourceReservation memory_reservation(
|
2023-03-07 16:45:13 -05:00
|
|
|
m_resource_limit, LimitableResource::PhysicalMemoryMax, code_size + m_system_resource_size);
|
2021-02-04 20:06:54 -05:00
|
|
|
if (!memory_reservation.Succeeded()) {
|
|
|
|
LOG_ERROR(Kernel, "Could not reserve process memory requirements of size {:X} bytes",
|
2023-03-07 16:45:13 -05:00
|
|
|
code_size + m_system_resource_size);
|
2022-10-15 01:55:51 -04:00
|
|
|
R_RETURN(ResultLimitReached);
|
2021-02-04 20:06:54 -05:00
|
|
|
}
|
2023-03-11 22:10:38 -05:00
|
|
|
// Initialize process address space
|
2023-03-07 16:45:13 -05:00
|
|
|
if (const Result result{m_page_table.InitializeForProcess(
|
2022-10-29 17:45:09 -04:00
|
|
|
metadata.GetAddressSpaceType(), false, false, false, KMemoryManager::Pool::Application,
|
2023-03-07 16:45:13 -05:00
|
|
|
0x8000000, code_size, std::addressof(m_kernel.GetAppSystemResource()),
|
|
|
|
m_resource_limit)};
|
2020-04-08 22:19:12 -04:00
|
|
|
result.IsError()) {
|
2022-10-15 01:55:51 -04:00
|
|
|
R_RETURN(result);
|
2020-04-08 22:19:12 -04:00
|
|
|
}
|
2017-05-06 02:11:06 -04:00
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
// Map process code region
|
2023-03-07 16:45:13 -05:00
|
|
|
if (const Result result{m_page_table.MapProcessCode(m_page_table.GetCodeRegionStart(),
|
|
|
|
code_size / PageSize, KMemoryState::Code,
|
|
|
|
KMemoryPermission::None)};
|
2020-04-08 22:19:12 -04:00
|
|
|
result.IsError()) {
|
2022-10-15 01:55:51 -04:00
|
|
|
R_RETURN(result);
|
2020-04-08 22:19:12 -04:00
|
|
|
}
|
2015-07-19 14:18:57 -04:00
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
// Initialize process capabilities
|
|
|
|
const auto& caps{metadata.GetKernelCapabilities()};
|
2022-06-25 23:44:19 -04:00
|
|
|
if (const Result result{
|
2023-03-07 16:45:13 -05:00
|
|
|
m_capabilities.InitializeForUserProcess(caps.data(), caps.size(), m_page_table)};
|
2020-04-08 22:19:12 -04:00
|
|
|
result.IsError()) {
|
2022-10-15 01:55:51 -04:00
|
|
|
R_RETURN(result);
|
2019-02-25 10:13:52 -05:00
|
|
|
}
|
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
// Set memory usage capacity
|
|
|
|
switch (metadata.GetAddressSpaceType()) {
|
|
|
|
case FileSys::ProgramAddressSpaceType::Is32Bit:
|
|
|
|
case FileSys::ProgramAddressSpaceType::Is36Bit:
|
|
|
|
case FileSys::ProgramAddressSpaceType::Is39Bit:
|
2023-03-07 16:45:13 -05:00
|
|
|
m_memory_usage_capacity =
|
|
|
|
m_page_table.GetHeapRegionEnd() - m_page_table.GetHeapRegionStart();
|
2020-04-08 22:19:12 -04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
|
2023-03-07 16:45:13 -05:00
|
|
|
m_memory_usage_capacity =
|
2023-03-17 21:26:04 -04:00
|
|
|
(m_page_table.GetHeapRegionEnd() - m_page_table.GetHeapRegionStart()) +
|
|
|
|
(m_page_table.GetAliasRegionEnd() - m_page_table.GetAliasRegionStart());
|
2020-04-08 22:19:12 -04:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2022-06-07 17:02:29 -04:00
|
|
|
ASSERT(false);
|
2022-11-11 07:12:37 -05:00
|
|
|
break;
|
2020-04-08 22:19:12 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Create TLS region
|
2023-03-07 16:45:13 -05:00
|
|
|
R_TRY(this->CreateThreadLocalRegion(std::addressof(m_plr_address)));
|
2021-02-04 20:06:54 -05:00
|
|
|
memory_reservation.Commit();
|
2020-04-08 22:19:12 -04:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
R_RETURN(m_handle_table.Initialize(m_capabilities.GetHandleTableSize()));
|
2015-05-03 23:01:16 -04:00
|
|
|
}
|
|
|
|
|
2021-04-24 01:04:28 -04:00
|
|
|
void KProcess::Run(s32 main_thread_priority, u64 stack_size) {
|
2023-03-07 16:45:13 -05:00
|
|
|
ASSERT(this->AllocateMainThreadStack(stack_size) == ResultSuccess);
|
|
|
|
m_resource_limit->Reserve(LimitableResource::ThreadCountMax, 1);
|
2017-05-06 02:11:06 -04:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
const std::size_t heap_capacity{m_memory_usage_capacity -
|
|
|
|
(m_main_thread_stack_size + m_image_size)};
|
|
|
|
ASSERT(!m_page_table.SetMaxHeapSize(heap_capacity).IsError());
|
2019-07-07 04:13:56 -04:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
this->ChangeState(State::Running);
|
2017-10-09 23:56:20 -04:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
SetupMainThread(m_kernel.System(), *this, main_thread_priority, m_main_thread_stack_top);
|
2017-09-30 14:15:09 -04:00
|
|
|
}
|
2017-09-24 11:12:16 -04:00
|
|
|
|
2021-04-24 01:04:28 -04:00
|
|
|
void KProcess::PrepareForTermination() {
|
2023-03-07 16:45:13 -05:00
|
|
|
this->ChangeState(State::Terminating);
|
2018-09-21 02:06:47 -04:00
|
|
|
|
2021-05-08 12:11:36 -04:00
|
|
|
const auto stop_threads = [this](const std::vector<KThread*>& in_thread_list) {
|
2022-06-16 10:35:52 -04:00
|
|
|
for (auto* thread : in_thread_list) {
|
2018-10-03 18:47:57 -04:00
|
|
|
if (thread->GetOwnerProcess() != this)
|
2018-09-21 02:06:47 -04:00
|
|
|
continue;
|
|
|
|
|
2023-03-07 10:49:41 -05:00
|
|
|
if (thread == GetCurrentThreadPointer(m_kernel))
|
2018-09-21 02:06:47 -04:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// TODO(Subv): When are the other running/ready threads terminated?
|
2020-12-28 16:16:43 -05:00
|
|
|
ASSERT_MSG(thread->GetState() == ThreadState::Waiting,
|
2018-09-21 02:06:47 -04:00
|
|
|
"Exiting processes with non-waiting threads is currently unimplemented");
|
|
|
|
|
2021-01-20 16:42:27 -05:00
|
|
|
thread->Exit();
|
2018-09-21 02:06:47 -04:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2023-03-07 10:49:41 -05:00
|
|
|
stop_threads(m_kernel.System().GlobalSchedulerContext().GetThreadList());
|
2018-12-04 19:08:56 -05:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
this->DeleteThreadLocalRegion(m_plr_address);
|
|
|
|
m_plr_address = 0;
|
2019-07-07 04:19:16 -04:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
if (m_resource_limit) {
|
|
|
|
m_resource_limit->Release(LimitableResource::PhysicalMemoryMax,
|
|
|
|
m_main_thread_stack_size + m_image_size);
|
2021-02-04 20:06:54 -05:00
|
|
|
}
|
|
|
|
|
2023-03-11 10:38:33 -05:00
|
|
|
this->ChangeState(State::Terminated);
|
2018-09-21 02:06:47 -04:00
|
|
|
}
|
|
|
|
|
2021-04-24 01:04:28 -04:00
|
|
|
void KProcess::Finalize() {
|
2021-09-25 11:01:53 -04:00
|
|
|
// Free all shared memory infos.
|
|
|
|
{
|
2023-03-07 16:45:13 -05:00
|
|
|
auto it = m_shared_memory_list.begin();
|
|
|
|
while (it != m_shared_memory_list.end()) {
|
2021-09-25 11:01:53 -04:00
|
|
|
KSharedMemoryInfo* info = *it;
|
|
|
|
KSharedMemory* shmem = info->GetSharedMemory();
|
|
|
|
|
|
|
|
while (!info->Close()) {
|
|
|
|
shmem->Close();
|
|
|
|
}
|
|
|
|
|
|
|
|
shmem->Close();
|
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
it = m_shared_memory_list.erase(it);
|
2023-03-07 10:49:41 -05:00
|
|
|
KSharedMemoryInfo::Free(m_kernel, info);
|
2021-09-25 11:01:53 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-26 06:12:13 -04:00
|
|
|
// Release memory to the resource limit.
|
2023-03-07 16:45:13 -05:00
|
|
|
if (m_resource_limit != nullptr) {
|
|
|
|
m_resource_limit->Close();
|
|
|
|
m_resource_limit = nullptr;
|
2021-10-26 06:12:13 -04:00
|
|
|
}
|
|
|
|
|
2022-03-11 20:15:04 -05:00
|
|
|
// Finalize the page table.
|
2023-03-07 16:45:13 -05:00
|
|
|
m_page_table.Finalize();
|
2022-03-11 20:15:04 -05:00
|
|
|
|
2021-04-21 00:28:11 -04:00
|
|
|
// Perform inherited finalization.
|
2023-03-11 10:38:33 -05:00
|
|
|
KSynchronizationObject::Finalize();
|
2021-04-21 00:28:11 -04:00
|
|
|
}
|
|
|
|
|
2023-03-17 21:26:04 -04:00
|
|
|
Result KProcess::CreateThreadLocalRegion(KProcessAddress* out) {
|
2022-03-11 20:14:17 -05:00
|
|
|
KThreadLocalPage* tlp = nullptr;
|
2023-03-17 21:26:04 -04:00
|
|
|
KProcessAddress tlr = 0;
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2022-03-11 20:14:17 -05:00
|
|
|
// See if we can get a region from a partially used TLP.
|
|
|
|
{
|
2023-03-07 10:49:41 -05:00
|
|
|
KScopedSchedulerLock sl{m_kernel};
|
2022-03-11 20:14:17 -05:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
if (auto it = m_partially_used_tlp_tree.begin(); it != m_partially_used_tlp_tree.end()) {
|
2022-03-11 20:14:17 -05:00
|
|
|
tlr = it->Reserve();
|
|
|
|
ASSERT(tlr != 0);
|
|
|
|
|
|
|
|
if (it->IsAllUsed()) {
|
|
|
|
tlp = std::addressof(*it);
|
2023-03-07 16:45:13 -05:00
|
|
|
m_partially_used_tlp_tree.erase(it);
|
|
|
|
m_fully_used_tlp_tree.insert(*tlp);
|
2022-03-11 20:14:17 -05:00
|
|
|
}
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2022-03-11 20:14:17 -05:00
|
|
|
*out = tlr;
|
2022-10-15 01:55:51 -04:00
|
|
|
R_SUCCEED();
|
2022-03-11 20:14:17 -05:00
|
|
|
}
|
|
|
|
}
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2022-03-11 20:14:17 -05:00
|
|
|
// Allocate a new page.
|
2023-03-07 10:49:41 -05:00
|
|
|
tlp = KThreadLocalPage::Allocate(m_kernel);
|
2022-03-11 20:14:17 -05:00
|
|
|
R_UNLESS(tlp != nullptr, ResultOutOfMemory);
|
2023-03-07 10:49:41 -05:00
|
|
|
auto tlp_guard = SCOPE_GUARD({ KThreadLocalPage::Free(m_kernel, tlp); });
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2022-03-11 20:14:17 -05:00
|
|
|
// Initialize the new page.
|
2023-03-07 10:49:41 -05:00
|
|
|
R_TRY(tlp->Initialize(m_kernel, this));
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2022-03-11 20:14:17 -05:00
|
|
|
// Reserve a TLR.
|
|
|
|
tlr = tlp->Reserve();
|
|
|
|
ASSERT(tlr != 0);
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2022-03-11 20:14:17 -05:00
|
|
|
// Insert into our tree.
|
|
|
|
{
|
2023-03-07 10:49:41 -05:00
|
|
|
KScopedSchedulerLock sl{m_kernel};
|
2022-03-11 20:14:17 -05:00
|
|
|
if (tlp->IsAllUsed()) {
|
2023-03-07 16:45:13 -05:00
|
|
|
m_fully_used_tlp_tree.insert(*tlp);
|
2022-03-11 20:14:17 -05:00
|
|
|
} else {
|
2023-03-07 16:45:13 -05:00
|
|
|
m_partially_used_tlp_tree.insert(*tlp);
|
2022-03-11 20:14:17 -05:00
|
|
|
}
|
|
|
|
}
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2022-03-11 20:14:17 -05:00
|
|
|
// We succeeded!
|
|
|
|
tlp_guard.Cancel();
|
|
|
|
*out = tlr;
|
2022-10-15 01:55:51 -04:00
|
|
|
R_SUCCEED();
|
2018-09-21 01:26:29 -04:00
|
|
|
}
|
|
|
|
|
2023-03-17 21:26:04 -04:00
|
|
|
Result KProcess::DeleteThreadLocalRegion(KProcessAddress addr) {
|
2022-03-11 20:14:17 -05:00
|
|
|
KThreadLocalPage* page_to_free = nullptr;
|
|
|
|
|
|
|
|
// Release the region.
|
|
|
|
{
|
2023-03-07 10:49:41 -05:00
|
|
|
KScopedSchedulerLock sl{m_kernel};
|
2022-03-11 20:14:17 -05:00
|
|
|
|
|
|
|
// Try to find the page in the partially used list.
|
2023-03-17 21:26:04 -04:00
|
|
|
auto it = m_partially_used_tlp_tree.find_key(Common::AlignDown(GetInteger(addr), PageSize));
|
2023-03-07 16:45:13 -05:00
|
|
|
if (it == m_partially_used_tlp_tree.end()) {
|
2022-03-11 20:14:17 -05:00
|
|
|
// If we don't find it, it has to be in the fully used list.
|
2023-03-17 21:26:04 -04:00
|
|
|
it = m_fully_used_tlp_tree.find_key(Common::AlignDown(GetInteger(addr), PageSize));
|
2023-03-07 16:45:13 -05:00
|
|
|
R_UNLESS(it != m_fully_used_tlp_tree.end(), ResultInvalidAddress);
|
2022-03-11 20:14:17 -05:00
|
|
|
|
|
|
|
// Release the region.
|
|
|
|
it->Release(addr);
|
|
|
|
|
|
|
|
// Move the page out of the fully used list.
|
|
|
|
KThreadLocalPage* tlp = std::addressof(*it);
|
2023-03-07 16:45:13 -05:00
|
|
|
m_fully_used_tlp_tree.erase(it);
|
2022-03-11 20:14:17 -05:00
|
|
|
if (tlp->IsAllFree()) {
|
|
|
|
page_to_free = tlp;
|
|
|
|
} else {
|
2023-03-07 16:45:13 -05:00
|
|
|
m_partially_used_tlp_tree.insert(*tlp);
|
2022-03-11 20:14:17 -05:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Release the region.
|
|
|
|
it->Release(addr);
|
|
|
|
|
|
|
|
// Handle the all-free case.
|
|
|
|
KThreadLocalPage* tlp = std::addressof(*it);
|
|
|
|
if (tlp->IsAllFree()) {
|
2023-03-07 16:45:13 -05:00
|
|
|
m_partially_used_tlp_tree.erase(it);
|
2022-03-11 20:14:17 -05:00
|
|
|
page_to_free = tlp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we should free the page it was in, do so.
|
|
|
|
if (page_to_free != nullptr) {
|
|
|
|
page_to_free->Finalize();
|
2019-06-05 14:32:33 -04:00
|
|
|
|
2023-03-07 10:49:41 -05:00
|
|
|
KThreadLocalPage::Free(m_kernel, page_to_free);
|
2022-03-11 20:14:17 -05:00
|
|
|
}
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2022-10-15 01:55:51 -04:00
|
|
|
R_SUCCEED();
|
2018-09-21 01:26:29 -04:00
|
|
|
}
|
|
|
|
|
2023-03-17 21:26:04 -04:00
|
|
|
bool KProcess::InsertWatchpoint(Core::System& system, KProcessAddress addr, u64 size,
|
2022-06-06 12:56:01 -04:00
|
|
|
DebugWatchpointType type) {
|
2023-03-07 16:45:13 -05:00
|
|
|
const auto watch{std::find_if(m_watchpoints.begin(), m_watchpoints.end(), [&](const auto& wp) {
|
2022-06-06 12:56:01 -04:00
|
|
|
return wp.type == DebugWatchpointType::None;
|
|
|
|
})};
|
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
if (watch == m_watchpoints.end()) {
|
2022-06-06 12:56:01 -04:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
watch->start_address = addr;
|
|
|
|
watch->end_address = addr + size;
|
|
|
|
watch->type = type;
|
|
|
|
|
2023-03-17 21:26:04 -04:00
|
|
|
for (KProcessAddress page = Common::AlignDown(GetInteger(addr), PageSize); page < addr + size;
|
|
|
|
page += PageSize) {
|
2023-03-07 16:45:13 -05:00
|
|
|
m_debug_page_refcounts[page]++;
|
2022-06-06 12:56:01 -04:00
|
|
|
system.Memory().MarkRegionDebug(page, PageSize, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2023-03-17 21:26:04 -04:00
|
|
|
bool KProcess::RemoveWatchpoint(Core::System& system, KProcessAddress addr, u64 size,
|
2022-06-06 12:56:01 -04:00
|
|
|
DebugWatchpointType type) {
|
2023-03-07 16:45:13 -05:00
|
|
|
const auto watch{std::find_if(m_watchpoints.begin(), m_watchpoints.end(), [&](const auto& wp) {
|
2022-06-06 12:56:01 -04:00
|
|
|
return wp.start_address == addr && wp.end_address == addr + size && wp.type == type;
|
|
|
|
})};
|
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
if (watch == m_watchpoints.end()) {
|
2022-06-06 12:56:01 -04:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
watch->start_address = 0;
|
|
|
|
watch->end_address = 0;
|
|
|
|
watch->type = DebugWatchpointType::None;
|
|
|
|
|
2023-03-17 21:26:04 -04:00
|
|
|
for (KProcessAddress page = Common::AlignDown(GetInteger(addr), PageSize); page < addr + size;
|
|
|
|
page += PageSize) {
|
2023-03-07 16:45:13 -05:00
|
|
|
m_debug_page_refcounts[page]--;
|
|
|
|
if (!m_debug_page_refcounts[page]) {
|
2022-06-06 12:56:01 -04:00
|
|
|
system.Memory().MarkRegionDebug(page, PageSize, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2023-03-17 21:26:04 -04:00
|
|
|
void KProcess::LoadModule(CodeSet code_set, KProcessAddress base_addr) {
|
2020-04-08 22:19:12 -04:00
|
|
|
const auto ReprotectSegment = [&](const CodeSet::Segment& segment,
|
2022-01-09 05:17:17 -05:00
|
|
|
Svc::MemoryPermission permission) {
|
2023-03-07 16:45:13 -05:00
|
|
|
m_page_table.SetProcessMemoryPermission(segment.addr + base_addr, segment.size, permission);
|
2017-09-24 11:12:16 -04:00
|
|
|
};
|
|
|
|
|
2023-03-07 10:49:41 -05:00
|
|
|
m_kernel.System().Memory().WriteBlock(*this, base_addr, code_set.memory.data(),
|
|
|
|
code_set.memory.size());
|
2020-04-08 22:19:12 -04:00
|
|
|
|
2022-01-09 05:17:17 -05:00
|
|
|
ReprotectSegment(code_set.CodeSegment(), Svc::MemoryPermission::ReadExecute);
|
|
|
|
ReprotectSegment(code_set.RODataSegment(), Svc::MemoryPermission::Read);
|
|
|
|
ReprotectSegment(code_set.DataSegment(), Svc::MemoryPermission::ReadWrite);
|
2015-05-03 23:01:16 -04:00
|
|
|
}
|
|
|
|
|
2021-04-24 01:04:28 -04:00
|
|
|
bool KProcess::IsSignaled() const {
|
2023-03-07 16:45:13 -05:00
|
|
|
ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));
|
|
|
|
return m_is_signaled;
|
2020-12-22 01:36:53 -05:00
|
|
|
}
|
|
|
|
|
2023-03-07 10:49:41 -05:00
|
|
|
KProcess::KProcess(KernelCore& kernel)
|
2023-03-07 16:45:13 -05:00
|
|
|
: KAutoObjectWithSlabHeapAndContainer{kernel}, m_page_table{m_kernel.System()},
|
|
|
|
m_handle_table{m_kernel}, m_address_arbiter{m_kernel.System()},
|
|
|
|
m_condition_var{m_kernel.System()}, m_state_lock{m_kernel}, m_list_lock{m_kernel} {}
|
2019-03-14 00:29:54 -04:00
|
|
|
|
2021-04-24 01:04:28 -04:00
|
|
|
KProcess::~KProcess() = default;
|
2015-05-03 23:01:16 -04:00
|
|
|
|
2022-09-05 20:47:00 -04:00
|
|
|
void KProcess::ChangeState(State new_state) {
|
2023-03-07 16:45:13 -05:00
|
|
|
if (m_state == new_state) {
|
2018-12-04 19:08:56 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
m_state = new_state;
|
|
|
|
m_is_signaled = true;
|
|
|
|
this->NotifyAvailable();
|
2018-12-04 19:08:56 -05:00
|
|
|
}
|
|
|
|
|
2022-06-25 23:44:19 -04:00
|
|
|
Result KProcess::AllocateMainThreadStack(std::size_t stack_size) {
|
2022-12-27 19:51:37 -05:00
|
|
|
// Ensure that we haven't already allocated stack.
|
2023-03-07 16:45:13 -05:00
|
|
|
ASSERT(m_main_thread_stack_size == 0);
|
2022-12-27 19:51:37 -05:00
|
|
|
|
|
|
|
// Ensure that we're allocating a valid stack.
|
|
|
|
stack_size = Common::AlignUp(stack_size, PageSize);
|
|
|
|
// R_UNLESS(stack_size + image_size <= m_max_process_memory, ResultOutOfMemory);
|
2023-03-07 16:45:13 -05:00
|
|
|
R_UNLESS(stack_size + m_image_size >= m_image_size, ResultOutOfMemory);
|
2022-12-27 19:51:37 -05:00
|
|
|
|
|
|
|
// 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.
|
|
|
|
if (stack_size) {
|
|
|
|
KProcessAddress stack_bottom;
|
2023-03-07 16:45:13 -05:00
|
|
|
R_TRY(m_page_table.MapPages(std::addressof(stack_bottom), stack_size / PageSize,
|
|
|
|
KMemoryState::Stack, KMemoryPermission::UserReadWrite));
|
2022-12-27 19:51:37 -05:00
|
|
|
|
2023-03-07 16:45:13 -05:00
|
|
|
m_main_thread_stack_top = stack_bottom + stack_size;
|
|
|
|
m_main_thread_stack_size = stack_size;
|
2022-12-27 19:51:37 -05:00
|
|
|
}
|
2020-04-08 22:19:12 -04:00
|
|
|
|
2022-12-27 19:51:37 -05:00
|
|
|
// We succeeded! Commit our memory reservation.
|
|
|
|
mem_reservation.Commit();
|
2020-04-08 22:19:12 -04:00
|
|
|
|
2022-10-15 01:55:51 -04:00
|
|
|
R_SUCCEED();
|
2022-10-02 17:26:30 -04:00
|
|
|
}
|
|
|
|
|
2018-01-01 14:38:34 -05:00
|
|
|
} // namespace Kernel
|