2015-05-04 03:01:16 +00:00
|
|
|
// Copyright 2015 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
2018-08-03 18:42:28 +00:00
|
|
|
#include <array>
|
2015-06-21 14:44:11 +00:00
|
|
|
#include <cstddef>
|
2019-03-20 22:53:48 +00:00
|
|
|
#include <list>
|
2015-06-21 14:44:11 +00:00
|
|
|
#include <string>
|
2018-01-01 19:38:34 +00:00
|
|
|
#include <vector>
|
2015-05-08 20:53:19 +00:00
|
|
|
#include "common/common_types.h"
|
2019-03-07 23:48:14 +00:00
|
|
|
#include "core/hle/kernel/address_arbiter.h"
|
2018-10-20 18:34:41 +00:00
|
|
|
#include "core/hle/kernel/handle_table.h"
|
2019-03-14 04:29:54 +00:00
|
|
|
#include "core/hle/kernel/mutex.h"
|
2018-12-20 04:50:20 +00:00
|
|
|
#include "core/hle/kernel/process_capability.h"
|
2015-07-18 02:19:16 +00:00
|
|
|
#include "core/hle/kernel/vm_manager.h"
|
2018-12-05 00:08:56 +00:00
|
|
|
#include "core/hle/kernel/wait_object.h"
|
|
|
|
#include "core/hle/result.h"
|
2015-05-04 03:01:16 +00:00
|
|
|
|
2019-03-07 23:48:14 +00:00
|
|
|
namespace Core {
|
|
|
|
class System;
|
|
|
|
}
|
|
|
|
|
2018-09-23 00:09:32 +00:00
|
|
|
namespace FileSys {
|
|
|
|
class ProgramMetadata;
|
|
|
|
}
|
|
|
|
|
2015-05-04 03:01:16 +00:00
|
|
|
namespace Kernel {
|
|
|
|
|
2018-08-28 16:30:33 +00:00
|
|
|
class KernelCore;
|
2018-10-13 18:31:46 +00:00
|
|
|
class ResourceLimit;
|
2018-12-31 23:09:41 +00:00
|
|
|
class Thread;
|
2019-06-05 18:32:33 +00:00
|
|
|
class TLSPage;
|
2018-08-28 16:30:33 +00:00
|
|
|
|
2019-03-20 16:40:09 +00:00
|
|
|
struct CodeSet;
|
|
|
|
|
2015-05-08 20:53:19 +00:00
|
|
|
enum class MemoryRegion : u16 {
|
2015-05-04 03:01:16 +00:00
|
|
|
APPLICATION = 1,
|
|
|
|
SYSTEM = 2,
|
|
|
|
BASE = 3,
|
|
|
|
};
|
|
|
|
|
2018-10-13 18:31:46 +00:00
|
|
|
/**
|
|
|
|
* Indicates the status of a Process instance.
|
|
|
|
*
|
|
|
|
* @note These match the values as used by kernel,
|
|
|
|
* so new entries should only be added if RE
|
|
|
|
* shows that a new value has been introduced.
|
|
|
|
*/
|
|
|
|
enum class ProcessStatus {
|
|
|
|
Created,
|
|
|
|
CreatedWithDebuggerAttached,
|
|
|
|
Running,
|
|
|
|
WaitingForDebuggerToAttach,
|
|
|
|
DebuggerAttached,
|
|
|
|
Exiting,
|
|
|
|
Exited,
|
|
|
|
DebugBreak,
|
|
|
|
};
|
2015-07-10 01:52:15 +00:00
|
|
|
|
2018-12-05 00:08:56 +00:00
|
|
|
class Process final : public WaitObject {
|
2015-05-04 03:01:16 +00:00
|
|
|
public:
|
2018-12-19 03:53:58 +00:00
|
|
|
enum : u64 {
|
|
|
|
/// Lowest allowed process ID for a kernel initial process.
|
|
|
|
InitialKIPIDMin = 1,
|
|
|
|
/// Highest allowed process ID for a kernel initial process.
|
|
|
|
InitialKIPIDMax = 80,
|
|
|
|
|
|
|
|
/// Lowest allowed process ID for a userland process.
|
|
|
|
ProcessIDMin = 81,
|
|
|
|
/// Highest allowed process ID for a userland process.
|
|
|
|
ProcessIDMax = 0xFFFFFFFFFFFFFFFF,
|
|
|
|
};
|
|
|
|
|
2019-06-10 04:28:33 +00:00
|
|
|
// Used to determine how process IDs are assigned.
|
|
|
|
enum class ProcessType {
|
|
|
|
KernelInternal,
|
|
|
|
Userland,
|
|
|
|
};
|
|
|
|
|
2018-11-13 17:25:43 +00:00
|
|
|
static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
|
|
|
|
|
2019-06-10 04:28:33 +00:00
|
|
|
static SharedPtr<Process> Create(Core::System& system, std::string name, ProcessType type);
|
2015-05-04 03:01:16 +00:00
|
|
|
|
2016-09-18 00:38:01 +00:00
|
|
|
std::string GetTypeName() const override {
|
|
|
|
return "Process";
|
|
|
|
}
|
|
|
|
std::string GetName() const override {
|
2017-09-30 18:15:09 +00:00
|
|
|
return name;
|
2016-09-18 00:38:01 +00:00
|
|
|
}
|
2015-05-04 03:01:16 +00:00
|
|
|
|
2019-04-11 20:30:52 +00:00
|
|
|
static constexpr HandleType HANDLE_TYPE = HandleType::Process;
|
2016-09-18 00:38:01 +00:00
|
|
|
HandleType GetHandleType() const override {
|
|
|
|
return HANDLE_TYPE;
|
|
|
|
}
|
2015-05-04 03:01:16 +00:00
|
|
|
|
2018-09-29 22:47:00 +00:00
|
|
|
/// 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;
|
|
|
|
}
|
|
|
|
|
2018-10-20 18:34:41 +00:00
|
|
|
/// Gets a reference to the process' handle table.
|
|
|
|
HandleTable& GetHandleTable() {
|
|
|
|
return handle_table;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets a const reference to the process' handle table.
|
|
|
|
const HandleTable& GetHandleTable() const {
|
|
|
|
return handle_table;
|
|
|
|
}
|
|
|
|
|
2019-03-07 23:48:14 +00:00
|
|
|
/// Gets a reference to the process' address arbiter.
|
|
|
|
AddressArbiter& GetAddressArbiter() {
|
|
|
|
return address_arbiter;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets a const reference to the process' address arbiter.
|
|
|
|
const AddressArbiter& GetAddressArbiter() const {
|
|
|
|
return address_arbiter;
|
|
|
|
}
|
|
|
|
|
2019-03-14 04:29:54 +00:00
|
|
|
/// Gets a reference to the process' mutex lock.
|
|
|
|
Mutex& GetMutex() {
|
|
|
|
return mutex;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets a const reference to the process' mutex lock
|
|
|
|
const Mutex& GetMutex() const {
|
|
|
|
return mutex;
|
|
|
|
}
|
|
|
|
|
2018-09-21 06:06:47 +00:00
|
|
|
/// Gets the current status of the process
|
|
|
|
ProcessStatus GetStatus() const {
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets the unique ID that identifies this particular process.
|
2018-12-19 03:16:53 +00:00
|
|
|
u64 GetProcessID() const {
|
2018-09-21 06:06:47 +00:00
|
|
|
return process_id;
|
|
|
|
}
|
|
|
|
|
2018-09-29 22:47:00 +00:00
|
|
|
/// Gets the title ID corresponding to this process.
|
|
|
|
u64 GetTitleID() const {
|
|
|
|
return program_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets the resource limit descriptor for this process
|
2018-12-04 05:29:15 +00:00
|
|
|
SharedPtr<ResourceLimit> GetResourceLimit() const;
|
2018-09-29 22:47:00 +00:00
|
|
|
|
2018-12-28 02:14:59 +00:00
|
|
|
/// Gets the ideal CPU core ID for this process
|
|
|
|
u8 GetIdealCore() const {
|
|
|
|
return ideal_core;
|
2018-09-29 22:47:00 +00:00
|
|
|
}
|
|
|
|
|
2018-12-31 02:09:00 +00:00
|
|
|
/// Gets the bitmask of allowed cores that this process' threads can run on.
|
|
|
|
u64 GetCoreMask() const {
|
2018-12-20 04:50:20 +00:00
|
|
|
return capabilities.GetCoreMask();
|
2018-09-29 22:47:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets the bitmask of allowed thread priorities.
|
2018-12-31 02:09:00 +00:00
|
|
|
u64 GetPriorityMask() const {
|
2018-12-20 04:50:20 +00:00
|
|
|
return capabilities.GetPriorityMask();
|
2018-09-29 22:47:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
u32 IsVirtualMemoryEnabled() const {
|
|
|
|
return is_virtual_address_memory_enabled;
|
|
|
|
}
|
|
|
|
|
2018-09-29 23:13:46 +00:00
|
|
|
/// Whether this process is an AArch64 or AArch32 process.
|
|
|
|
bool Is64BitProcess() const {
|
|
|
|
return is_64bit_process;
|
|
|
|
}
|
|
|
|
|
2018-10-25 22:42:50 +00:00
|
|
|
/// Gets the total running time of the process instance in ticks.
|
|
|
|
u64 GetCPUTimeTicks() const {
|
|
|
|
return total_process_running_time_ticks;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Updates the total running time, adding the given ticks to it.
|
|
|
|
void UpdateCPUTimeTicks(u64 ticks) {
|
|
|
|
total_process_running_time_ticks += ticks;
|
|
|
|
}
|
|
|
|
|
2018-11-13 17:25:43 +00:00
|
|
|
/// Gets 8 bytes of random data for svcGetInfo RandomEntropy
|
|
|
|
u64 GetRandomEntropy(std::size_t index) const {
|
|
|
|
return random_entropy.at(index);
|
|
|
|
}
|
|
|
|
|
2019-06-09 22:20:20 +00:00
|
|
|
/// Retrieves the total physical memory available to this process in bytes.
|
|
|
|
u64 GetTotalPhysicalMemoryAvailable() const;
|
|
|
|
|
|
|
|
/// Retrieves the total physical memory available to this process in bytes,
|
|
|
|
/// without the size of the personal heap added to it.
|
|
|
|
u64 GetTotalPhysicalMemoryAvailableWithoutMmHeap() const;
|
|
|
|
|
2019-03-29 02:59:17 +00:00
|
|
|
/// Retrieves the total physical memory used by this process in bytes.
|
|
|
|
u64 GetTotalPhysicalMemoryUsed() const;
|
|
|
|
|
2019-06-09 22:20:20 +00:00
|
|
|
/// Retrieves the total physical memory used by this process in bytes,
|
|
|
|
/// without the size of the personal heap added to it.
|
|
|
|
u64 GetTotalPhysicalMemoryUsedWithoutMmHeap() const;
|
|
|
|
|
2019-03-20 22:53:48 +00:00
|
|
|
/// Gets the list of all threads created with this process as their owner.
|
|
|
|
const std::list<const Thread*>& GetThreadList() const {
|
|
|
|
return thread_list;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Registers a thread as being created under this process,
|
|
|
|
/// adding it to this process' thread list.
|
|
|
|
void RegisterThread(const Thread* thread);
|
|
|
|
|
|
|
|
/// Unregisters a thread from this process, removing it
|
|
|
|
/// from this process' thread list.
|
|
|
|
void UnregisterThread(const Thread* thread);
|
|
|
|
|
2018-12-05 00:08:56 +00:00
|
|
|
/// Clears the signaled state of the process if and only if it's signaled.
|
|
|
|
///
|
|
|
|
/// @pre The process must not be already terminated. If this is called on a
|
|
|
|
/// terminated process, then ERR_INVALID_STATE will be returned.
|
|
|
|
///
|
|
|
|
/// @pre The process must be in a signaled state. If this is called on a
|
|
|
|
/// process instance that is not signaled, ERR_INVALID_STATE will be
|
|
|
|
/// returned.
|
|
|
|
ResultCode ClearSignalState();
|
|
|
|
|
2018-09-23 00:09:32 +00:00
|
|
|
/**
|
|
|
|
* Loads process-specifics configuration info with metadata provided
|
|
|
|
* by an executable.
|
|
|
|
*
|
2018-12-20 04:50:20 +00:00
|
|
|
* @param metadata The provided metadata to load process specific info from.
|
|
|
|
*
|
|
|
|
* @returns RESULT_SUCCESS if all relevant metadata was able to be
|
|
|
|
* loaded and parsed. Otherwise, an error code is returned.
|
2015-05-08 21:11:06 +00:00
|
|
|
*/
|
2018-12-20 04:50:20 +00:00
|
|
|
ResultCode LoadFromMetadata(const FileSys::ProgramMetadata& metadata);
|
2015-05-08 21:11:06 +00:00
|
|
|
|
|
|
|
/**
|
2019-04-09 21:03:04 +00:00
|
|
|
* Starts the main application thread for this process.
|
|
|
|
*
|
|
|
|
* @param main_thread_priority The priority for the main thread.
|
|
|
|
* @param stack_size The stack size for the main thread in bytes.
|
2015-05-08 21:11:06 +00:00
|
|
|
*/
|
2019-04-09 21:03:04 +00:00
|
|
|
void Run(s32 main_thread_priority, u64 stack_size);
|
2015-05-04 03:01:16 +00:00
|
|
|
|
2018-09-21 06:06:47 +00:00
|
|
|
/**
|
|
|
|
* Prepares a process for termination by stopping all of its threads
|
|
|
|
* and clearing any other resources.
|
|
|
|
*/
|
|
|
|
void PrepareForTermination();
|
|
|
|
|
2018-10-12 15:36:31 +00:00
|
|
|
void LoadModule(CodeSet module_, VAddr base_addr);
|
2017-09-24 15:12:16 +00:00
|
|
|
|
2015-07-18 02:19:16 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
2018-12-27 23:31:31 +00:00
|
|
|
// Thread-local storage management
|
2015-07-18 02:19:16 +00:00
|
|
|
|
2018-09-21 05:26:29 +00:00
|
|
|
// Marks the next available region as used and returns the address of the slot.
|
2019-06-05 18:32:33 +00:00
|
|
|
[[nodiscard]] VAddr CreateTLSRegion();
|
2018-09-21 05:26:29 +00:00
|
|
|
|
|
|
|
// Frees a used TLS slot identified by the given address
|
2019-06-05 18:32:33 +00:00
|
|
|
void FreeTLSRegion(VAddr tls_address);
|
2018-09-21 05:26:29 +00:00
|
|
|
|
|
|
|
private:
|
2019-03-12 23:03:26 +00:00
|
|
|
explicit Process(Core::System& system);
|
2018-09-21 05:26:29 +00:00
|
|
|
~Process() override;
|
|
|
|
|
2018-12-05 00:08:56 +00:00
|
|
|
/// Checks if the specified thread should wait until this process is available.
|
2019-04-01 22:19:42 +00:00
|
|
|
bool ShouldWait(const Thread* thread) const override;
|
2018-12-05 00:08:56 +00:00
|
|
|
|
|
|
|
/// Acquires/locks this process for the specified thread if it's available.
|
|
|
|
void Acquire(Thread* thread) override;
|
|
|
|
|
|
|
|
/// Changes the process status. If the status is different
|
|
|
|
/// from the current process status, then this will trigger
|
|
|
|
/// a process signal.
|
|
|
|
void ChangeStatus(ProcessStatus new_status);
|
|
|
|
|
2018-09-29 22:47:00 +00:00
|
|
|
/// Memory manager for this process.
|
|
|
|
Kernel::VMManager vm_manager;
|
|
|
|
|
2019-03-28 22:30:58 +00:00
|
|
|
/// Size of the main thread's stack in bytes.
|
|
|
|
u64 main_thread_stack_size = 0;
|
|
|
|
|
2019-03-28 22:52:45 +00:00
|
|
|
/// Size of the loaded code memory in bytes.
|
|
|
|
u64 code_memory_size = 0;
|
|
|
|
|
2018-09-21 06:06:47 +00:00
|
|
|
/// Current status of the process
|
2019-06-05 19:08:01 +00:00
|
|
|
ProcessStatus status{};
|
2018-09-21 06:06:47 +00:00
|
|
|
|
|
|
|
/// The ID of this process
|
2018-12-19 03:16:53 +00:00
|
|
|
u64 process_id = 0;
|
2018-09-21 06:06:47 +00:00
|
|
|
|
2018-09-29 22:47:00 +00:00
|
|
|
/// Title ID corresponding to the process
|
2018-12-19 03:16:53 +00:00
|
|
|
u64 program_id = 0;
|
2018-09-29 22:47:00 +00:00
|
|
|
|
|
|
|
/// Resource limit descriptor for this process
|
|
|
|
SharedPtr<ResourceLimit> resource_limit;
|
|
|
|
|
2018-12-28 02:14:59 +00:00
|
|
|
/// The ideal CPU core for this process, threads are scheduled on this core by default.
|
|
|
|
u8 ideal_core = 0;
|
2018-09-29 22:47:00 +00:00
|
|
|
u32 is_virtual_address_memory_enabled = 0;
|
|
|
|
|
2016-04-19 22:12:48 +00:00
|
|
|
/// The Thread Local Storage area is allocated as processes create threads,
|
|
|
|
/// each TLS area is 0x200 bytes, so one page (0x1000) is split up in 8 parts, and each part
|
2016-09-18 00:38:01 +00:00
|
|
|
/// holds the TLS for a specific thread. This vector contains which parts are in use for each
|
|
|
|
/// page as a bitmask.
|
2016-04-19 22:12:48 +00:00
|
|
|
/// This vector will grow as more pages are allocated for new threads.
|
2019-06-05 18:32:33 +00:00
|
|
|
std::vector<TLSPage> tls_pages;
|
2015-07-18 02:19:16 +00:00
|
|
|
|
2018-12-20 04:50:20 +00:00
|
|
|
/// Contains the parsed process capability descriptors.
|
|
|
|
ProcessCapabilities capabilities;
|
|
|
|
|
2018-09-29 23:13:46 +00:00
|
|
|
/// 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;
|
|
|
|
|
2018-12-05 00:08:56 +00:00
|
|
|
/// Whether or not this process is signaled. This occurs
|
|
|
|
/// upon the process changing to a different state.
|
|
|
|
bool is_signaled = false;
|
|
|
|
|
2018-10-25 22:42:50 +00:00
|
|
|
/// Total running time for the process in ticks.
|
|
|
|
u64 total_process_running_time_ticks = 0;
|
|
|
|
|
2018-10-20 18:34:41 +00:00
|
|
|
/// Per-process handle table for storing created object handles in.
|
|
|
|
HandleTable handle_table;
|
|
|
|
|
2019-03-07 23:48:14 +00:00
|
|
|
/// Per-process address arbiter.
|
|
|
|
AddressArbiter address_arbiter;
|
|
|
|
|
2019-03-14 04:29:54 +00:00
|
|
|
/// The per-process mutex lock instance used for handling various
|
|
|
|
/// forms of services, such as lock arbitration, and condition
|
|
|
|
/// variable related facilities.
|
|
|
|
Mutex mutex;
|
|
|
|
|
2018-11-13 17:25:43 +00:00
|
|
|
/// Random values for svcGetInfo RandomEntropy
|
2019-06-05 19:08:01 +00:00
|
|
|
std::array<u64, RANDOM_ENTROPY_SIZE> random_entropy{};
|
2018-11-13 17:25:43 +00:00
|
|
|
|
2019-03-20 22:53:48 +00:00
|
|
|
/// List of threads that are running with this process as their owner.
|
|
|
|
std::list<const Thread*> thread_list;
|
|
|
|
|
2019-03-12 23:03:26 +00:00
|
|
|
/// System context
|
|
|
|
Core::System& system;
|
|
|
|
|
|
|
|
/// Name of this process
|
2017-09-30 18:15:09 +00:00
|
|
|
std::string name;
|
2015-05-04 03:01:16 +00:00
|
|
|
};
|
|
|
|
|
2018-01-01 19:38:34 +00:00
|
|
|
} // namespace Kernel
|