2015-05-03 23:01:16 -04:00
|
|
|
// Copyright 2015 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
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"
|
2018-09-21 02:06:47 -04:00
|
|
|
#include "core/core.h"
|
2020-04-08 22:19:12 -04:00
|
|
|
#include "core/device_memory.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"
|
2018-12-04 19:08:56 -05:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2020-12-02 21:08:35 -05:00
|
|
|
#include "core/hle/kernel/k_scheduler.h"
|
2018-08-28 12:30:33 -04:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2020-04-08 22:19:12 -04: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-21 02:52:38 -04:00
|
|
|
#include "core/hle/kernel/process.h"
|
2015-05-12 16:25:15 -04:00
|
|
|
#include "core/hle/kernel/resource_limit.h"
|
2015-05-03 23:01:16 -04:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2020-03-03 10:04:37 -05:00
|
|
|
#include "core/hle/lock.h"
|
2015-05-12 21:38:29 -04:00
|
|
|
#include "core/memory.h"
|
2018-11-13 12:25:43 -05:00
|
|
|
#include "core/settings.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
|
|
|
|
*/
|
2020-02-24 21:04:12 -05:00
|
|
|
void SetupMainThread(Core::System& system, Process& owner_process, u32 priority, VAddr stack_top) {
|
2020-04-08 22:19:12 -04:00
|
|
|
const VAddr entry_point = owner_process.PageTable().GetCodeRegionStart();
|
2020-02-24 21:04:12 -05:00
|
|
|
ThreadType type = THREADTYPE_USER;
|
|
|
|
auto thread_res = Thread::Create(system, type, "main", entry_point, priority, 0,
|
|
|
|
owner_process.GetIdealCore(), stack_top, &owner_process);
|
2018-12-27 20:28:15 -05:00
|
|
|
|
2019-11-24 20:15:51 -05:00
|
|
|
std::shared_ptr<Thread> thread = std::move(thread_res).Unwrap();
|
2018-12-27 20:28:15 -05:00
|
|
|
|
|
|
|
// Register 1 must be a handle to the main thread
|
2019-04-14 06:06:04 -04:00
|
|
|
const Handle thread_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
|
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
|
|
|
|
2020-02-24 21:04:12 -05:00
|
|
|
auto& kernel = system.Kernel();
|
2018-12-27 20:28:15 -05:00
|
|
|
// Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
|
2020-02-24 21:04:12 -05:00
|
|
|
{
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock{kernel};
|
2020-12-28 16:16:43 -05:00
|
|
|
thread->SetState(ThreadState::Runnable);
|
2020-02-24 21:04:12 -05:00
|
|
|
}
|
2018-12-27 20:28:15 -05:00
|
|
|
}
|
|
|
|
} // Anonymous namespace
|
2015-05-03 23:01:16 -04:00
|
|
|
|
2019-06-05 14:32:33 -04: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 15:10:44 -04:00
|
|
|
static constexpr std::size_t num_slot_entries =
|
|
|
|
Core::Memory::PAGE_SIZE / Core::Memory::TLS_ENTRY_SIZE;
|
2019-06-05 14:32:33 -04: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 15:10:44 -04:00
|
|
|
return base_address + (i * Core::Memory::TLS_ENTRY_SIZE);
|
2019-06-05 14:32:33 -04: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 15:10:44 -04:00
|
|
|
ASSERT((address % Core::Memory::TLS_ENTRY_SIZE) == 0);
|
2019-06-05 14:32:33 -04:00
|
|
|
|
2020-03-31 15:10:44 -04:00
|
|
|
const std::size_t index = (address - base_address) / Core::Memory::TLS_ENTRY_SIZE;
|
2019-06-05 14:32:33 -04:00
|
|
|
is_slot_used[index] = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool IsWithinPage(VAddr address) const {
|
2020-03-31 15:10:44 -04:00
|
|
|
return base_address <= address && address < base_address + Core::Memory::PAGE_SIZE;
|
2019-06-05 14:32:33 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
VAddr base_address;
|
|
|
|
std::bitset<num_slot_entries> is_slot_used;
|
|
|
|
};
|
|
|
|
|
2019-11-24 20:15:51 -05:00
|
|
|
std::shared_ptr<Process> Process::Create(Core::System& system, std::string name, ProcessType type) {
|
2019-03-07 18:48:14 -05:00
|
|
|
auto& kernel = system.Kernel();
|
2015-05-03 23:01:16 -04:00
|
|
|
|
2019-11-24 20:15:51 -05:00
|
|
|
std::shared_ptr<Process> process = std::make_shared<Process>(system);
|
2017-09-30 14:15:09 -04:00
|
|
|
process->name = std::move(name);
|
2020-04-08 22:19:12 -04:00
|
|
|
process->resource_limit = ResourceLimit::Create(kernel);
|
2018-01-01 14:38:34 -05:00
|
|
|
process->status = ProcessStatus::Created;
|
2018-03-13 17:49:59 -04:00
|
|
|
process->program_id = 0;
|
2019-06-10 00:28:33 -04:00
|
|
|
process->process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()
|
|
|
|
: kernel.CreateNewUserProcessID();
|
2018-12-19 23:50:20 -05:00
|
|
|
process->capabilities.InitializeForMetadatalessProcess();
|
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;
|
|
|
|
std::generate(process->random_entropy.begin(), process->random_entropy.end(),
|
|
|
|
[&] { return distribution(rng); });
|
|
|
|
|
2018-08-28 12:30:33 -04:00
|
|
|
kernel.AppendNewProcess(process);
|
2015-05-03 23:01:16 -04:00
|
|
|
return process;
|
|
|
|
}
|
|
|
|
|
2019-11-24 20:15:51 -05:00
|
|
|
std::shared_ptr<ResourceLimit> Process::GetResourceLimit() const {
|
2018-12-04 00:29:15 -05:00
|
|
|
return resource_limit;
|
|
|
|
}
|
|
|
|
|
2019-06-09 18:20:20 -04:00
|
|
|
u64 Process::GetTotalPhysicalMemoryAvailable() const {
|
2020-10-20 22:07:39 -04:00
|
|
|
const u64 capacity{resource_limit->GetCurrentResourceValue(ResourceType::PhysicalMemory) +
|
|
|
|
page_table->GetTotalHeapSize() + GetSystemResourceSize() + image_size +
|
|
|
|
main_thread_stack_size};
|
2020-04-08 22:19:12 -04:00
|
|
|
|
|
|
|
if (capacity < memory_usage_capacity) {
|
|
|
|
return capacity;
|
|
|
|
}
|
|
|
|
|
|
|
|
return memory_usage_capacity;
|
2019-06-09 18:20:20 -04:00
|
|
|
}
|
|
|
|
|
2019-07-07 14:48:11 -04:00
|
|
|
u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
|
|
|
|
return GetTotalPhysicalMemoryAvailable() - GetSystemResourceSize();
|
2019-06-09 18:20:20 -04:00
|
|
|
}
|
|
|
|
|
2019-03-28 22:59:17 -04:00
|
|
|
u64 Process::GetTotalPhysicalMemoryUsed() const {
|
2020-06-10 00:49:00 -04:00
|
|
|
return image_size + main_thread_stack_size + page_table->GetTotalHeapSize() +
|
|
|
|
GetSystemResourceSize();
|
2019-03-28 22:59:17 -04:00
|
|
|
}
|
|
|
|
|
2019-07-07 14:48:11 -04:00
|
|
|
u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {
|
|
|
|
return GetTotalPhysicalMemoryUsed() - GetSystemResourceUsage();
|
2019-06-09 18:20:20 -04:00
|
|
|
}
|
|
|
|
|
2019-03-20 18:53:48 -04: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 19:08:56 -05:00
|
|
|
ResultCode Process::ClearSignalState() {
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock(system.Kernel());
|
2018-12-04 19:08:56 -05:00
|
|
|
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 22:19:12 -04:00
|
|
|
ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
|
|
|
|
std::size_t code_size) {
|
2018-09-22 20:09:32 -04:00
|
|
|
program_id = metadata.GetTitleID();
|
2018-12-27 21:14:59 -05:00
|
|
|
ideal_core = metadata.GetMainThreadCore();
|
2018-09-29 19:13:46 -04:00
|
|
|
is_64bit_process = metadata.Is64BitProgram();
|
2019-07-07 12:42:54 -04:00
|
|
|
system_resource_size = metadata.GetSystemResourceSize();
|
2020-04-08 22:19:12 -04: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-06 02:11:06 -04:00
|
|
|
|
2020-04-08 22:19:12 -04: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 14:18:57 -04:00
|
|
|
|
2020-04-08 22:19:12 -04: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 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:
|
|
|
|
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,
|
2020-10-20 22:07:39 -04:00
|
|
|
kernel.MemoryManager().GetSize(Memory::MemoryManager::Pool::Application));
|
2020-04-08 22:19:12 -04:00
|
|
|
resource_limit->SetLimitValue(ResourceType::Threads, 608);
|
|
|
|
resource_limit->SetLimitValue(ResourceType::Events, 700);
|
|
|
|
resource_limit->SetLimitValue(ResourceType::TransferMemory, 128);
|
|
|
|
resource_limit->SetLimitValue(ResourceType::Sessions, 894);
|
2020-10-20 22:07:39 -04:00
|
|
|
ASSERT(resource_limit->Reserve(ResourceType::PhysicalMemory, code_size));
|
2020-04-08 22:19:12 -04:00
|
|
|
|
|
|
|
// Create TLS region
|
|
|
|
tls_region_address = CreateTLSRegion();
|
|
|
|
|
2019-02-25 10:13:52 -05:00
|
|
|
return handle_table.SetSize(capabilities.GetHandleTableSize());
|
2015-05-03 23:01:16 -04:00
|
|
|
}
|
|
|
|
|
2019-04-09 17:03:04 -04:00
|
|
|
void Process::Run(s32 main_thread_priority, u64 stack_size) {
|
2019-07-07 04:13:56 -04:00
|
|
|
AllocateMainThreadStack(stack_size);
|
2017-05-06 02:11:06 -04:00
|
|
|
|
2020-04-08 22:19:12 -04: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 04:13:56 -04:00
|
|
|
|
2018-12-04 19:08:56 -05:00
|
|
|
ChangeStatus(ProcessStatus::Running);
|
2017-10-09 23:56:20 -04:00
|
|
|
|
2020-10-20 22:07:39 -04:00
|
|
|
SetupMainThread(system, *this, main_thread_priority, main_thread_stack_top);
|
2020-04-08 22:19:12 -04:00
|
|
|
resource_limit->Reserve(ResourceType::Threads, 1);
|
2020-10-20 22:07:39 -04:00
|
|
|
resource_limit->Reserve(ResourceType::PhysicalMemory, main_thread_stack_size);
|
2017-09-30 14:15:09 -04:00
|
|
|
}
|
2017-09-24 11:12:16 -04:00
|
|
|
|
2018-09-21 02:06:47 -04:00
|
|
|
void Process::PrepareForTermination() {
|
2018-12-04 19:08:56 -05:00
|
|
|
ChangeStatus(ProcessStatus::Exiting);
|
2018-09-21 02:06:47 -04:00
|
|
|
|
2019-11-24 20:15:51 -05:00
|
|
|
const auto stop_threads = [this](const std::vector<std::shared_ptr<Thread>>& thread_list) {
|
2018-09-21 02:06:47 -04:00
|
|
|
for (auto& thread : thread_list) {
|
2018-10-03 18:47:57 -04:00
|
|
|
if (thread->GetOwnerProcess() != this)
|
2018-09-21 02:06:47 -04:00
|
|
|
continue;
|
|
|
|
|
2020-12-02 21:08:35 -05:00
|
|
|
if (thread.get() == kernel.CurrentScheduler()->GetCurrentThread())
|
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");
|
|
|
|
|
|
|
|
thread->Stop();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-12-02 21:08:35 -05:00
|
|
|
stop_threads(system.GlobalSchedulerContext().GetThreadList());
|
2018-12-04 19:08:56 -05:00
|
|
|
|
2019-07-07 04:19:16 -04:00
|
|
|
FreeTLSRegion(tls_region_address);
|
|
|
|
tls_region_address = 0;
|
|
|
|
|
2018-12-04 19:08:56 -05:00
|
|
|
ChangeStatus(ProcessStatus::Exited);
|
2018-09-21 02:06:47 -04:00
|
|
|
}
|
|
|
|
|
2018-09-21 01:26:29 -04:00
|
|
|
/**
|
2019-06-05 14:32:33 -04: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-21 01:26:29 -04:00
|
|
|
*/
|
2019-06-05 14:32:33 -04: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-21 01:26:29 -04:00
|
|
|
}
|
|
|
|
|
2019-06-05 14:32:33 -04:00
|
|
|
VAddr Process::CreateTLSRegion() {
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock(system.Kernel());
|
2020-04-08 22:19:12 -04:00
|
|
|
if (auto tls_page_iter{FindTLSPageWithAvailableSlots(tls_pages)};
|
|
|
|
tls_page_iter != tls_pages.cend()) {
|
|
|
|
return *tls_page_iter->ReserveSlot();
|
|
|
|
}
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
Memory::Page* const tls_page_ptr{kernel.GetUserSlabHeapPages().Allocate()};
|
|
|
|
ASSERT(tls_page_ptr);
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2020-04-08 22:19:12 -04: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)
|
2020-10-20 22:07:39 -04:00
|
|
|
.ValueOr(0)};
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
ASSERT(tls_page_addr);
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
std::memset(tls_page_ptr, 0, Memory::PageSize);
|
|
|
|
tls_pages.emplace_back(tls_page_addr);
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
const auto reserve_result{tls_pages.back().ReserveSlot()};
|
|
|
|
ASSERT(reserve_result.has_value());
|
2018-09-21 01:26:29 -04:00
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
return *reserve_result;
|
2018-09-21 01:26:29 -04:00
|
|
|
}
|
|
|
|
|
2019-06-05 14:32:33 -04:00
|
|
|
void Process::FreeTLSRegion(VAddr tls_address) {
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock(system.Kernel());
|
2020-03-31 15:10:44 -04:00
|
|
|
const VAddr aligned_address = Common::AlignDown(tls_address, Core::Memory::PAGE_SIZE);
|
2019-06-05 14:32:33 -04: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-21 01:26:29 -04:00
|
|
|
|
2019-06-05 14:32:33 -04:00
|
|
|
iter->ReleaseSlot(tls_address);
|
2018-09-21 01:26:29 -04:00
|
|
|
}
|
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
void Process::LoadModule(CodeSet code_set, VAddr base_addr) {
|
2020-03-03 10:04:37 -05:00
|
|
|
std::lock_guard lock{HLE::g_hle_lock};
|
2020-04-08 22:19:12 -04:00
|
|
|
const auto ReprotectSegment = [&](const CodeSet::Segment& segment,
|
|
|
|
Memory::MemoryPermission permission) {
|
|
|
|
page_table->SetCodeMemoryPermission(segment.addr + base_addr, segment.size, permission);
|
2017-09-24 11:12:16 -04:00
|
|
|
};
|
|
|
|
|
2020-04-08 22:19:12 -04: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 23:01:16 -04:00
|
|
|
}
|
|
|
|
|
2020-12-22 01:36:53 -05:00
|
|
|
bool Process::IsSignaled() const {
|
|
|
|
ASSERT(kernel.GlobalSchedulerContext().IsLocked());
|
|
|
|
return is_signaled;
|
|
|
|
}
|
|
|
|
|
2019-03-12 19:03:26 -04:00
|
|
|
Process::Process(Core::System& system)
|
2020-12-30 04:14:02 -05:00
|
|
|
: KSynchronizationObject{system.Kernel()},
|
|
|
|
page_table{std::make_unique<Memory::PageTable>(system)}, handle_table{system.Kernel()},
|
|
|
|
address_arbiter{system}, condition_var{system}, system{system} {}
|
2019-03-14 00:29:54 -04:00
|
|
|
|
2019-03-07 18:48:14 -05:00
|
|
|
Process::~Process() = default;
|
2015-05-03 23:01:16 -04:00
|
|
|
|
2018-12-04 19:08:56 -05:00
|
|
|
void Process::ChangeStatus(ProcessStatus new_status) {
|
|
|
|
if (status == new_status) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = new_status;
|
|
|
|
is_signaled = true;
|
2020-12-22 01:36:53 -05:00
|
|
|
NotifyAvailable();
|
2018-12-04 19:08:56 -05:00
|
|
|
}
|
|
|
|
|
2020-04-08 22:19:12 -04:00
|
|
|
ResultCode Process::AllocateMainThreadStack(std::size_t stack_size) {
|
|
|
|
ASSERT(stack_size);
|
|
|
|
|
2019-07-07 04:13:56 -04:00
|
|
|
// The kernel always ensures that the given stack size is page aligned.
|
2020-04-08 22:19:12 -04: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 04:13:56 -04:00
|
|
|
}
|
|
|
|
|
2018-01-01 14:38:34 -05:00
|
|
|
} // namespace Kernel
|