1 files changed, 126 insertions, 36 deletions

diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h
index 1587d40c1..590e0c73d 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -17,6 +17,10 @@
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/vm_manager.h"
 
+namespace FileSys {
+class ProgramMetadata;
+}
+
 namespace Kernel {
 
 class KernelCore;
@@ -59,7 +63,7 @@ class ResourceLimit;
 
 struct CodeSet final : public Object {
     struct Segment {
-        size_t offset = 0;
+        std::size_t offset = 0;
         VAddr addr = 0;
         u32 size = 0;
     };
@@ -131,6 +135,121 @@ public:
         return HANDLE_TYPE;
     }
 
+    /// Gets a reference to the process' memory manager.
+    Kernel::VMManager& VMManager() {
+        return vm_manager;
+    }
+
+    /// Gets a const reference to the process' memory manager.
+    const Kernel::VMManager& VMManager() const {
+        return vm_manager;
+    }
+
+    /// Gets the current status of the process
+    ProcessStatus GetStatus() const {
+        return status;
+    }
+
+    /// Gets the unique ID that identifies this particular process.
+    u32 GetProcessID() const {
+        return process_id;
+    }
+
+    /// Gets the title ID corresponding to this process.
+    u64 GetTitleID() const {
+        return program_id;
+    }
+
+    /// Gets the resource limit descriptor for this process
+    ResourceLimit& GetResourceLimit() {
+        return *resource_limit;
+    }
+
+    /// Gets the resource limit descriptor for this process
+    const ResourceLimit& GetResourceLimit() const {
+        return *resource_limit;
+    }
+
+    /// Gets the default CPU ID for this process
+    u8 GetDefaultProcessorID() const {
+        return ideal_processor;
+    }
+
+    /// Gets the bitmask of allowed CPUs that this process' threads can run on.
+    u32 GetAllowedProcessorMask() const {
+        return allowed_processor_mask;
+    }
+
+    /// Gets the bitmask of allowed thread priorities.
+    u32 GetAllowedThreadPriorityMask() const {
+        return allowed_thread_priority_mask;
+    }
+
+    u32 IsVirtualMemoryEnabled() const {
+        return is_virtual_address_memory_enabled;
+    }
+
+    /// Whether this process is an AArch64 or AArch32 process.
+    bool Is64BitProcess() const {
+        return is_64bit_process;
+    }
+
+    /**
+     * Loads process-specifics configuration info with metadata provided
+     * by an executable.
+     *
+     * @param metadata The provided metadata to load process specific info.
+     */
+    void LoadFromMetadata(const FileSys::ProgramMetadata& metadata);
+
+    /**
+     * Parses a list of kernel capability descriptors (as found in the ExHeader) and applies them
+     * to this process.
+     */
+    void ParseKernelCaps(const u32* kernel_caps, std::size_t len);
+
+    /**
+     * Applies address space changes and launches the process main thread.
+     */
+    void Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size);
+
+    /**
+     * Prepares a process for termination by stopping all of its threads
+     * and clearing any other resources.
+     */
+    void PrepareForTermination();
+
+    void LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr);
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Memory Management
+
+    // Marks the next available region as used and returns the address of the slot.
+    VAddr MarkNextAvailableTLSSlotAsUsed(Thread& thread);
+
+    // Frees a used TLS slot identified by the given address
+    void FreeTLSSlot(VAddr tls_address);
+
+    ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
+    ResultCode HeapFree(VAddr target, u32 size);
+
+    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
+
+    ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);
+
+private:
+    explicit Process(KernelCore& kernel);
+    ~Process() override;
+
+    /// Memory manager for this process.
+    Kernel::VMManager vm_manager;
+
+    /// Current status of the process
+    ProcessStatus status;
+
+    /// The ID of this process
+    u32 process_id = 0;
+
     /// Title ID corresponding to the process
     u64 program_id;
 
@@ -140,7 +259,7 @@ public:
     /// The process may only call SVCs which have the corresponding bit set.
     std::bitset<0x80> svc_access_mask;
     /// Maximum size of the handle table for the process.
-    unsigned int handle_table_size = 0x200;
+    u32 handle_table_size = 0x200;
     /// Special memory ranges mapped into this processes address space. This is used to give
     /// processes access to specific I/O regions and device memory.
     boost::container::static_vector<AddressMapping, 8> address_mappings;
@@ -154,29 +273,6 @@ public:
     u32 allowed_processor_mask = THREADPROCESSORID_DEFAULT_MASK;
     u32 allowed_thread_priority_mask = 0xFFFFFFFF;
     u32 is_virtual_address_memory_enabled = 0;
-    /// Current status of the process
-    ProcessStatus status;
-
-    /// The ID of this process
-    u32 process_id = 0;
-
-    /**
-     * Parses a list of kernel capability descriptors (as found in the ExHeader) and applies them
-     * to this process.
-     */
-    void ParseKernelCaps(const u32* kernel_caps, size_t len);
-
-    /**
-     * Applies address space changes and launches the process main thread.
-     */
-    void Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size);
-
-    void LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr);
-
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    // Memory Management
-
-    VMManager vm_manager;
 
     // Memory used to back the allocations in the regular heap. A single vector is used to cover
     // the entire virtual address space extents that bound the allocations, including any holes.
@@ -196,18 +292,12 @@ public:
     /// This vector will grow as more pages are allocated for new threads.
     std::vector<std::bitset<8>> tls_slots;
 
-    std::string name;
-
-    ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
-    ResultCode HeapFree(VAddr target, u32 size);
-
-    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
+    /// Whether or not this process is AArch64, or AArch32.
+    /// By default, we currently assume this is true, unless otherwise
+    /// specified by metadata provided to the process during loading.
+    bool is_64bit_process = true;
 
-    ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);
-
-private:
-    explicit Process(KernelCore& kernel);
-    ~Process() override;
+    std::string name;
 };
 
 } // namespace Kernel