2015-05-03 20:01:16 -07:00
|
|
|
// Copyright 2015 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2018-01-01 11:38:34 -08:00
|
|
|
#include <algorithm>
|
2019-06-05 11:32:33 -07:00
|
|
|
#include <bitset>
|
2016-04-05 05:29:55 -07:00
|
|
|
#include <memory>
|
2018-11-20 14:46:17 -08:00
|
|
|
#include <random>
|
2019-03-28 15:24:56 -07:00
|
|
|
#include "common/alignment.h"
|
2015-05-03 20:01:16 -07:00
|
|
|
#include "common/assert.h"
|
2015-05-08 12:51:48 -07:00
|
|
|
#include "common/logging/log.h"
|
2018-09-20 23:06:47 -07:00
|
|
|
#include "core/core.h"
|
2020-04-08 19:19:12 -07:00
|
|
|
#include "core/device_memory.h"
|
2018-09-22 17:09:32 -07:00
|
|
|
#include "core/file_sys/program_metadata.h"
|
2019-03-20 09:40:09 -07:00
|
|
|
#include "core/hle/kernel/code_set.h"
|
2018-12-04 16:08:56 -08:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2018-08-28 09:30:33 -07:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2020-04-08 19:19:12 -07:00
|
|
|
#include "core/hle/kernel/memory/memory_block_manager.h"
|
|
|
|
#include "core/hle/kernel/memory/page_table.h"
|
|
|
|
#include "core/hle/kernel/memory/slab_heap.h"
|
2016-09-20 23:52:38 -07:00
|
|
|
#include "core/hle/kernel/process.h"
|
2015-05-12 13:25:15 -07:00
|
|
|
#include "core/hle/kernel/resource_limit.h"
|
2018-09-20 23:06:47 -07:00
|
|
|
#include "core/hle/kernel/scheduler.h"
|
2015-05-03 20:01:16 -07:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2015-05-12 18:38:29 -07:00
|
|
|
#include "core/memory.h"
|
2018-11-13 09:25:43 -08:00
|
|
|
#include "core/settings.h"
|
2015-05-03 20:01:16 -07:00
|
|
|
|
|
|
|
namespace Kernel {
|
2018-12-27 17:28:15 -08:00
|
|
|
namespace {
|
|
|
|
/**
|
|
|
|
* Sets up the primary application thread
|
|
|
|
*
|
|
|
|
* @param owner_process The parent process for the main thread
|
|
|
|
* @param kernel The kernel instance to create the main thread under.
|
|
|
|
* @param priority The priority to give the main thread
|
|
|
|
*/
|
2020-04-08 19:19:12 -07:00
|
|
|
void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority, VAddr stack_top) {
|
|
|
|
const VAddr entry_point = owner_process.PageTable().GetCodeRegionStart();
|
2018-12-27 18:20:49 -08:00
|
|
|
auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0,
|
|
|
|
owner_process.GetIdealCore(), stack_top, owner_process);
|
2018-12-27 17:28:15 -08:00
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<Thread> thread = std::move(thread_res).Unwrap();
|
2018-12-27 17:28:15 -08:00
|
|
|
|
|
|
|
// Register 1 must be a handle to the main thread
|
2019-04-14 03:06:04 -07:00
|
|
|
const Handle thread_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
|
2020-03-20 19:39:07 -07:00
|
|
|
thread->GetContext32().cpu_registers[0] = 0;
|
|
|
|
thread->GetContext64().cpu_registers[0] = 0;
|
2020-03-01 20:46:10 -08:00
|
|
|
thread->GetContext32().cpu_registers[1] = thread_handle;
|
|
|
|
thread->GetContext64().cpu_registers[1] = thread_handle;
|
2018-12-27 17:28:15 -08:00
|
|
|
|
|
|
|
// Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
|
|
|
|
thread->ResumeFromWait();
|
|
|
|
}
|
|
|
|
} // Anonymous namespace
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2019-06-05 11:32:33 -07:00
|
|
|
// Represents a page used for thread-local storage.
|
|
|
|
//
|
|
|
|
// Each TLS page contains slots that may be used by processes and threads.
|
|
|
|
// Every process and thread is created with a slot in some arbitrary page
|
|
|
|
// (whichever page happens to have an available slot).
|
|
|
|
class TLSPage {
|
|
|
|
public:
|
2020-03-31 12:10:44 -07:00
|
|
|
static constexpr std::size_t num_slot_entries =
|
|
|
|
Core::Memory::PAGE_SIZE / Core::Memory::TLS_ENTRY_SIZE;
|
2019-06-05 11:32:33 -07:00
|
|
|
|
|
|
|
explicit TLSPage(VAddr address) : base_address{address} {}
|
|
|
|
|
|
|
|
bool HasAvailableSlots() const {
|
|
|
|
return !is_slot_used.all();
|
|
|
|
}
|
|
|
|
|
|
|
|
VAddr GetBaseAddress() const {
|
|
|
|
return base_address;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::optional<VAddr> ReserveSlot() {
|
|
|
|
for (std::size_t i = 0; i < is_slot_used.size(); i++) {
|
|
|
|
if (is_slot_used[i]) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
is_slot_used[i] = true;
|
2020-03-31 12:10:44 -07:00
|
|
|
return base_address + (i * Core::Memory::TLS_ENTRY_SIZE);
|
2019-06-05 11:32:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return std::nullopt;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ReleaseSlot(VAddr address) {
|
|
|
|
// Ensure that all given addresses are consistent with how TLS pages
|
|
|
|
// are intended to be used when releasing slots.
|
|
|
|
ASSERT(IsWithinPage(address));
|
2020-03-31 12:10:44 -07:00
|
|
|
ASSERT((address % Core::Memory::TLS_ENTRY_SIZE) == 0);
|
2019-06-05 11:32:33 -07:00
|
|
|
|
2020-03-31 12:10:44 -07:00
|
|
|
const std::size_t index = (address - base_address) / Core::Memory::TLS_ENTRY_SIZE;
|
2019-06-05 11:32:33 -07:00
|
|
|
is_slot_used[index] = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool IsWithinPage(VAddr address) const {
|
2020-03-31 12:10:44 -07:00
|
|
|
return base_address <= address && address < base_address + Core::Memory::PAGE_SIZE;
|
2019-06-05 11:32:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
VAddr base_address;
|
|
|
|
std::bitset<num_slot_entries> is_slot_used;
|
|
|
|
};
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<Process> Process::Create(Core::System& system, std::string name, ProcessType type) {
|
2019-03-07 15:48:14 -08:00
|
|
|
auto& kernel = system.Kernel();
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<Process> process = std::make_shared<Process>(system);
|
2017-09-30 11:15:09 -07:00
|
|
|
process->name = std::move(name);
|
2020-04-08 19:19:12 -07:00
|
|
|
process->resource_limit = ResourceLimit::Create(kernel);
|
2018-01-01 11:38:34 -08:00
|
|
|
process->status = ProcessStatus::Created;
|
2018-03-13 14:49:59 -07:00
|
|
|
process->program_id = 0;
|
2019-06-09 21:28:33 -07:00
|
|
|
process->process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()
|
|
|
|
: kernel.CreateNewUserProcessID();
|
2018-12-19 20:50:20 -08:00
|
|
|
process->capabilities.InitializeForMetadatalessProcess();
|
2015-05-08 13:53:19 -07:00
|
|
|
|
2018-11-13 09:25:43 -08:00
|
|
|
std::mt19937 rng(Settings::values.rng_seed.value_or(0));
|
|
|
|
std::uniform_int_distribution<u64> distribution;
|
|
|
|
std::generate(process->random_entropy.begin(), process->random_entropy.end(),
|
|
|
|
[&] { return distribution(rng); });
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
kernel.AppendNewProcess(process);
|
2015-05-03 20:01:16 -07:00
|
|
|
return process;
|
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<ResourceLimit> Process::GetResourceLimit() const {
|
2018-12-03 21:29:15 -08:00
|
|
|
return resource_limit;
|
|
|
|
}
|
|
|
|
|
2019-06-09 15:20:20 -07:00
|
|
|
u64 Process::GetTotalPhysicalMemoryAvailable() const {
|
2020-04-08 19:19:12 -07:00
|
|
|
const u64 capacity{resource_limit->GetCurrentResourceValue(ResourceType::PhysicalMemory) +
|
2020-06-09 21:49:00 -07:00
|
|
|
page_table->GetTotalHeapSize() + GetSystemResourceSize() + image_size +
|
|
|
|
main_thread_stack_size};
|
2020-04-08 19:19:12 -07:00
|
|
|
|
|
|
|
if (capacity < memory_usage_capacity) {
|
|
|
|
return capacity;
|
|
|
|
}
|
|
|
|
|
|
|
|
return memory_usage_capacity;
|
2019-06-09 15:20:20 -07:00
|
|
|
}
|
|
|
|
|
2019-07-07 11:48:11 -07:00
|
|
|
u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
|
|
|
|
return GetTotalPhysicalMemoryAvailable() - GetSystemResourceSize();
|
2019-06-09 15:20:20 -07:00
|
|
|
}
|
|
|
|
|
2019-03-28 19:59:17 -07:00
|
|
|
u64 Process::GetTotalPhysicalMemoryUsed() const {
|
2020-06-09 21:49:00 -07:00
|
|
|
return image_size + main_thread_stack_size + page_table->GetTotalHeapSize() +
|
|
|
|
GetSystemResourceSize();
|
2019-03-28 19:59:17 -07:00
|
|
|
}
|
|
|
|
|
2019-07-07 11:48:11 -07:00
|
|
|
u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {
|
|
|
|
return GetTotalPhysicalMemoryUsed() - GetSystemResourceUsage();
|
2019-06-09 15:20:20 -07:00
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
void Process::InsertConditionVariableThread(std::shared_ptr<Thread> thread) {
|
2019-11-21 07:03:37 -08:00
|
|
|
VAddr cond_var_addr = thread->GetCondVarWaitAddress();
|
2019-11-24 17:15:51 -08:00
|
|
|
std::list<std::shared_ptr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
|
2019-11-21 07:03:37 -08:00
|
|
|
auto it = thread_list.begin();
|
|
|
|
while (it != thread_list.end()) {
|
2019-11-24 17:15:51 -08:00
|
|
|
const std::shared_ptr<Thread> current_thread = *it;
|
2019-11-21 07:03:37 -08:00
|
|
|
if (current_thread->GetPriority() > thread->GetPriority()) {
|
|
|
|
thread_list.insert(it, thread);
|
|
|
|
return;
|
2019-11-14 16:13:18 -08:00
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
2019-11-21 07:03:37 -08:00
|
|
|
thread_list.push_back(thread);
|
2019-11-14 16:13:18 -08:00
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
void Process::RemoveConditionVariableThread(std::shared_ptr<Thread> thread) {
|
2019-11-21 07:03:37 -08:00
|
|
|
VAddr cond_var_addr = thread->GetCondVarWaitAddress();
|
2019-11-24 17:15:51 -08:00
|
|
|
std::list<std::shared_ptr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
|
2019-11-21 07:03:37 -08:00
|
|
|
auto it = thread_list.begin();
|
|
|
|
while (it != thread_list.end()) {
|
2019-11-24 17:15:51 -08:00
|
|
|
const std::shared_ptr<Thread> current_thread = *it;
|
2019-11-14 16:13:18 -08:00
|
|
|
if (current_thread.get() == thread.get()) {
|
2019-11-21 07:03:37 -08:00
|
|
|
thread_list.erase(it);
|
2019-11-14 16:13:18 -08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::vector<std::shared_ptr<Thread>> Process::GetConditionVariableThreads(
|
|
|
|
const VAddr cond_var_addr) {
|
|
|
|
std::vector<std::shared_ptr<Thread>> result{};
|
|
|
|
std::list<std::shared_ptr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
|
2019-11-21 07:03:37 -08:00
|
|
|
auto it = thread_list.begin();
|
|
|
|
while (it != thread_list.end()) {
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<Thread> current_thread = *it;
|
2019-11-21 07:03:37 -08:00
|
|
|
result.push_back(current_thread);
|
2019-11-14 16:13:18 -08:00
|
|
|
++it;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-03-20 15:53:48 -07:00
|
|
|
void Process::RegisterThread(const Thread* thread) {
|
|
|
|
thread_list.push_back(thread);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Process::UnregisterThread(const Thread* thread) {
|
|
|
|
thread_list.remove(thread);
|
|
|
|
}
|
|
|
|
|
2018-12-04 16:08:56 -08:00
|
|
|
ResultCode Process::ClearSignalState() {
|
|
|
|
if (status == ProcessStatus::Exited) {
|
|
|
|
LOG_ERROR(Kernel, "called on a terminated process instance.");
|
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_signaled) {
|
|
|
|
LOG_ERROR(Kernel, "called on a process instance that isn't signaled.");
|
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
is_signaled = false;
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
|
|
|
|
std::size_t code_size) {
|
2018-09-22 17:09:32 -07:00
|
|
|
program_id = metadata.GetTitleID();
|
2018-12-27 18:14:59 -08:00
|
|
|
ideal_core = metadata.GetMainThreadCore();
|
2018-09-29 16:13:46 -07:00
|
|
|
is_64bit_process = metadata.Is64BitProgram();
|
2019-07-07 09:42:54 -07:00
|
|
|
system_resource_size = metadata.GetSystemResourceSize();
|
2020-04-08 19:19:12 -07:00
|
|
|
image_size = code_size;
|
|
|
|
|
|
|
|
// Initialize proces address space
|
|
|
|
if (const ResultCode result{
|
|
|
|
page_table->InitializeForProcess(metadata.GetAddressSpaceType(), false, 0x8000000,
|
|
|
|
code_size, Memory::MemoryManager::Pool::Application)};
|
|
|
|
result.IsError()) {
|
|
|
|
return result;
|
|
|
|
}
|
2017-05-05 23:11:06 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
// Map process code region
|
|
|
|
if (const ResultCode result{page_table->MapProcessCode(
|
|
|
|
page_table->GetCodeRegionStart(), code_size / Memory::PageSize,
|
|
|
|
Memory::MemoryState::Code, Memory::MemoryPermission::None)};
|
|
|
|
result.IsError()) {
|
|
|
|
return result;
|
|
|
|
}
|
2015-07-19 11:18:57 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
// Initialize process capabilities
|
|
|
|
const auto& caps{metadata.GetKernelCapabilities()};
|
|
|
|
if (const ResultCode result{
|
|
|
|
capabilities.InitializeForUserProcess(caps.data(), caps.size(), *page_table)};
|
|
|
|
result.IsError()) {
|
|
|
|
return result;
|
2019-02-25 07:13:52 -08:00
|
|
|
}
|
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
// Set memory usage capacity
|
|
|
|
switch (metadata.GetAddressSpaceType()) {
|
|
|
|
case FileSys::ProgramAddressSpaceType::Is32Bit:
|
|
|
|
case FileSys::ProgramAddressSpaceType::Is36Bit:
|
|
|
|
case FileSys::ProgramAddressSpaceType::Is39Bit:
|
|
|
|
memory_usage_capacity = page_table->GetHeapRegionEnd() - page_table->GetHeapRegionStart();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
|
|
|
|
memory_usage_capacity = page_table->GetHeapRegionEnd() - page_table->GetHeapRegionStart() +
|
|
|
|
page_table->GetAliasRegionEnd() - page_table->GetAliasRegionStart();
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set initial resource limits
|
|
|
|
resource_limit->SetLimitValue(
|
|
|
|
ResourceType::PhysicalMemory,
|
|
|
|
kernel.MemoryManager().GetSize(Memory::MemoryManager::Pool::Application));
|
|
|
|
resource_limit->SetLimitValue(ResourceType::Threads, 608);
|
|
|
|
resource_limit->SetLimitValue(ResourceType::Events, 700);
|
|
|
|
resource_limit->SetLimitValue(ResourceType::TransferMemory, 128);
|
|
|
|
resource_limit->SetLimitValue(ResourceType::Sessions, 894);
|
|
|
|
ASSERT(resource_limit->Reserve(ResourceType::PhysicalMemory, code_size));
|
|
|
|
|
|
|
|
// Create TLS region
|
|
|
|
tls_region_address = CreateTLSRegion();
|
|
|
|
|
2019-02-25 07:13:52 -08:00
|
|
|
return handle_table.SetSize(capabilities.GetHandleTableSize());
|
2015-05-03 20:01:16 -07:00
|
|
|
}
|
|
|
|
|
2019-04-09 14:03:04 -07:00
|
|
|
void Process::Run(s32 main_thread_priority, u64 stack_size) {
|
2019-07-07 01:13:56 -07:00
|
|
|
AllocateMainThreadStack(stack_size);
|
2017-05-05 23:11:06 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
const std::size_t heap_capacity{memory_usage_capacity - main_thread_stack_size - image_size};
|
|
|
|
ASSERT(!page_table->SetHeapCapacity(heap_capacity).IsError());
|
2019-07-07 01:13:56 -07:00
|
|
|
|
2018-12-04 16:08:56 -08:00
|
|
|
ChangeStatus(ProcessStatus::Running);
|
2017-10-09 20:56:20 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
SetupMainThread(*this, kernel, main_thread_priority, main_thread_stack_top);
|
|
|
|
resource_limit->Reserve(ResourceType::Threads, 1);
|
|
|
|
resource_limit->Reserve(ResourceType::PhysicalMemory, main_thread_stack_size);
|
2017-09-30 11:15:09 -07:00
|
|
|
}
|
2017-09-24 08:12:16 -07:00
|
|
|
|
2018-09-20 23:06:47 -07:00
|
|
|
void Process::PrepareForTermination() {
|
2018-12-04 16:08:56 -08:00
|
|
|
ChangeStatus(ProcessStatus::Exiting);
|
2018-09-20 23:06:47 -07:00
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
const auto stop_threads = [this](const std::vector<std::shared_ptr<Thread>>& thread_list) {
|
2018-09-20 23:06:47 -07:00
|
|
|
for (auto& thread : thread_list) {
|
2018-10-03 15:47:57 -07:00
|
|
|
if (thread->GetOwnerProcess() != this)
|
2018-09-20 23:06:47 -07:00
|
|
|
continue;
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
if (thread.get() == system.CurrentScheduler().GetCurrentThread())
|
2018-09-20 23:06:47 -07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// TODO(Subv): When are the other running/ready threads terminated?
|
2019-04-17 04:21:19 -07:00
|
|
|
ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynch,
|
2018-09-20 23:06:47 -07:00
|
|
|
"Exiting processes with non-waiting threads is currently unimplemented");
|
|
|
|
|
|
|
|
thread->Stop();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-03-29 14:12:02 -07:00
|
|
|
stop_threads(system.GlobalScheduler().GetThreadList());
|
2018-12-04 16:08:56 -08:00
|
|
|
|
2019-07-07 01:19:16 -07:00
|
|
|
FreeTLSRegion(tls_region_address);
|
|
|
|
tls_region_address = 0;
|
|
|
|
|
2018-12-04 16:08:56 -08:00
|
|
|
ChangeStatus(ProcessStatus::Exited);
|
2018-09-20 23:06:47 -07:00
|
|
|
}
|
|
|
|
|
2018-09-20 22:26:29 -07:00
|
|
|
/**
|
2019-06-05 11:32:33 -07:00
|
|
|
* Attempts to find a TLS page that contains a free slot for
|
|
|
|
* use by a thread.
|
|
|
|
*
|
|
|
|
* @returns If a page with an available slot is found, then an iterator
|
|
|
|
* pointing to the page is returned. Otherwise the end iterator
|
|
|
|
* is returned instead.
|
2018-09-20 22:26:29 -07:00
|
|
|
*/
|
2019-06-05 11:32:33 -07:00
|
|
|
static auto FindTLSPageWithAvailableSlots(std::vector<TLSPage>& tls_pages) {
|
|
|
|
return std::find_if(tls_pages.begin(), tls_pages.end(),
|
|
|
|
[](const auto& page) { return page.HasAvailableSlots(); });
|
2018-09-20 22:26:29 -07:00
|
|
|
}
|
|
|
|
|
2019-06-05 11:32:33 -07:00
|
|
|
VAddr Process::CreateTLSRegion() {
|
2020-04-08 19:19:12 -07:00
|
|
|
if (auto tls_page_iter{FindTLSPageWithAvailableSlots(tls_pages)};
|
|
|
|
tls_page_iter != tls_pages.cend()) {
|
|
|
|
return *tls_page_iter->ReserveSlot();
|
|
|
|
}
|
2018-09-20 22:26:29 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
Memory::Page* const tls_page_ptr{kernel.GetUserSlabHeapPages().Allocate()};
|
|
|
|
ASSERT(tls_page_ptr);
|
2018-09-20 22:26:29 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
const VAddr start{page_table->GetKernelMapRegionStart()};
|
|
|
|
const VAddr size{page_table->GetKernelMapRegionEnd() - start};
|
|
|
|
const PAddr tls_map_addr{system.DeviceMemory().GetPhysicalAddr(tls_page_ptr)};
|
|
|
|
const VAddr tls_page_addr{
|
|
|
|
page_table
|
|
|
|
->AllocateAndMapMemory(1, Memory::PageSize, true, start, size / Memory::PageSize,
|
|
|
|
Memory::MemoryState::ThreadLocal,
|
|
|
|
Memory::MemoryPermission::ReadAndWrite, tls_map_addr)
|
|
|
|
.ValueOr(0)};
|
2018-09-20 22:26:29 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
ASSERT(tls_page_addr);
|
2018-09-20 22:26:29 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
std::memset(tls_page_ptr, 0, Memory::PageSize);
|
|
|
|
tls_pages.emplace_back(tls_page_addr);
|
2018-09-20 22:26:29 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
const auto reserve_result{tls_pages.back().ReserveSlot()};
|
|
|
|
ASSERT(reserve_result.has_value());
|
2018-09-20 22:26:29 -07:00
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
return *reserve_result;
|
2018-09-20 22:26:29 -07:00
|
|
|
}
|
|
|
|
|
2019-06-05 11:32:33 -07:00
|
|
|
void Process::FreeTLSRegion(VAddr tls_address) {
|
2020-03-31 12:10:44 -07:00
|
|
|
const VAddr aligned_address = Common::AlignDown(tls_address, Core::Memory::PAGE_SIZE);
|
2019-06-05 11:32:33 -07:00
|
|
|
auto iter =
|
|
|
|
std::find_if(tls_pages.begin(), tls_pages.end(), [aligned_address](const auto& page) {
|
|
|
|
return page.GetBaseAddress() == aligned_address;
|
|
|
|
});
|
|
|
|
|
|
|
|
// Something has gone very wrong if we're freeing a region
|
|
|
|
// with no actual page available.
|
|
|
|
ASSERT(iter != tls_pages.cend());
|
2018-09-20 22:26:29 -07:00
|
|
|
|
2019-06-05 11:32:33 -07:00
|
|
|
iter->ReleaseSlot(tls_address);
|
2018-09-20 22:26:29 -07:00
|
|
|
}
|
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
void Process::LoadModule(CodeSet code_set, VAddr base_addr) {
|
|
|
|
const auto ReprotectSegment = [&](const CodeSet::Segment& segment,
|
|
|
|
Memory::MemoryPermission permission) {
|
|
|
|
page_table->SetCodeMemoryPermission(segment.addr + base_addr, segment.size, permission);
|
2017-09-24 08:12:16 -07:00
|
|
|
};
|
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
system.Memory().WriteBlock(*this, base_addr, code_set.memory.data(), code_set.memory.size());
|
|
|
|
|
|
|
|
ReprotectSegment(code_set.CodeSegment(), Memory::MemoryPermission::ReadAndExecute);
|
|
|
|
ReprotectSegment(code_set.RODataSegment(), Memory::MemoryPermission::Read);
|
|
|
|
ReprotectSegment(code_set.DataSegment(), Memory::MemoryPermission::ReadAndWrite);
|
2015-05-03 20:01:16 -07:00
|
|
|
}
|
|
|
|
|
2019-03-12 16:03:26 -07:00
|
|
|
Process::Process(Core::System& system)
|
2020-04-08 19:19:12 -07:00
|
|
|
: SynchronizationObject{system.Kernel()}, page_table{std::make_unique<Memory::PageTable>(
|
|
|
|
system)},
|
2019-04-16 02:07:43 -07:00
|
|
|
address_arbiter{system}, mutex{system}, system{system} {}
|
2019-03-13 21:29:54 -07:00
|
|
|
|
2019-03-07 15:48:14 -08:00
|
|
|
Process::~Process() = default;
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2018-12-04 16:08:56 -08:00
|
|
|
void Process::Acquire(Thread* thread) {
|
|
|
|
ASSERT_MSG(!ShouldWait(thread), "Object unavailable!");
|
|
|
|
}
|
|
|
|
|
2019-04-01 15:19:42 -07:00
|
|
|
bool Process::ShouldWait(const Thread* thread) const {
|
2018-12-04 16:08:56 -08:00
|
|
|
return !is_signaled;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Process::ChangeStatus(ProcessStatus new_status) {
|
|
|
|
if (status == new_status) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = new_status;
|
|
|
|
is_signaled = true;
|
2020-02-11 13:36:39 -08:00
|
|
|
Signal();
|
2018-12-04 16:08:56 -08:00
|
|
|
}
|
|
|
|
|
2020-04-08 19:19:12 -07:00
|
|
|
ResultCode Process::AllocateMainThreadStack(std::size_t stack_size) {
|
|
|
|
ASSERT(stack_size);
|
|
|
|
|
2019-07-07 01:13:56 -07:00
|
|
|
// The kernel always ensures that the given stack size is page aligned.
|
2020-04-08 19:19:12 -07:00
|
|
|
main_thread_stack_size = Common::AlignUp(stack_size, Memory::PageSize);
|
|
|
|
|
|
|
|
const VAddr start{page_table->GetStackRegionStart()};
|
|
|
|
const std::size_t size{page_table->GetStackRegionEnd() - start};
|
|
|
|
|
|
|
|
CASCADE_RESULT(main_thread_stack_top,
|
|
|
|
page_table->AllocateAndMapMemory(
|
|
|
|
main_thread_stack_size / Memory::PageSize, Memory::PageSize, false, start,
|
|
|
|
size / Memory::PageSize, Memory::MemoryState::Stack,
|
|
|
|
Memory::MemoryPermission::ReadAndWrite));
|
|
|
|
|
|
|
|
main_thread_stack_top += main_thread_stack_size;
|
|
|
|
|
|
|
|
return RESULT_SUCCESS;
|
2019-07-07 01:13:56 -07:00
|
|
|
}
|
|
|
|
|
2018-01-01 11:38:34 -08:00
|
|
|
} // namespace Kernel
|