summaryrefslogtreecommitdiffstats
path: root/src/core/hle/kernel/k_process.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/hle/kernel/k_process.h')
-rw-r--r--src/core/hle/kernel/k_process.h186
1 files changed, 98 insertions, 88 deletions
diff --git a/src/core/hle/kernel/k_process.h b/src/core/hle/kernel/k_process.h
index a19d9b09d..7b7a971b8 100644
--- a/src/core/hle/kernel/k_process.h
+++ b/src/core/hle/kernel/k_process.h
@@ -107,66 +107,76 @@ public:
/// Gets a reference to the process' page table.
KPageTable& PageTable() {
- return page_table;
+ return m_page_table;
}
/// Gets const a reference to the process' page table.
const KPageTable& PageTable() const {
- return page_table;
+ return m_page_table;
+ }
+
+ /// Gets a reference to the process' page table.
+ KPageTable& GetPageTable() {
+ return m_page_table;
+ }
+
+ /// Gets const a reference to the process' page table.
+ const KPageTable& GetPageTable() const {
+ return m_page_table;
}
/// Gets a reference to the process' handle table.
KHandleTable& GetHandleTable() {
- return handle_table;
+ return m_handle_table;
}
/// Gets a const reference to the process' handle table.
const KHandleTable& GetHandleTable() const {
- return handle_table;
+ return m_handle_table;
}
Result SignalToAddress(VAddr address) {
- return condition_var.SignalToAddress(address);
+ return m_condition_var.SignalToAddress(address);
}
Result WaitForAddress(Handle handle, VAddr address, u32 tag) {
- return condition_var.WaitForAddress(handle, address, tag);
+ return m_condition_var.WaitForAddress(handle, address, tag);
}
void SignalConditionVariable(u64 cv_key, int32_t count) {
- return condition_var.Signal(cv_key, count);
+ return m_condition_var.Signal(cv_key, count);
}
Result WaitConditionVariable(VAddr address, u64 cv_key, u32 tag, s64 ns) {
- R_RETURN(condition_var.Wait(address, cv_key, tag, ns));
+ R_RETURN(m_condition_var.Wait(address, cv_key, tag, ns));
}
Result SignalAddressArbiter(VAddr address, Svc::SignalType signal_type, s32 value, s32 count) {
- R_RETURN(address_arbiter.SignalToAddress(address, signal_type, value, count));
+ R_RETURN(m_address_arbiter.SignalToAddress(address, signal_type, value, count));
}
Result WaitAddressArbiter(VAddr address, Svc::ArbitrationType arb_type, s32 value,
s64 timeout) {
- R_RETURN(address_arbiter.WaitForAddress(address, arb_type, value, timeout));
+ R_RETURN(m_address_arbiter.WaitForAddress(address, arb_type, value, timeout));
}
VAddr GetProcessLocalRegionAddress() const {
- return plr_address;
+ return m_plr_address;
}
/// Gets the current status of the process
State GetState() const {
- return state;
+ return m_state;
}
/// Gets the unique ID that identifies this particular process.
- u64 GetProcessID() const {
- return process_id;
+ u64 GetProcessId() const {
+ return m_process_id;
}
/// Gets the program ID corresponding to this process.
- u64 GetProgramID() const {
- return program_id;
+ u64 GetProgramId() const {
+ return m_program_id;
}
/// Gets the resource limit descriptor for this process
@@ -174,7 +184,7 @@ public:
/// Gets the ideal CPU core ID for this process
u8 GetIdealCoreId() const {
- return ideal_core;
+ return m_ideal_core;
}
/// Checks if the specified thread priority is valid.
@@ -184,17 +194,17 @@ public:
/// Gets the bitmask of allowed cores that this process' threads can run on.
u64 GetCoreMask() const {
- return capabilities.GetCoreMask();
+ return m_capabilities.GetCoreMask();
}
/// Gets the bitmask of allowed thread priorities.
u64 GetPriorityMask() const {
- return capabilities.GetPriorityMask();
+ return m_capabilities.GetPriorityMask();
}
/// Gets the amount of secure memory to allocate for memory management.
u32 GetSystemResourceSize() const {
- return system_resource_size;
+ return m_system_resource_size;
}
/// Gets the amount of secure memory currently in use for memory management.
@@ -214,67 +224,67 @@ public:
/// Whether this process is an AArch64 or AArch32 process.
bool Is64BitProcess() const {
- return is_64bit_process;
+ return m_is_64bit_process;
}
- [[nodiscard]] bool IsSuspended() const {
- return is_suspended;
+ bool IsSuspended() const {
+ return m_is_suspended;
}
void SetSuspended(bool suspended) {
- is_suspended = suspended;
+ m_is_suspended = suspended;
}
/// Gets the total running time of the process instance in ticks.
u64 GetCPUTimeTicks() const {
- return total_process_running_time_ticks;
+ return m_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;
+ m_total_process_running_time_ticks += ticks;
}
/// Gets the process schedule count, used for thread yielding
s64 GetScheduledCount() const {
- return schedule_count;
+ return m_schedule_count;
}
/// Increments the process schedule count, used for thread yielding.
void IncrementScheduledCount() {
- ++schedule_count;
+ ++m_schedule_count;
}
void IncrementRunningThreadCount();
void DecrementRunningThreadCount();
void SetRunningThread(s32 core, KThread* thread, u64 idle_count) {
- running_threads[core] = thread;
- running_thread_idle_counts[core] = idle_count;
+ m_running_threads[core] = thread;
+ m_running_thread_idle_counts[core] = idle_count;
}
void ClearRunningThread(KThread* thread) {
- for (size_t i = 0; i < running_threads.size(); ++i) {
- if (running_threads[i] == thread) {
- running_threads[i] = nullptr;
+ for (size_t i = 0; i < m_running_threads.size(); ++i) {
+ if (m_running_threads[i] == thread) {
+ m_running_threads[i] = nullptr;
}
}
}
[[nodiscard]] KThread* GetRunningThread(s32 core) const {
- return running_threads[core];
+ return m_running_threads[core];
}
bool ReleaseUserException(KThread* thread);
[[nodiscard]] KThread* GetPinnedThread(s32 core_id) const {
ASSERT(0 <= core_id && core_id < static_cast<s32>(Core::Hardware::NUM_CPU_CORES));
- return pinned_threads[core_id];
+ return m_pinned_threads[core_id];
}
/// Gets 8 bytes of random data for svcGetInfo RandomEntropy
u64 GetRandomEntropy(std::size_t index) const {
- return random_entropy.at(index);
+ return m_random_entropy.at(index);
}
/// Retrieves the total physical memory available to this process in bytes.
@@ -293,7 +303,7 @@ public:
/// Gets the list of all threads created with this process as their owner.
std::list<KThread*>& GetThreadList() {
- return thread_list;
+ return m_thread_list;
}
/// Registers a thread as being created under this process,
@@ -345,15 +355,15 @@ public:
void LoadModule(CodeSet code_set, VAddr base_addr);
bool IsInitialized() const override {
- return is_initialized;
+ return m_is_initialized;
}
- static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
+ static void PostDestroy(uintptr_t arg) {}
void Finalize() override;
u64 GetId() const override {
- return GetProcessID();
+ return GetProcessId();
}
bool IsSignaled() const override;
@@ -367,7 +377,7 @@ public:
void UnpinThread(KThread* thread);
KLightLock& GetStateLock() {
- return state_lock;
+ return m_state_lock;
}
Result AddSharedMemory(KSharedMemory* shmem, VAddr address, size_t size);
@@ -392,7 +402,7 @@ public:
bool RemoveWatchpoint(Core::System& system, VAddr addr, u64 size, DebugWatchpointType type);
const std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS>& GetWatchpoints() const {
- return watchpoints;
+ return m_watchpoints;
}
const std::string& GetName() {
@@ -403,23 +413,23 @@ private:
void PinThread(s32 core_id, KThread* thread) {
ASSERT(0 <= core_id && core_id < static_cast<s32>(Core::Hardware::NUM_CPU_CORES));
ASSERT(thread != nullptr);
- ASSERT(pinned_threads[core_id] == nullptr);
- pinned_threads[core_id] = thread;
+ ASSERT(m_pinned_threads[core_id] == nullptr);
+ m_pinned_threads[core_id] = thread;
}
void UnpinThread(s32 core_id, KThread* thread) {
ASSERT(0 <= core_id && core_id < static_cast<s32>(Core::Hardware::NUM_CPU_CORES));
ASSERT(thread != nullptr);
- ASSERT(pinned_threads[core_id] == thread);
- pinned_threads[core_id] = nullptr;
+ ASSERT(m_pinned_threads[core_id] == thread);
+ m_pinned_threads[core_id] = nullptr;
}
void FinalizeHandleTable() {
// Finalize the table.
- handle_table.Finalize();
+ m_handle_table.Finalize();
// Note that the table is finalized.
- is_handle_table_initialized = false;
+ m_is_handle_table_initialized = false;
}
void ChangeState(State new_state);
@@ -428,107 +438,107 @@ private:
Result AllocateMainThreadStack(std::size_t stack_size);
/// Memory manager for this process
- KPageTable page_table;
+ KPageTable m_page_table;
/// Current status of the process
- State state{};
+ State m_state{};
/// The ID of this process
- u64 process_id = 0;
+ u64 m_process_id = 0;
/// Title ID corresponding to the process
- u64 program_id = 0;
+ u64 m_program_id = 0;
/// Specifies additional memory to be reserved for the process's memory management by the
/// system. When this is non-zero, secure memory is allocated and used for page table allocation
/// instead of using the normal global page tables/memory block management.
- u32 system_resource_size = 0;
+ u32 m_system_resource_size = 0;
/// Resource limit descriptor for this process
- KResourceLimit* resource_limit{};
+ KResourceLimit* m_resource_limit{};
- VAddr system_resource_address{};
+ VAddr m_system_resource_address{};
/// The ideal CPU core for this process, threads are scheduled on this core by default.
- u8 ideal_core = 0;
+ u8 m_ideal_core = 0;
/// Contains the parsed process capability descriptors.
- ProcessCapabilities capabilities;
+ ProcessCapabilities m_capabilities;
/// 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;
+ bool m_is_64bit_process = true;
/// Total running time for the process in ticks.
- std::atomic<u64> total_process_running_time_ticks = 0;
+ std::atomic<u64> m_total_process_running_time_ticks = 0;
/// Per-process handle table for storing created object handles in.
- KHandleTable handle_table;
+ KHandleTable m_handle_table;
/// Per-process address arbiter.
- KAddressArbiter address_arbiter;
+ KAddressArbiter m_address_arbiter;
/// The per-process mutex lock instance used for handling various
/// forms of services, such as lock arbitration, and condition
/// variable related facilities.
- KConditionVariable condition_var;
+ KConditionVariable m_condition_var;
/// Address indicating the location of the process' dedicated TLS region.
- VAddr plr_address = 0;
+ VAddr m_plr_address = 0;
/// Random values for svcGetInfo RandomEntropy
- std::array<u64, RANDOM_ENTROPY_SIZE> random_entropy{};
+ std::array<u64, RANDOM_ENTROPY_SIZE> m_random_entropy{};
/// List of threads that are running with this process as their owner.
- std::list<KThread*> thread_list;
+ std::list<KThread*> m_thread_list;
/// List of shared memory that are running with this process as their owner.
- std::list<KSharedMemoryInfo*> shared_memory_list;
+ std::list<KSharedMemoryInfo*> m_shared_memory_list;
/// Address of the top of the main thread's stack
- VAddr main_thread_stack_top{};
+ VAddr m_main_thread_stack_top{};
/// Size of the main thread's stack
- std::size_t main_thread_stack_size{};
+ std::size_t m_main_thread_stack_size{};
/// Memory usage capacity for the process
- std::size_t memory_usage_capacity{};
+ std::size_t m_memory_usage_capacity{};
/// Process total image size
- std::size_t image_size{};
+ std::size_t m_image_size{};
/// Schedule count of this process
- s64 schedule_count{};
+ s64 m_schedule_count{};
- size_t memory_release_hint{};
+ size_t m_memory_release_hint{};
std::string name{};
- bool is_signaled{};
- bool is_suspended{};
- bool is_immortal{};
- bool is_handle_table_initialized{};
- bool is_initialized{};
+ bool m_is_signaled{};
+ bool m_is_suspended{};
+ bool m_is_immortal{};
+ bool m_is_handle_table_initialized{};
+ bool m_is_initialized{};
- std::atomic<u16> num_running_threads{};
+ std::atomic<u16> m_num_running_threads{};
- std::array<KThread*, Core::Hardware::NUM_CPU_CORES> running_threads{};
- std::array<u64, Core::Hardware::NUM_CPU_CORES> running_thread_idle_counts{};
- std::array<KThread*, Core::Hardware::NUM_CPU_CORES> pinned_threads{};
- std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> watchpoints{};
- std::map<VAddr, u64> debug_page_refcounts;
+ std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_running_threads{};
+ std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_idle_counts{};
+ std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_pinned_threads{};
+ std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> m_watchpoints{};
+ std::map<VAddr, u64> m_debug_page_refcounts;
- KThread* exception_thread{};
+ KThread* m_exception_thread{};
- KLightLock state_lock;
- KLightLock list_lock;
+ KLightLock m_state_lock;
+ KLightLock m_list_lock;
using TLPTree =
Common::IntrusiveRedBlackTreeBaseTraits<KThreadLocalPage>::TreeType<KThreadLocalPage>;
using TLPIterator = TLPTree::iterator;
- TLPTree fully_used_tlp_tree;
- TLPTree partially_used_tlp_tree;
+ TLPTree m_fully_used_tlp_tree;
+ TLPTree m_partially_used_tlp_tree;
};
} // namespace Kernel