Process: Support parsing of exheader kernel caps

src/core/hle/kernel/process.cpp

@@ -3,24 +3,91 @@
 // Refer to the license.txt file included.
 
 #include "common/assert.h"
+#include "common/common_funcs.h"
+#include "common/logging/log.h"
 
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/thread.h"
+#include "core/mem_map.h"
 
 namespace Kernel {
 
 SharedPtr<Process> Process::Create(std::string name, u64 program_id) {
     SharedPtr<Process> process(new Process);
 
-    process->svc_access_mask.set();
     process->name = std::move(name);
     process->program_id = program_id;
 
     return process;
 }
 
-void Process::ParseKernelCaps(const u32 * kernel_caps, size_t len) {
-    //UNIMPLEMENTED();
+void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
+    for (int i = 0; i < len; ++i) {
+        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
+            LOG_WARNING(Loader, "ExHeader allowed interrupts list ignored");
+        } 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);
+                ++index; bits >>= 1;
+            }
+        } else if ((type & 0xFF0) == 0xFE0) { // 0x00FF
+            // Handle table size
+            handle_table_size = descriptor & 0x3FF;
+        } else if ((type & 0xFF8) == 0xFF0) { // 0x007F
+            // Misc. flags
+            bool allow_debug       = descriptor & BIT(0);
+            bool force_debug       = descriptor & BIT(1);
+            bool allow_nonalphanum = descriptor & BIT(2);
+            shared_page_writable   = descriptor & BIT(3);
+            privileged_priority    = descriptor & BIT(4);
+            bool allow_main_args   = descriptor & BIT(5);
+            bool shared_device_mem = descriptor & BIT(6);
+            bool runnable_on_sleep = descriptor & BIT(7);
+            loaded_high            = descriptor & BIT(12);
+            memory_region = MemoryRegion((descriptor >> 8) & 0xF);
+        } else if ((type & 0xFFE) == 0xFF8) { // 0x001F
+            // Mapped memory range
+            if (i+1 >= len || ((kernel_caps[i+1] >> 20) & 0xFFE) != 0xFF8) {
+                LOG_WARNING(Loader, "Incomplete exheader memory range descriptor ignored.");
+                continue;
+            }
+            u32 end_desc = kernel_caps[i+1];
+            ++i; // Skip over the second descriptor on the next iteration
+
+            StaticAddressMapping mapping;
+            mapping.address = descriptor << 12;
+            mapping.size = (end_desc << 12) - mapping.address;
+            mapping.writable = descriptor & BIT(20);
+            mapping.unk_flag = end_desc & BIT(20);
+
+            static_address_mappings.push_back(mapping);
+        } else if ((type & 0xFFF) == 0xFFE) { // 0x000F
+            // Mapped memory page
+            StaticAddressMapping mapping;
+            mapping.address = descriptor << 12;
+            mapping.size = Memory::PAGE_SIZE;
+            mapping.writable = true; // TODO: Not sure if correct
+            mapping.unk_flag = false;
+        } else if ((type & 0xFE0) == 0xFC0) { // 0x01FF
+            // Kernel version
+            int minor = descriptor & 0xFF;
+            int major = (descriptor >> 8) & 0xFF;
+            LOG_INFO(Loader, "ExHeader kernel version ignored: %d.%d", major, minor);
+        } else {
+            LOG_ERROR(Loader, "Unhandled kernel caps descriptor: 0x%08X", descriptor);
+        }
+    }
 }
 
 void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {