Kernel: Implement svcGetProcessInfo in a basic way

This also adds some basic memory usage accounting. These two types are
used by Super Smash Bros. during startup.

src/core/hle/kernel/process.cpp

@@ -110,6 +110,7 @@ void Process::Run(s32 main_thread_priority, u32 stack_size) {
         auto vma = vm_manager.MapMemoryBlock(segment.addr, codeset->memory,
                 segment.offset, segment.size, memory_state).Unwrap();
         vm_manager.Reprotect(vma, permissions);
+        misc_memory_used += segment.size;
     };
 
     // Map CodeSet segments
@@ -121,6 +122,7 @@ void Process::Run(s32 main_thread_priority, u32 stack_size) {
     vm_manager.MapMemoryBlock(Memory::HEAP_VADDR_END - stack_size,
             std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size, MemoryState::Locked
             ).Unwrap();
+    misc_memory_used += stack_size;
 
     vm_manager.LogLayout(Log::Level::Debug);
     Kernel::SetupMainThread(codeset->entrypoint, main_thread_priority);
@@ -162,6 +164,8 @@ ResultVal<VAddr> Process::HeapAllocate(VAddr target, u32 size, VMAPermission per
     CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, heap_memory, target - heap_start, size, MemoryState::Private));
     vm_manager.Reprotect(vma, perms);
 
+    heap_used += size;
+
     return MakeResult<VAddr>(heap_end - size);
 }
 
@@ -173,6 +177,8 @@ ResultCode Process::HeapFree(VAddr target, u32 size) {
     ResultCode result = vm_manager.UnmapRange(target, size);
     if (result.IsError()) return result;
 
+    heap_used -= size;
+
     return RESULT_SUCCESS;
 }
 
@@ -206,6 +212,8 @@ ResultVal<VAddr> Process::LinearAllocate(VAddr target, u32 size, VMAPermission p
     CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, linheap_memory, offset, size, MemoryState::Continuous));
     vm_manager.Reprotect(vma, perms);
 
+    linear_heap_used += size;
+
     return MakeResult<VAddr>(target);
 }
 
@@ -226,6 +234,8 @@ ResultCode Process::LinearFree(VAddr target, u32 size) {
     ResultCode result = vm_manager.UnmapRange(target, size);
     if (result.IsError()) return result;
 
+    linear_heap_used -= size;
+
     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.

src/core/hle/kernel/process.h

@@ -136,6 +136,8 @@ public:
     // The left/right bounds of the address space covered by heap_memory.
     VAddr heap_start = 0, heap_end = 0;
 
+    u32 heap_used = 0, linear_heap_used = 0, misc_memory_used = 0;
+
     MemoryRegionInfo* memory_region = nullptr;
 
     /// Bitmask of the used TLS slots

src/core/hle/kernel/thread.cpp

@@ -117,6 +117,7 @@ void Thread::Stop() {
     wait_objects.clear();
 
     Kernel::g_current_process->used_tls_slots[tls_index] = false;
+    g_current_process->misc_memory_used -= Memory::TLS_ENTRY_SIZE;
 
     HLE::Reschedule(__func__);
 }
@@ -414,6 +415,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
     }
 
     ASSERT_MSG(thread->tls_index != -1, "Out of TLS space");
+    g_current_process->misc_memory_used += Memory::TLS_ENTRY_SIZE;
 
     // TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
     // to initialize the context
@@ -504,7 +506,7 @@ void Thread::SetWaitSynchronizationOutput(s32 output) {
 }
 
 VAddr Thread::GetTLSAddress() const {
-    return Memory::TLS_AREA_VADDR + tls_index * 0x200;
+    return Memory::TLS_AREA_VADDR + tls_index * Memory::TLS_ENTRY_SIZE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////