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>
|
2016-04-05 05:29:55 -07:00
|
|
|
#include <memory>
|
2018-11-20 14:46:17 -08:00
|
|
|
#include <random>
|
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"
|
2018-09-22 17:09:32 -07:00
|
|
|
#include "core/file_sys/program_metadata.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"
|
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-07-09 18:52:15 -07:00
|
|
|
#include "core/hle/kernel/vm_manager.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 entry_point The address at which the thread should start execution
|
|
|
|
* @param priority The priority to give the main thread
|
|
|
|
*/
|
|
|
|
void SetupMainThread(Process& owner_process, KernelCore& kernel, VAddr entry_point, u32 priority) {
|
|
|
|
// Setup page table so we can write to memory
|
|
|
|
SetCurrentPageTable(&owner_process.VMManager().page_table);
|
|
|
|
|
|
|
|
// Initialize new "main" thread
|
|
|
|
const VAddr stack_top = owner_process.VMManager().GetTLSIORegionEndAddress();
|
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
|
|
|
|
|
|
|
SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
|
|
|
|
|
|
|
|
// Register 1 must be a handle to the main thread
|
|
|
|
const Handle guest_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
|
|
|
|
thread->SetGuestHandle(guest_handle);
|
|
|
|
thread->GetContext().cpu_registers[1] = guest_handle;
|
|
|
|
|
|
|
|
// 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
|
|
|
|
2018-10-12 08:36:31 -07:00
|
|
|
CodeSet::CodeSet() = default;
|
2018-08-28 09:30:33 -07:00
|
|
|
CodeSet::~CodeSet() = default;
|
2015-05-11 07:15:10 -07:00
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
SharedPtr<Process> Process::Create(KernelCore& kernel, std::string&& name) {
|
|
|
|
SharedPtr<Process> process(new Process(kernel));
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2017-09-30 11:15:09 -07:00
|
|
|
process->name = std::move(name);
|
2018-11-19 09:54:06 -08:00
|
|
|
process->resource_limit = kernel.GetSystemResourceLimit();
|
2018-01-01 11:38:34 -08:00
|
|
|
process->status = ProcessStatus::Created;
|
2018-03-13 14:49:59 -07:00
|
|
|
process->program_id = 0;
|
2018-08-28 09:30:33 -07:00
|
|
|
process->process_id = kernel.CreateNewProcessID();
|
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;
|
|
|
|
}
|
|
|
|
|
2018-12-03 21:29:15 -08:00
|
|
|
SharedPtr<ResourceLimit> Process::GetResourceLimit() const {
|
|
|
|
return resource_limit;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-12-19 20:50:20 -08:00
|
|
|
ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
|
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();
|
2017-05-05 23:11:06 -07:00
|
|
|
|
2018-12-19 20:50:20 -08:00
|
|
|
vm_manager.Reset(metadata.GetAddressSpaceType());
|
2015-07-19 11:18:57 -07:00
|
|
|
|
2018-12-19 20:50:20 -08:00
|
|
|
const auto& caps = metadata.GetKernelCapabilities();
|
|
|
|
return capabilities.InitializeForUserProcess(caps.data(), caps.size(), vm_manager);
|
2015-05-03 20:01:16 -07:00
|
|
|
}
|
|
|
|
|
2017-09-30 11:15:09 -07:00
|
|
|
void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
|
2018-03-10 14:51:23 -08: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.
|
2016-09-17 17:38:01 -07:00
|
|
|
vm_manager
|
2018-09-24 17:01:45 -07:00
|
|
|
.MapMemoryBlock(vm_manager.GetTLSIORegionEndAddress() - stack_size,
|
2018-03-31 12:03:28 -07:00
|
|
|
std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size,
|
2018-12-12 07:08:46 -08:00
|
|
|
MemoryState::Stack)
|
2016-09-17 17:38:01 -07:00
|
|
|
.Unwrap();
|
2017-05-05 23:11:06 -07:00
|
|
|
|
2018-04-27 08:49:18 -07:00
|
|
|
vm_manager.LogLayout();
|
2018-12-04 16:08:56 -08:00
|
|
|
ChangeStatus(ProcessStatus::Running);
|
2017-10-09 20:56:20 -07:00
|
|
|
|
2018-12-27 17:28:15 -08:00
|
|
|
SetupMainThread(*this, kernel, entry_point, main_thread_priority);
|
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
|
|
|
|
|
|
|
const auto stop_threads = [this](const std::vector<SharedPtr<Thread>>& thread_list) {
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (thread == GetCurrentThread())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// TODO(Subv): When are the other running/ready threads terminated?
|
2018-10-03 15:47:57 -07:00
|
|
|
ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynchAny ||
|
|
|
|
thread->GetStatus() == ThreadStatus::WaitSynchAll,
|
2018-09-20 23:06:47 -07:00
|
|
|
"Exiting processes with non-waiting threads is currently unimplemented");
|
|
|
|
|
|
|
|
thread->Stop();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-10-15 06:25:11 -07:00
|
|
|
const auto& system = Core::System::GetInstance();
|
|
|
|
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-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
|
|
|
/**
|
|
|
|
* 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-24 17:01:45 -07:00
|
|
|
const VAddr tls_begin = vm_manager.GetTLSIORegionBaseAddress();
|
2018-09-20 22:26:29 -07: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-24 17:01:45 -07:00
|
|
|
vm_manager.MapMemoryBlock(tls_begin + available_page * Memory::PAGE_SIZE, tls_memory, 0,
|
|
|
|
Memory::PAGE_SIZE, MemoryState::ThreadLocal);
|
2018-09-20 22:26:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
tls_slots[available_page].set(available_slot);
|
|
|
|
|
2018-09-24 17:01:45 -07:00
|
|
|
return tls_begin + available_page * Memory::PAGE_SIZE + available_slot * Memory::TLS_ENTRY_SIZE;
|
2018-09-20 22:26:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void Process::FreeTLSSlot(VAddr tls_address) {
|
2018-09-24 17:01:45 -07:00
|
|
|
const VAddr tls_base = tls_address - vm_manager.GetTLSIORegionBaseAddress();
|
2018-09-20 22:26:29 -07: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 08:36:31 -07:00
|
|
|
void Process::LoadModule(CodeSet module_, VAddr base_addr) {
|
2018-08-02 20:37:44 -07:00
|
|
|
const auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions,
|
|
|
|
MemoryState memory_state) {
|
2018-10-12 08:36:31 -07:00
|
|
|
const auto vma = vm_manager
|
|
|
|
.MapMemoryBlock(segment.addr + base_addr, module_.memory,
|
|
|
|
segment.offset, segment.size, memory_state)
|
|
|
|
.Unwrap();
|
2017-09-24 08:12:16 -07:00
|
|
|
vm_manager.Reprotect(vma, permissions);
|
|
|
|
};
|
|
|
|
|
|
|
|
// Map CodeSet segments
|
2018-10-12 08:36:31 -07:00
|
|
|
MapSegment(module_.CodeSegment(), VMAPermission::ReadExecute, MemoryState::CodeStatic);
|
|
|
|
MapSegment(module_.RODataSegment(), VMAPermission::Read, MemoryState::CodeMutable);
|
|
|
|
MapSegment(module_.DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeMutable);
|
2018-10-23 15:42:15 -07:00
|
|
|
|
|
|
|
// Clear instruction cache in CPU JIT
|
|
|
|
Core::System::GetInstance().ArmInterface(0).ClearInstructionCache();
|
|
|
|
Core::System::GetInstance().ArmInterface(1).ClearInstructionCache();
|
|
|
|
Core::System::GetInstance().ArmInterface(2).ClearInstructionCache();
|
|
|
|
Core::System::GetInstance().ArmInterface(3).ClearInstructionCache();
|
2015-05-03 20:01:16 -07:00
|
|
|
}
|
|
|
|
|
2018-12-04 16:08:56 -08:00
|
|
|
Kernel::Process::Process(KernelCore& kernel) : WaitObject{kernel} {}
|
2016-09-18 18:01:46 -07:00
|
|
|
Kernel::Process::~Process() {}
|
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!");
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Process::ShouldWait(Thread* thread) const {
|
|
|
|
return !is_signaled;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Process::ChangeStatus(ProcessStatus new_status) {
|
|
|
|
if (status == new_status) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = new_status;
|
|
|
|
is_signaled = true;
|
|
|
|
WakeupAllWaitingThreads();
|
|
|
|
}
|
|
|
|
|
2018-01-01 11:38:34 -08:00
|
|
|
} // namespace Kernel
|