From b17754f998f225f3de9df59c917c7b88f81aaf22 Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Mon, 29 May 2017 14:42:27 -0700 Subject: Kernel: Extract dynamic Object pointer cast into its own function --- src/core/hle/kernel/kernel.h | 35 ++++++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 11 deletions(-) (limited to 'src/core/hle/kernel/kernel.h') diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index 94f2025a0..d8929259e 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -121,6 +121,18 @@ inline void intrusive_ptr_release(Object* object) { template using SharedPtr = boost::intrusive_ptr; +/** + * Attempts to downcast the given Object pointer to a pointer to T. + * @return Derived pointer to the object, or `nullptr` if `object` isn't of type T. + */ +template +inline SharedPtr DynamicObjectCast(SharedPtr object) { + if (object != nullptr && object->GetHandleType() == T::HANDLE_TYPE) { + return boost::static_pointer_cast(std::move(object)); + } + return nullptr; +} + /// Class that represents a Kernel object that a thread can be waiting on class WaitObject : public Object { public: @@ -163,6 +175,15 @@ private: std::vector> waiting_threads; }; +// Specialization of DynamicObjectCast for WaitObjects +template <> +inline SharedPtr DynamicObjectCast(SharedPtr object) { + if (object != nullptr && object->IsWaitable()) { + return boost::static_pointer_cast(std::move(object)); + } + return nullptr; +} + /** * This class allows the creation of Handles, which are references to objects that can be tested * for validity and looked up. Here they are used to pass references to kernel objects to/from the @@ -224,15 +245,11 @@ public: /** * Looks up a handle while verifying its type. * @return Pointer to the looked-up object, or `nullptr` if the handle is not valid or its - * type differs from the handle type `T::HANDLE_TYPE`. + * type differs from the requested one. */ template SharedPtr Get(Handle handle) const { - SharedPtr object = GetGeneric(handle); - if (object != nullptr && object->GetHandleType() == T::HANDLE_TYPE) { - return boost::static_pointer_cast(std::move(object)); - } - return nullptr; + return DynamicObjectCast(GetGeneric(handle)); } /** @@ -241,11 +258,7 @@ public: * not a waitable object. */ SharedPtr GetWaitObject(Handle handle) const { - SharedPtr object = GetGeneric(handle); - if (object != nullptr && object->IsWaitable()) { - return boost::static_pointer_cast(std::move(object)); - } - return nullptr; + return DynamicObjectCast(GetGeneric(handle)); } /// Closes all handles held in this table. -- cgit v1.2.3 From 9453223075e100a94b274613f1da0c47f747edf5 Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Mon, 29 May 2017 15:10:06 -0700 Subject: Kernel: Removed HandleTable::GetWaitObject This isn't necessary anymore since plain Get works correctly for WaitObjects. --- src/core/hle/kernel/kernel.h | 9 --------- 1 file changed, 9 deletions(-) (limited to 'src/core/hle/kernel/kernel.h') diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index d8929259e..4344264dc 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -252,15 +252,6 @@ public: return DynamicObjectCast(GetGeneric(handle)); } - /** - * Looks up a handle while verifying that it is an object that a thread can wait on - * @return Pointer to the looked-up object, or `nullptr` if the handle is not valid or it is - * not a waitable object. - */ - SharedPtr GetWaitObject(Handle handle) const { - return DynamicObjectCast(GetGeneric(handle)); - } - /// Closes all handles held in this table. void Clear(); -- cgit v1.2.3 From 64ecf81a3cf6d6e0a4e4e915e1da2f0bcf2f1cb4 Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Mon, 29 May 2017 15:45:30 -0700 Subject: Kernel: Move WaitObject to a separate file Now that HandleTable doesn't directly depend on WaitObject anymore, this can be separated from the main kernel.h header. --- src/core/hle/kernel/kernel.h | 53 -------------------------------------------- 1 file changed, 53 deletions(-) (limited to 'src/core/hle/kernel/kernel.h') diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index 4344264dc..5335a961d 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -17,8 +17,6 @@ namespace Kernel { using Handle = u32; -class Thread; - enum KernelHandle : Handle { CurrentThread = 0xFFFF8000, CurrentProcess = 0xFFFF8001, @@ -133,57 +131,6 @@ inline SharedPtr DynamicObjectCast(SharedPtr object) { return nullptr; } -/// Class that represents a Kernel object that a thread can be waiting on -class WaitObject : public Object { -public: - /** - * Check if the specified thread should wait until the object is available - * @param thread The thread about which we're deciding. - * @return True if the current thread should wait due to this object being unavailable - */ - virtual bool ShouldWait(Thread* thread) const = 0; - - /// Acquire/lock the object for the specified thread if it is available - virtual void Acquire(Thread* thread) = 0; - - /** - * Add a thread to wait on this object - * @param thread Pointer to thread to add - */ - virtual void AddWaitingThread(SharedPtr thread); - - /** - * Removes a thread from waiting on this object (e.g. if it was resumed already) - * @param thread Pointer to thread to remove - */ - virtual void RemoveWaitingThread(Thread* thread); - - /** - * Wake up all threads waiting on this object that can be awoken, in priority order, - * and set the synchronization result and output of the thread. - */ - virtual void WakeupAllWaitingThreads(); - - /// Obtains the highest priority thread that is ready to run from this object's waiting list. - SharedPtr GetHighestPriorityReadyThread(); - - /// Get a const reference to the waiting threads list for debug use - const std::vector>& GetWaitingThreads() const; - -private: - /// Threads waiting for this object to become available - std::vector> waiting_threads; -}; - -// Specialization of DynamicObjectCast for WaitObjects -template <> -inline SharedPtr DynamicObjectCast(SharedPtr object) { - if (object != nullptr && object->IsWaitable()) { - return boost::static_pointer_cast(std::move(object)); - } - return nullptr; -} - /** * This class allows the creation of Handles, which are references to objects that can be tested * for validity and looked up. Here they are used to pass references to kernel objects to/from the -- cgit v1.2.3 From be031989ee9384786fb9ed380dab9a260ad69fd5 Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Mon, 29 May 2017 16:45:42 -0700 Subject: Kernel: Move HandleTable to a separate file --- src/core/hle/kernel/kernel.h | 116 +------------------------------------------ 1 file changed, 1 insertion(+), 115 deletions(-) (limited to 'src/core/hle/kernel/kernel.h') diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index 5335a961d..9cf288b08 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -4,24 +4,16 @@ #pragma once -#include -#include #include #include -#include +#include #include #include "common/common_types.h" -#include "core/hle/result.h" namespace Kernel { using Handle = u32; -enum KernelHandle : Handle { - CurrentThread = 0xFFFF8000, - CurrentProcess = 0xFFFF8001, -}; - enum class HandleType : u32 { Unknown, Event, @@ -131,112 +123,6 @@ inline SharedPtr DynamicObjectCast(SharedPtr object) { return nullptr; } -/** - * This class allows the creation of Handles, which are references to objects that can be tested - * for validity and looked up. Here they are used to pass references to kernel objects to/from the - * emulated process. it has been designed so that it follows the same handle format and has - * approximately the same restrictions as the handle manager in the CTR-OS. - * - * Handles contain two sub-fields: a slot index (bits 31:15) and a generation value (bits 14:0). - * The slot index is used to index into the arrays in this class to access the data corresponding - * to the Handle. - * - * To prevent accidental use of a freed Handle whose slot has already been reused, a global counter - * is kept and incremented every time a Handle is created. This is the Handle's "generation". The - * value of the counter is stored into the Handle as well as in the handle table (in the - * "generations" array). When looking up a handle, the Handle's generation must match with the - * value stored on the class, otherwise the Handle is considered invalid. - * - * To find free slots when allocating a Handle without needing to scan the entire object array, the - * generations field of unallocated slots is re-purposed as a linked list of indices to free slots. - * When a Handle is created, an index is popped off the list and used for the new Handle. When it - * is destroyed, it is again pushed onto the list to be re-used by the next allocation. It is - * likely that this allocation strategy differs from the one used in CTR-OS, but this hasn't been - * verified and isn't likely to cause any problems. - */ -class HandleTable final : NonCopyable { -public: - HandleTable(); - - /** - * Allocates a handle for the given object. - * @return The created Handle or one of the following errors: - * - `ERR_OUT_OF_HANDLES`: the maximum number of handles has been exceeded. - */ - ResultVal Create(SharedPtr obj); - - /** - * Returns a new handle that points to the same object as the passed in handle. - * @return The duplicated Handle or one of the following errors: - * - `ERR_INVALID_HANDLE`: an invalid handle was passed in. - * - Any errors returned by `Create()`. - */ - ResultVal Duplicate(Handle handle); - - /** - * Closes a handle, removing it from the table and decreasing the object's ref-count. - * @return `RESULT_SUCCESS` or one of the following errors: - * - `ERR_INVALID_HANDLE`: an invalid handle was passed in. - */ - ResultCode Close(Handle handle); - - /// Checks if a handle is valid and points to an existing object. - bool IsValid(Handle handle) const; - - /** - * Looks up a handle. - * @return Pointer to the looked-up object, or `nullptr` if the handle is not valid. - */ - SharedPtr GetGeneric(Handle handle) const; - - /** - * Looks up a handle while verifying its type. - * @return Pointer to the looked-up object, or `nullptr` if the handle is not valid or its - * type differs from the requested one. - */ - template - SharedPtr Get(Handle handle) const { - return DynamicObjectCast(GetGeneric(handle)); - } - - /// Closes all handles held in this table. - void Clear(); - -private: - /** - * This is the maximum limit of handles allowed per process in CTR-OS. It can be further - * reduced by ExHeader values, but this is not emulated here. - */ - static const size_t MAX_COUNT = 4096; - - static u16 GetSlot(Handle handle) { - return handle >> 15; - } - static u16 GetGeneration(Handle handle) { - return handle & 0x7FFF; - } - - /// Stores the Object referenced by the handle or null if the slot is empty. - std::array, MAX_COUNT> objects; - - /** - * The value of `next_generation` when the handle was created, used to check for validity. For - * empty slots, contains the index of the next free slot in the list. - */ - std::array generations; - - /** - * Global counter of the number of created handles. Stored in `generations` when a handle is - * created, and wraps around to 1 when it hits 0x8000. - */ - u16 next_generation; - - /// Head of the free slots linked list. - u16 next_free_slot; -}; - -extern HandleTable g_handle_table; - /// Initialize the kernel with the specified system mode. void Init(u32 system_mode); -- cgit v1.2.3