2015-05-04 03:01:16 +00:00
|
|
|
// Copyright 2015 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2018-01-01 19:38:34 +00:00
|
|
|
#include <algorithm>
|
2016-04-05 12:29:55 +00:00
|
|
|
#include <memory>
|
2018-11-20 22:46:17 +00:00
|
|
|
#include <random>
|
2019-03-28 22:24:56 +00:00
|
|
|
#include "common/alignment.h"
|
2015-05-04 03:01:16 +00:00
|
|
|
#include "common/assert.h"
|
2015-05-08 19:51:48 +00:00
|
|
|
#include "common/logging/log.h"
|
2018-09-21 06:06:47 +00:00
|
|
|
#include "core/core.h"
|
2018-09-23 00:09:32 +00:00
|
|
|
#include "core/file_sys/program_metadata.h"
|
2019-03-20 16:40:09 +00:00
|
|
|
#include "core/hle/kernel/code_set.h"
|
2018-12-05 00:08:56 +00:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2018-08-28 16:30:33 +00:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2016-09-21 06:52:38 +00:00
|
|
|
#include "core/hle/kernel/process.h"
|
2015-05-12 20:25:15 +00:00
|
|
|
#include "core/hle/kernel/resource_limit.h"
|
2018-09-21 06:06:47 +00:00
|
|
|
#include "core/hle/kernel/scheduler.h"
|
2015-05-04 03:01:16 +00:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2015-07-10 01:52:15 +00:00
|
|
|
#include "core/hle/kernel/vm_manager.h"
|
2015-05-13 01:38:29 +00:00
|
|
|
#include "core/memory.h"
|
2018-11-13 17:25:43 +00:00
|
|
|
#include "core/settings.h"
|
2015-05-04 03:01:16 +00:00
|
|
|
|
|
|
|
namespace Kernel {
|
2018-12-28 01:28:15 +00: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
|
|
|
|
*/
|
2019-04-09 21:03:04 +00:00
|
|
|
void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority) {
|
|
|
|
const auto& vm_manager = owner_process.VMManager();
|
|
|
|
const VAddr entry_point = vm_manager.GetCodeRegionBaseAddress();
|
|
|
|
const VAddr stack_top = vm_manager.GetTLSIORegionEndAddress();
|
2018-12-28 02:20:49 +00:00
|
|
|
auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0,
|
|
|
|
owner_process.GetIdealCore(), stack_top, owner_process);
|
2018-12-28 01:28:15 +00:00
|
|
|
|
|
|
|
SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
|
|
|
|
|
|
|
|
// Register 1 must be a handle to the main thread
|
2019-04-14 10:06:04 +00:00
|
|
|
const Handle thread_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
|
|
|
|
thread->GetContext().cpu_registers[1] = thread_handle;
|
2018-12-28 01:28:15 +00:00
|
|
|
|
|
|
|
// Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
|
|
|
|
thread->ResumeFromWait();
|
|
|
|
}
|
|
|
|
} // Anonymous namespace
|
2015-05-04 03:01:16 +00:00
|
|
|
|
2019-06-09 22:47:34 +00:00
|
|
|
SharedPtr<Process> Process::Create(Core::System& system, std::string name) {
|
2019-03-07 23:48:14 +00:00
|
|
|
auto& kernel = system.Kernel();
|
2015-05-04 03:01:16 +00:00
|
|
|
|
2019-03-07 23:48:14 +00:00
|
|
|
SharedPtr<Process> process(new Process(system));
|
2017-09-30 18:15:09 +00:00
|
|
|
process->name = std::move(name);
|
2018-11-19 17:54:06 +00:00
|
|
|
process->resource_limit = kernel.GetSystemResourceLimit();
|
2018-01-01 19:38:34 +00:00
|
|
|
process->status = ProcessStatus::Created;
|
2018-03-13 21:49:59 +00:00
|
|
|
process->program_id = 0;
|
2018-08-28 16:30:33 +00:00
|
|
|
process->process_id = kernel.CreateNewProcessID();
|
2018-12-20 04:50:20 +00:00
|
|
|
process->capabilities.InitializeForMetadatalessProcess();
|
2015-05-08 20:53:19 +00:00
|
|
|
|
2018-11-13 17:25:43 +00: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 16:30:33 +00:00
|
|
|
kernel.AppendNewProcess(process);
|
2015-05-04 03:01:16 +00:00
|
|
|
return process;
|
|
|
|
}
|
|
|
|
|
2018-12-04 05:29:15 +00:00
|
|
|
SharedPtr<ResourceLimit> Process::GetResourceLimit() const {
|
|
|
|
return resource_limit;
|
|
|
|
}
|
|
|
|
|
2019-06-09 22:20:20 +00:00
|
|
|
u64 Process::GetTotalPhysicalMemoryAvailable() const {
|
|
|
|
return vm_manager.GetTotalPhysicalMemoryAvailable();
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 Process::GetTotalPhysicalMemoryAvailableWithoutMmHeap() const {
|
|
|
|
// TODO: Subtract the personal heap size from this when the
|
|
|
|
// personal heap is implemented.
|
|
|
|
return GetTotalPhysicalMemoryAvailable();
|
|
|
|
}
|
|
|
|
|
2019-03-29 02:59:17 +00:00
|
|
|
u64 Process::GetTotalPhysicalMemoryUsed() const {
|
|
|
|
return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size;
|
|
|
|
}
|
|
|
|
|
2019-06-09 22:20:20 +00:00
|
|
|
u64 Process::GetTotalPhysicalMemoryUsedWithoutMmHeap() const {
|
|
|
|
// TODO: Subtract the personal heap size from this when the
|
|
|
|
// personal heap is implemented.
|
|
|
|
return GetTotalPhysicalMemoryUsed();
|
|
|
|
}
|
|
|
|
|
2019-03-20 22:53:48 +00:00
|
|
|
void Process::RegisterThread(const Thread* thread) {
|
|
|
|
thread_list.push_back(thread);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Process::UnregisterThread(const Thread* thread) {
|
|
|
|
thread_list.remove(thread);
|
|
|
|
}
|
|
|
|
|
2018-12-05 00:08:56 +00: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;
|
|
|
|
}
|
|
|
|
|
2018-12-20 04:50:20 +00:00
|
|
|
ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
|
2018-09-23 00:09:32 +00:00
|
|
|
program_id = metadata.GetTitleID();
|
2018-12-28 02:14:59 +00:00
|
|
|
ideal_core = metadata.GetMainThreadCore();
|
2018-09-29 23:13:46 +00:00
|
|
|
is_64bit_process = metadata.Is64BitProgram();
|
2017-05-06 06:11:06 +00:00
|
|
|
|
2018-12-20 04:50:20 +00:00
|
|
|
vm_manager.Reset(metadata.GetAddressSpaceType());
|
2015-07-19 18:18:57 +00:00
|
|
|
|
2018-12-20 04:50:20 +00:00
|
|
|
const auto& caps = metadata.GetKernelCapabilities();
|
2019-02-25 15:13:52 +00:00
|
|
|
const auto capability_init_result =
|
|
|
|
capabilities.InitializeForUserProcess(caps.data(), caps.size(), vm_manager);
|
|
|
|
if (capability_init_result.IsError()) {
|
|
|
|
return capability_init_result;
|
|
|
|
}
|
|
|
|
|
|
|
|
return handle_table.SetSize(capabilities.GetHandleTableSize());
|
2015-05-04 03:01:16 +00:00
|
|
|
}
|
|
|
|
|
2019-04-09 21:03:04 +00:00
|
|
|
void Process::Run(s32 main_thread_priority, u64 stack_size) {
|
2019-03-28 22:24:56 +00:00
|
|
|
// The kernel always ensures that the given stack size is page aligned.
|
2019-03-28 22:30:58 +00:00
|
|
|
main_thread_stack_size = Common::AlignUp(stack_size, Memory::PAGE_SIZE);
|
2019-03-28 22:24:56 +00:00
|
|
|
|
2018-03-10 22:51:23 +00:00
|
|
|
// Allocate and map the main thread stack
|
|
|
|
// TODO(bunnei): This is heap area that should be allocated by the kernel and not mapped as part
|
|
|
|
// of the user address space.
|
2019-03-28 22:30:58 +00:00
|
|
|
const VAddr mapping_address = vm_manager.GetTLSIORegionEndAddress() - main_thread_stack_size;
|
2016-09-18 00:38:01 +00:00
|
|
|
vm_manager
|
2019-03-28 22:30:58 +00:00
|
|
|
.MapMemoryBlock(mapping_address, std::make_shared<std::vector<u8>>(main_thread_stack_size),
|
|
|
|
0, main_thread_stack_size, MemoryState::Stack)
|
2016-09-18 00:38:01 +00:00
|
|
|
.Unwrap();
|
2017-05-06 06:11:06 +00:00
|
|
|
|
2018-04-27 15:49:18 +00:00
|
|
|
vm_manager.LogLayout();
|
2018-12-05 00:08:56 +00:00
|
|
|
ChangeStatus(ProcessStatus::Running);
|
2017-10-10 03:56:20 +00:00
|
|
|
|
2019-04-09 21:03:04 +00:00
|
|
|
SetupMainThread(*this, kernel, main_thread_priority);
|
2017-09-30 18:15:09 +00:00
|
|
|
}
|
2017-09-24 15:12:16 +00:00
|
|
|
|
2018-09-21 06:06:47 +00:00
|
|
|
void Process::PrepareForTermination() {
|
2018-12-05 00:08:56 +00:00
|
|
|
ChangeStatus(ProcessStatus::Exiting);
|
2018-09-21 06:06:47 +00:00
|
|
|
|
|
|
|
const auto stop_threads = [this](const std::vector<SharedPtr<Thread>>& thread_list) {
|
|
|
|
for (auto& thread : thread_list) {
|
2018-10-03 22:47:57 +00:00
|
|
|
if (thread->GetOwnerProcess() != this)
|
2018-09-21 06:06:47 +00:00
|
|
|
continue;
|
|
|
|
|
2019-03-12 23:03:26 +00:00
|
|
|
if (thread == system.CurrentScheduler().GetCurrentThread())
|
2018-09-21 06:06:47 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// TODO(Subv): When are the other running/ready threads terminated?
|
2019-04-17 11:21:19 +00:00
|
|
|
ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynch,
|
2018-09-21 06:06:47 +00:00
|
|
|
"Exiting processes with non-waiting threads is currently unimplemented");
|
|
|
|
|
|
|
|
thread->Stop();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-10-15 13:25:11 +00:00
|
|
|
stop_threads(system.Scheduler(0).GetThreadList());
|
|
|
|
stop_threads(system.Scheduler(1).GetThreadList());
|
|
|
|
stop_threads(system.Scheduler(2).GetThreadList());
|
|
|
|
stop_threads(system.Scheduler(3).GetThreadList());
|
2018-12-05 00:08:56 +00:00
|
|
|
|
|
|
|
ChangeStatus(ProcessStatus::Exited);
|
2018-09-21 06:06:47 +00:00
|
|
|
}
|
|
|
|
|
2018-09-21 05:26:29 +00:00
|
|
|
/**
|
|
|
|
* Finds a free location for the TLS section of a thread.
|
|
|
|
* @param tls_slots The TLS page array of the thread's owner process.
|
|
|
|
* Returns a tuple of (page, slot, alloc_needed) where:
|
|
|
|
* page: The index of the first allocated TLS page that has free slots.
|
|
|
|
* slot: The index of the first free slot in the indicated page.
|
|
|
|
* alloc_needed: Whether there's a need to allocate a new TLS page (All pages are full).
|
|
|
|
*/
|
|
|
|
static std::tuple<std::size_t, std::size_t, bool> FindFreeThreadLocalSlot(
|
|
|
|
const std::vector<std::bitset<8>>& tls_slots) {
|
|
|
|
// Iterate over all the allocated pages, and try to find one where not all slots are used.
|
|
|
|
for (std::size_t page = 0; page < tls_slots.size(); ++page) {
|
|
|
|
const auto& page_tls_slots = tls_slots[page];
|
|
|
|
if (!page_tls_slots.all()) {
|
|
|
|
// We found a page with at least one free slot, find which slot it is
|
|
|
|
for (std::size_t slot = 0; slot < page_tls_slots.size(); ++slot) {
|
|
|
|
if (!page_tls_slots.test(slot)) {
|
|
|
|
return std::make_tuple(page, slot, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return std::make_tuple(0, 0, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
VAddr Process::MarkNextAvailableTLSSlotAsUsed(Thread& thread) {
|
|
|
|
auto [available_page, available_slot, needs_allocation] = FindFreeThreadLocalSlot(tls_slots);
|
2018-09-25 00:01:45 +00:00
|
|
|
const VAddr tls_begin = vm_manager.GetTLSIORegionBaseAddress();
|
2018-09-21 05:26:29 +00:00
|
|
|
|
|
|
|
if (needs_allocation) {
|
|
|
|
tls_slots.emplace_back(0); // The page is completely available at the start
|
|
|
|
available_page = tls_slots.size() - 1;
|
|
|
|
available_slot = 0; // Use the first slot in the new page
|
|
|
|
|
|
|
|
// Allocate some memory from the end of the linear heap for this region.
|
|
|
|
auto& tls_memory = thread.GetTLSMemory();
|
|
|
|
tls_memory->insert(tls_memory->end(), Memory::PAGE_SIZE, 0);
|
|
|
|
|
|
|
|
vm_manager.RefreshMemoryBlockMappings(tls_memory.get());
|
|
|
|
|
2018-09-25 00:01:45 +00:00
|
|
|
vm_manager.MapMemoryBlock(tls_begin + available_page * Memory::PAGE_SIZE, tls_memory, 0,
|
|
|
|
Memory::PAGE_SIZE, MemoryState::ThreadLocal);
|
2018-09-21 05:26:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tls_slots[available_page].set(available_slot);
|
|
|
|
|
2018-09-25 00:01:45 +00:00
|
|
|
return tls_begin + available_page * Memory::PAGE_SIZE + available_slot * Memory::TLS_ENTRY_SIZE;
|
2018-09-21 05:26:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Process::FreeTLSSlot(VAddr tls_address) {
|
2018-09-25 00:01:45 +00:00
|
|
|
const VAddr tls_base = tls_address - vm_manager.GetTLSIORegionBaseAddress();
|
2018-09-21 05:26:29 +00:00
|
|
|
const VAddr tls_page = tls_base / Memory::PAGE_SIZE;
|
|
|
|
const VAddr tls_slot = (tls_base % Memory::PAGE_SIZE) / Memory::TLS_ENTRY_SIZE;
|
|
|
|
|
|
|
|
tls_slots[tls_page].reset(tls_slot);
|
|
|
|
}
|
|
|
|
|
2018-10-12 15:36:31 +00:00
|
|
|
void Process::LoadModule(CodeSet module_, VAddr base_addr) {
|
2019-03-22 18:51:36 +00:00
|
|
|
const auto memory = std::make_shared<std::vector<u8>>(std::move(module_.memory));
|
|
|
|
|
2019-03-20 17:03:14 +00:00
|
|
|
const auto MapSegment = [&](const CodeSet::Segment& segment, VMAPermission permissions,
|
2018-08-03 03:37:44 +00:00
|
|
|
MemoryState memory_state) {
|
2018-10-12 15:36:31 +00:00
|
|
|
const auto vma = vm_manager
|
2019-03-22 18:51:36 +00:00
|
|
|
.MapMemoryBlock(segment.addr + base_addr, memory, segment.offset,
|
|
|
|
segment.size, memory_state)
|
2018-10-12 15:36:31 +00:00
|
|
|
.Unwrap();
|
2017-09-24 15:12:16 +00:00
|
|
|
vm_manager.Reprotect(vma, permissions);
|
|
|
|
};
|
|
|
|
|
|
|
|
// Map CodeSet segments
|
2019-03-21 15:39:55 +00:00
|
|
|
MapSegment(module_.CodeSegment(), VMAPermission::ReadExecute, MemoryState::Code);
|
|
|
|
MapSegment(module_.RODataSegment(), VMAPermission::Read, MemoryState::CodeData);
|
|
|
|
MapSegment(module_.DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeData);
|
2018-10-23 22:42:15 +00:00
|
|
|
|
2019-04-02 04:44:32 +00:00
|
|
|
code_memory_size += module_.memory.size();
|
2015-05-04 03:01:16 +00:00
|
|
|
}
|
|
|
|
|
2019-03-12 23:03:26 +00:00
|
|
|
Process::Process(Core::System& system)
|
2019-04-16 09:07:43 +00:00
|
|
|
: WaitObject{system.Kernel()}, vm_manager{system},
|
|
|
|
address_arbiter{system}, mutex{system}, system{system} {}
|
2019-03-14 04:29:54 +00:00
|
|
|
|
2019-03-07 23:48:14 +00:00
|
|
|
Process::~Process() = default;
|
2015-05-04 03:01:16 +00:00
|
|
|
|
2018-12-05 00:08:56 +00:00
|
|
|
void Process::Acquire(Thread* thread) {
|
|
|
|
ASSERT_MSG(!ShouldWait(thread), "Object unavailable!");
|
|
|
|
}
|
|
|
|
|
2019-04-01 22:19:42 +00:00
|
|
|
bool Process::ShouldWait(const Thread* thread) const {
|
2018-12-05 00:08:56 +00:00
|
|
|
return !is_signaled;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Process::ChangeStatus(ProcessStatus new_status) {
|
|
|
|
if (status == new_status) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = new_status;
|
|
|
|
is_signaled = true;
|
|
|
|
WakeupAllWaitingThreads();
|
|
|
|
}
|
|
|
|
|
2018-01-01 19:38:34 +00:00
|
|
|
} // namespace Kernel
|