|
|
|
@ -36,8 +36,7 @@ SharedPtr<Process> Process::Create(SharedPtr<CodeSet> code_set) {
|
|
|
|
|
process->codeset = std::move(code_set);
|
|
|
|
|
process->flags.raw = 0;
|
|
|
|
|
process->flags.memory_region = MemoryRegion::APPLICATION;
|
|
|
|
|
process->address_space = Common::make_unique<VMManager>();
|
|
|
|
|
Memory::InitLegacyAddressSpace(*process->address_space);
|
|
|
|
|
Memory::InitLegacyAddressSpace(process->vm_manager);
|
|
|
|
|
|
|
|
|
|
return process;
|
|
|
|
|
}
|
|
|
|
@ -104,19 +103,130 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
|
|
|
|
|
|
|
|
|
|
void Process::Run(s32 main_thread_priority, u32 stack_size) {
|
|
|
|
|
auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions, MemoryState memory_state) {
|
|
|
|
|
auto vma = address_space->MapMemoryBlock(segment.addr, codeset->memory,
|
|
|
|
|
auto vma = vm_manager.MapMemoryBlock(segment.addr, codeset->memory,
|
|
|
|
|
segment.offset, segment.size, memory_state).Unwrap();
|
|
|
|
|
address_space->Reprotect(vma, permissions);
|
|
|
|
|
vm_manager.Reprotect(vma, permissions);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Map CodeSet segments
|
|
|
|
|
MapSegment(codeset->code, VMAPermission::ReadExecute, MemoryState::Code);
|
|
|
|
|
MapSegment(codeset->rodata, VMAPermission::Read, MemoryState::Code);
|
|
|
|
|
MapSegment(codeset->data, VMAPermission::ReadWrite, MemoryState::Private);
|
|
|
|
|
|
|
|
|
|
address_space->LogLayout(Log::Level::Debug);
|
|
|
|
|
// Allocate and map stack
|
|
|
|
|
vm_manager.MapMemoryBlock(Memory::HEAP_VADDR_END - stack_size,
|
|
|
|
|
std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size, MemoryState::Locked
|
|
|
|
|
).Unwrap();
|
|
|
|
|
|
|
|
|
|
vm_manager.LogLayout(Log::Level::Debug);
|
|
|
|
|
Kernel::SetupMainThread(codeset->entrypoint, main_thread_priority);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ResultVal<VAddr> Process::HeapAllocate(VAddr target, u32 size, VMAPermission perms) {
|
|
|
|
|
if (target < Memory::HEAP_VADDR || target + size > Memory::HEAP_VADDR_END || target + size < target) {
|
|
|
|
|
return ERR_INVALID_ADDRESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (heap_memory == nullptr) {
|
|
|
|
|
// Initialize heap
|
|
|
|
|
heap_memory = std::make_shared<std::vector<u8>>();
|
|
|
|
|
heap_start = heap_end = target;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// 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());
|
|
|
|
|
|
|
|
|
|
CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, heap_memory, target - heap_start, size, MemoryState::Private));
|
|
|
|
|
vm_manager.Reprotect(vma, perms);
|
|
|
|
|
|
|
|
|
|
return MakeResult<VAddr>(heap_end - size);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ResultCode Process::HeapFree(VAddr target, u32 size) {
|
|
|
|
|
if (target < Memory::HEAP_VADDR || target + size > Memory::HEAP_VADDR_END || target + size < target) {
|
|
|
|
|
return ERR_INVALID_ADDRESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ResultCode result = vm_manager.UnmapRange(target, size);
|
|
|
|
|
if (result.IsError()) return result;
|
|
|
|
|
|
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ResultVal<VAddr> Process::LinearAllocate(VAddr target, u32 size, VMAPermission perms) {
|
|
|
|
|
if (linear_heap_memory == nullptr) {
|
|
|
|
|
// Initialize heap
|
|
|
|
|
linear_heap_memory = std::make_shared<std::vector<u8>>();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
VAddr heap_end = Memory::LINEAR_HEAP_VADDR + (u32)linear_heap_memory->size();
|
|
|
|
|
// Games and homebrew only ever seem to pass 0 here (which lets the kernel decide the address),
|
|
|
|
|
// but explicit addresses are also accepted and respected.
|
|
|
|
|
if (target == 0) {
|
|
|
|
|
target = heap_end;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (target < Memory::LINEAR_HEAP_VADDR || target + size > Memory::LINEAR_HEAP_VADDR_END ||
|
|
|
|
|
target > heap_end || target + size < target) {
|
|
|
|
|
|
|
|
|
|
return ERR_INVALID_ADDRESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Expansion of the linear heap is only allowed if you do an allocation immediatelly at its
|
|
|
|
|
// end. It's possible to free gaps in the middle of the heap and then reallocate them later,
|
|
|
|
|
// but expansions are only allowed at the end.
|
|
|
|
|
if (target == heap_end) {
|
|
|
|
|
linear_heap_memory->insert(linear_heap_memory->end(), size, 0);
|
|
|
|
|
vm_manager.RefreshMemoryBlockMappings(linear_heap_memory.get());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size_t offset = target - Memory::LINEAR_HEAP_VADDR;
|
|
|
|
|
CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, linear_heap_memory, offset, size, MemoryState::Continuous));
|
|
|
|
|
vm_manager.Reprotect(vma, perms);
|
|
|
|
|
|
|
|
|
|
return MakeResult<VAddr>(target);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ResultCode Process::LinearFree(VAddr target, u32 size) {
|
|
|
|
|
if (linear_heap_memory == nullptr || target < Memory::LINEAR_HEAP_VADDR ||
|
|
|
|
|
target + size > Memory::LINEAR_HEAP_VADDR_END || target + size < target) {
|
|
|
|
|
|
|
|
|
|
return ERR_INVALID_ADDRESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
VAddr heap_end = Memory::LINEAR_HEAP_VADDR + (u32)linear_heap_memory->size();
|
|
|
|
|
if (target + size > heap_end) {
|
|
|
|
|
return ERR_INVALID_ADDRESS_STATE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ResultCode result = vm_manager.UnmapRange(target, size);
|
|
|
|
|
if (result.IsError()) return result;
|
|
|
|
|
|
|
|
|
|
if (target + size == heap_end) {
|
|
|
|
|
// End of linear heap has been freed, so check what's the last allocated block in it and
|
|
|
|
|
// reduce the size.
|
|
|
|
|
auto vma = vm_manager.FindVMA(target);
|
|
|
|
|
ASSERT(vma != vm_manager.vma_map.end());
|
|
|
|
|
ASSERT(vma->second.type == VMAType::Free);
|
|
|
|
|
VAddr new_end = vma->second.base;
|
|
|
|
|
if (new_end >= Memory::LINEAR_HEAP_VADDR) {
|
|
|
|
|
linear_heap_memory->resize(new_end - Memory::LINEAR_HEAP_VADDR);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Kernel::Process::Process() {}
|
|
|
|
|
Kernel::Process::~Process() {}
|
|
|
|
|
|
|
|
|
|