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>
|
2015-05-03 20:01:16 -07:00
|
|
|
#include "common/assert.h"
|
2015-05-08 12:51:48 -07:00
|
|
|
#include "common/common_funcs.h"
|
|
|
|
#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"
|
2017-05-21 00:11:36 -07: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"
|
2015-05-03 20:01:16 -07:00
|
|
|
|
|
|
|
namespace Kernel {
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
SharedPtr<CodeSet> CodeSet::Create(KernelCore& kernel, std::string name) {
|
|
|
|
SharedPtr<CodeSet> codeset(new CodeSet(kernel));
|
2015-07-09 18:52:15 -07:00
|
|
|
codeset->name = std::move(name);
|
|
|
|
return codeset;
|
|
|
|
}
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
CodeSet::CodeSet(KernelCore& kernel) : Object{kernel} {}
|
|
|
|
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);
|
2015-05-08 13:53:19 -07:00
|
|
|
process->flags.raw = 0;
|
2016-02-11 09:41:15 -08:00
|
|
|
process->flags.memory_region.Assign(MemoryRegion::APPLICATION);
|
2018-09-22 17:09:32 -07:00
|
|
|
process->resource_limit = kernel.ResourceLimitForCategory(ResourceLimitCategory::APPLICATION);
|
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-09-22 17:09:32 -07:00
|
|
|
process->svc_access_mask.set();
|
2015-05-08 13:53:19 -07:00
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
kernel.AppendNewProcess(process);
|
2015-05-03 20:01:16 -07:00
|
|
|
return process;
|
|
|
|
}
|
|
|
|
|
2018-09-22 17:09:32 -07:00
|
|
|
void Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
|
|
|
|
program_id = metadata.GetTitleID();
|
2018-09-29 16:13:46 -07:00
|
|
|
is_64bit_process = metadata.Is64BitProgram();
|
2018-09-22 17:09:32 -07:00
|
|
|
vm_manager.Reset(metadata.GetAddressSpaceType());
|
|
|
|
}
|
|
|
|
|
2018-09-15 06:21:06 -07:00
|
|
|
void Process::ParseKernelCaps(const u32* kernel_caps, std::size_t len) {
|
|
|
|
for (std::size_t i = 0; i < len; ++i) {
|
2015-05-08 12:51:48 -07:00
|
|
|
u32 descriptor = kernel_caps[i];
|
|
|
|
u32 type = descriptor >> 20;
|
|
|
|
|
|
|
|
if (descriptor == 0xFFFFFFFF) {
|
|
|
|
// Unused descriptor entry
|
|
|
|
continue;
|
|
|
|
} else if ((type & 0xF00) == 0xE00) { // 0x0FFF
|
|
|
|
// Allowed interrupts list
|
2018-07-02 09:13:26 -07:00
|
|
|
LOG_WARNING(Loader, "ExHeader allowed interrupts list ignored");
|
2015-05-08 12:51:48 -07:00
|
|
|
} else if ((type & 0xF80) == 0xF00) { // 0x07FF
|
|
|
|
// Allowed syscalls mask
|
|
|
|
unsigned int index = ((descriptor >> 24) & 7) * 24;
|
|
|
|
u32 bits = descriptor & 0xFFFFFF;
|
|
|
|
|
|
|
|
while (bits && index < svc_access_mask.size()) {
|
|
|
|
svc_access_mask.set(index, bits & 1);
|
2016-09-17 17:38:01 -07:00
|
|
|
++index;
|
|
|
|
bits >>= 1;
|
2015-05-08 12:51:48 -07:00
|
|
|
}
|
|
|
|
} else if ((type & 0xFF0) == 0xFE0) { // 0x00FF
|
|
|
|
// Handle table size
|
|
|
|
handle_table_size = descriptor & 0x3FF;
|
|
|
|
} else if ((type & 0xFF8) == 0xFF0) { // 0x007F
|
|
|
|
// Misc. flags
|
2015-05-08 13:53:19 -07:00
|
|
|
flags.raw = descriptor & 0xFFFF;
|
2015-05-08 12:51:48 -07:00
|
|
|
} else if ((type & 0xFFE) == 0xFF8) { // 0x001F
|
|
|
|
// Mapped memory range
|
2016-09-17 17:38:01 -07:00
|
|
|
if (i + 1 >= len || ((kernel_caps[i + 1] >> 20) & 0xFFE) != 0xFF8) {
|
2018-07-02 09:13:26 -07:00
|
|
|
LOG_WARNING(Loader, "Incomplete exheader memory range descriptor ignored.");
|
2015-05-08 12:51:48 -07:00
|
|
|
continue;
|
|
|
|
}
|
2016-09-17 17:38:01 -07:00
|
|
|
u32 end_desc = kernel_caps[i + 1];
|
2015-05-08 12:51:48 -07:00
|
|
|
++i; // Skip over the second descriptor on the next iteration
|
|
|
|
|
2015-05-08 14:12:25 -07:00
|
|
|
AddressMapping mapping;
|
2015-05-08 12:51:48 -07:00
|
|
|
mapping.address = descriptor << 12;
|
2017-05-05 23:11:06 -07:00
|
|
|
VAddr end_address = end_desc << 12;
|
|
|
|
|
|
|
|
if (mapping.address < end_address) {
|
|
|
|
mapping.size = end_address - mapping.address;
|
|
|
|
} else {
|
|
|
|
mapping.size = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
mapping.read_only = (descriptor & (1 << 20)) != 0;
|
2015-05-14 09:59:12 -07:00
|
|
|
mapping.unk_flag = (end_desc & (1 << 20)) != 0;
|
2015-05-08 12:51:48 -07:00
|
|
|
|
2015-05-08 14:12:25 -07:00
|
|
|
address_mappings.push_back(mapping);
|
2015-05-08 12:51:48 -07:00
|
|
|
} else if ((type & 0xFFF) == 0xFFE) { // 0x000F
|
|
|
|
// Mapped memory page
|
2015-05-08 14:12:25 -07:00
|
|
|
AddressMapping mapping;
|
2015-05-08 12:51:48 -07:00
|
|
|
mapping.address = descriptor << 12;
|
|
|
|
mapping.size = Memory::PAGE_SIZE;
|
2017-05-05 23:11:06 -07:00
|
|
|
mapping.read_only = false;
|
2015-05-08 12:51:48 -07:00
|
|
|
mapping.unk_flag = false;
|
2017-05-05 23:11:06 -07:00
|
|
|
|
|
|
|
address_mappings.push_back(mapping);
|
2015-05-08 12:51:48 -07:00
|
|
|
} else if ((type & 0xFE0) == 0xFC0) { // 0x01FF
|
|
|
|
// Kernel version
|
2015-07-19 11:18:57 -07:00
|
|
|
kernel_version = descriptor & 0xFFFF;
|
|
|
|
|
|
|
|
int minor = kernel_version & 0xFF;
|
|
|
|
int major = (kernel_version >> 8) & 0xFF;
|
2018-07-02 09:13:26 -07:00
|
|
|
LOG_INFO(Loader, "ExHeader kernel version: {}.{}", major, minor);
|
2015-05-08 12:51:48 -07:00
|
|
|
} else {
|
2018-07-02 09:13:26 -07:00
|
|
|
LOG_ERROR(Loader, "Unhandled kernel caps descriptor: 0x{:08X}", descriptor);
|
2015-05-08 12:51:48 -07:00
|
|
|
}
|
|
|
|
}
|
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,
|
|
|
|
MemoryState::Mapped)
|
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-01-01 11:38:34 -08:00
|
|
|
status = ProcessStatus::Running;
|
2017-10-09 20:56:20 -07:00
|
|
|
|
2018-09-20 18:09:57 -07:00
|
|
|
Kernel::SetupMainThread(kernel, entry_point, main_thread_priority, *this);
|
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() {
|
|
|
|
status = ProcessStatus::Exited;
|
|
|
|
|
|
|
|
const auto stop_threads = [this](const std::vector<SharedPtr<Thread>>& thread_list) {
|
|
|
|
for (auto& thread : thread_list) {
|
|
|
|
if (thread->owner_process != this)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (thread == GetCurrentThread())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// TODO(Subv): When are the other running/ready threads terminated?
|
|
|
|
ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
|
|
|
|
thread->status == ThreadStatus::WaitSynchAll,
|
|
|
|
"Exiting processes with non-waiting threads is currently unimplemented");
|
|
|
|
|
|
|
|
thread->Stop();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
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-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);
|
|
|
|
}
|
|
|
|
|
2017-09-24 08:12:16 -07:00
|
|
|
void Process::LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr) {
|
2018-08-02 20:37:44 -07:00
|
|
|
const auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions,
|
|
|
|
MemoryState memory_state) {
|
2017-09-24 08:12:16 -07:00
|
|
|
auto vma = vm_manager
|
2018-01-01 11:38:34 -08:00
|
|
|
.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-08-03 11:33:59 -07:00
|
|
|
MapSegment(module_->CodeSegment(), VMAPermission::ReadExecute, MemoryState::CodeStatic);
|
|
|
|
MapSegment(module_->RODataSegment(), VMAPermission::Read, MemoryState::CodeMutable);
|
|
|
|
MapSegment(module_->DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeMutable);
|
2015-05-03 20:01:16 -07:00
|
|
|
}
|
|
|
|
|
2017-12-29 10:27:58 -08:00
|
|
|
ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission perms) {
|
2018-09-24 17:01:45 -07:00
|
|
|
if (target < vm_manager.GetHeapRegionBaseAddress() ||
|
|
|
|
target + size > vm_manager.GetHeapRegionEndAddress() || target + size < target) {
|
2015-07-17 19:19:16 -07:00
|
|
|
return ERR_INVALID_ADDRESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (heap_memory == nullptr) {
|
|
|
|
// Initialize heap
|
|
|
|
heap_memory = std::make_shared<std::vector<u8>>();
|
|
|
|
heap_start = heap_end = target;
|
2018-03-16 15:24:29 -07:00
|
|
|
} else {
|
|
|
|
vm_manager.UnmapRange(heap_start, heap_end - heap_start);
|
2015-07-17 19:19:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// If necessary, expand backing vector to cover new heap extents.
|
|
|
|
if (target < heap_start) {
|
|
|
|
heap_memory->insert(begin(*heap_memory), heap_start - target, 0);
|
|
|
|
heap_start = target;
|
|
|
|
vm_manager.RefreshMemoryBlockMappings(heap_memory.get());
|
|
|
|
}
|
|
|
|
if (target + size > heap_end) {
|
|
|
|
heap_memory->insert(end(*heap_memory), (target + size) - heap_end, 0);
|
|
|
|
heap_end = target + size;
|
|
|
|
vm_manager.RefreshMemoryBlockMappings(heap_memory.get());
|
|
|
|
}
|
|
|
|
ASSERT(heap_end - heap_start == heap_memory->size());
|
|
|
|
|
2016-09-17 17:38:01 -07:00
|
|
|
CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, heap_memory, target - heap_start,
|
2017-10-19 20:00:46 -07:00
|
|
|
size, MemoryState::Heap));
|
2015-07-17 19:19:16 -07:00
|
|
|
vm_manager.Reprotect(vma, perms);
|
|
|
|
|
2018-03-16 15:24:29 -07:00
|
|
|
heap_used = size;
|
2015-08-05 17:39:53 -07:00
|
|
|
|
2015-07-17 19:19:16 -07:00
|
|
|
return MakeResult<VAddr>(heap_end - size);
|
|
|
|
}
|
|
|
|
|
|
|
|
ResultCode Process::HeapFree(VAddr target, u32 size) {
|
2018-09-24 17:01:45 -07:00
|
|
|
if (target < vm_manager.GetHeapRegionBaseAddress() ||
|
|
|
|
target + size > vm_manager.GetHeapRegionEndAddress() || target + size < target) {
|
2015-07-17 19:19:16 -07:00
|
|
|
return ERR_INVALID_ADDRESS;
|
|
|
|
}
|
|
|
|
|
2015-08-26 02:38:26 -07:00
|
|
|
if (size == 0) {
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2015-07-17 19:19:16 -07:00
|
|
|
ResultCode result = vm_manager.UnmapRange(target, size);
|
2016-09-17 17:38:01 -07:00
|
|
|
if (result.IsError())
|
|
|
|
return result;
|
2015-07-17 19:19:16 -07:00
|
|
|
|
2015-08-05 17:39:53 -07:00
|
|
|
heap_used -= size;
|
2015-07-17 19:19:16 -07:00
|
|
|
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2017-12-28 18:35:49 -08:00
|
|
|
ResultCode Process::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
|
|
|
|
auto vma = vm_manager.FindVMA(src_addr);
|
|
|
|
|
|
|
|
ASSERT_MSG(vma != vm_manager.vma_map.end(), "Invalid memory address");
|
|
|
|
ASSERT_MSG(vma->second.backing_block, "Backing block doesn't exist for address");
|
|
|
|
|
|
|
|
// The returned VMA might be a bigger one encompassing the desired address.
|
|
|
|
auto vma_offset = src_addr - vma->first;
|
|
|
|
ASSERT_MSG(vma_offset + size <= vma->second.size,
|
|
|
|
"Shared memory exceeds bounds of mapped block");
|
|
|
|
|
|
|
|
const std::shared_ptr<std::vector<u8>>& backing_block = vma->second.backing_block;
|
2018-09-15 06:21:06 -07:00
|
|
|
std::size_t backing_block_offset = vma->second.offset + vma_offset;
|
2017-12-28 18:35:49 -08:00
|
|
|
|
|
|
|
CASCADE_RESULT(auto new_vma,
|
|
|
|
vm_manager.MapMemoryBlock(dst_addr, backing_block, backing_block_offset, size,
|
2018-03-16 16:24:54 -07:00
|
|
|
MemoryState::Mapped));
|
2017-12-28 18:35:49 -08:00
|
|
|
// Protect mirror with permissions from old region
|
|
|
|
vm_manager.Reprotect(new_vma, vma->second.permissions);
|
|
|
|
// Remove permissions from old region
|
|
|
|
vm_manager.Reprotect(vma, VMAPermission::None);
|
|
|
|
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2017-12-31 12:22:49 -08:00
|
|
|
ResultCode Process::UnmapMemory(VAddr dst_addr, VAddr /*src_addr*/, u64 size) {
|
|
|
|
return vm_manager.UnmapRange(dst_addr, size);
|
|
|
|
}
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
Kernel::Process::Process(KernelCore& kernel) : Object{kernel} {}
|
2016-09-18 18:01:46 -07:00
|
|
|
Kernel::Process::~Process() {}
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2018-01-01 11:38:34 -08:00
|
|
|
} // namespace Kernel
|