kernel_thread.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <atomic>
#include <chrono>
#include <cstddef>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
 
#include <rex/assert.h>
#include <rex/kernel/types/status.h>
#include <rex/platform.h>
#include <rex/kernel/object/object.h>
#include <rex/kernel/thread_state.h>
#include <rex/kernel/types/list.h>
#include <rex/kernel/types/memory.h>
#include <rex/kernel/types/thread.h>
#include <rex/platform/thread.h>
#include <rex/types.h>
#include <rex/utility.h>
 
namespace rex {
namespace kernel {
class TitleRuntime;
}  // namespace kernel
}  // namespace rex
 
namespace rex::kernel {
 
class ThreadRegistry;

struct ThreadRef : public rex::NonCopyable {
  ThreadRef(u32 thread_id_in, ThreadRegistry* registry_in)
      : thread_id(thread_id_in), registry(registry_in) {}
  REX_KERNEL_API ~ThreadRef();
 
  u32 thread_id;            
  ThreadRegistry* registry; 
};

class ICallingThread {
 public:
  virtual ~ICallingThread() = default;
 
  virtual u32 GetLastError() = 0;
 
  virtual void SetLastError(u32 error_code) = 0;

  virtual bool IsMainThread() const = 0;
};

class REX_KERNEL_API KernelThread : public ICallingThread, public rex::NonCopyable {
 public:
  static constexpr u32 kStackAddressRangeBegin = 0x70000000;
  static constexpr u32 kStackAddressRangeEnd = 0x7F000000;
 
  struct CreationParams {
    u32 stack_size;          
    u32 xapi_thread_startup; 
    u32 start_address;       
    u32 start_context;       
    u32 creation_flags;      
    u32 title_process;       
  };

  KernelThread(TitleRuntime& runtime, u32 stack_size, u32 xapi_thread_startup, u32 start_address,
               u32 start_context, u32 creation_flags, bool guest_thread, bool main_thread = false,
               u32 title_process = 0);

  KernelThread(TitleRuntime& runtime, u32 stack_size, u32 creation_flags,
               rex::MoveOnlyFunction<int()> host_fn);
  ~KernelThread();
 
  static bool IsInThread(const KernelThread* other);
 
  static bool IsInThread();
 
  static KernelThread* GetCallingThread();
 
  static u32 GetCurrentThreadHandle();

  static void CheckStop();

  static bool IsStopPending();

  static void SleepFor(std::chrono::microseconds duration);

  static void WriteKernelTime();
 
  TitleRuntime& GetRuntime() const { return *runtime_; }
 
  kernel::GuestAddressSpace* GetAddressSpace() const;

  X_HANDLE GetHandle() const { return handle_; }
 
  u32 GetGuestObject() const { return guest_object_ptr_; }

  template <typename T>
  T* GetGuestObject() {
    return GetAddressSpace()->TranslateVirtual<T*>(guest_object_ptr_);
  }
 
  const std::string& GetName() const { return thread_name_; }

  std::string_view GetCrashName() const {
    return {crash_name_.data(), crash_name_length_.load(std::memory_order_acquire)};
  }
 
  const CreationParams* GetCreationParams() const { return &creation_params_; }
 
  u32 GetTLSPtr() const { return tls_static_address_; }
 
  u32 GetPCRPtr() const { return pcr_address_; }
 
  bool IsGuestThread() const { return guest_thread_; }
 
  bool IsMainThread() const override { return main_thread_; }
 
  bool IsRunning() const { return running_; }
 
  u32 GetThreadID() const { return thread_id_; }
 
  u32 GetLastError() override;
 
  void SetLastError(u32 error_code) override;

  void SetName(const std::string_view name);

  [[noreturn]] void Exit(int exit_code);

  void RequestStop(i32 exit_code = 0);

  bool ForceStop();
 
  rex::platform::Fiber* GetMainFiber() const { return main_fiber_; }
 
  void SetMainFiber(rex::platform::Fiber* fiber) { main_fiber_ = fiber; }

  void EnterCriticalRegion();

  void LeaveCriticalRegion();
 
  void DeliverAPCs();

  bool HasPendingAPCs();
 
  void EnqueueAPC(u32 normal_routine, u32 normal_context, u32 arg1, u32 arg2);
 
  i32 GetPriority() const { return priority_; }
 
  i32 GetHostPriority();
 
  void SetPriority(i32 increment);

  bool SetAffinity(u32 affinity);
 
  u8 GetActiveCPU() const;
 
  void SetActiveCPU(u8 cpu_index);

  bool GetTLSValue(u32 slot, u32* value_out) const;

  bool SetTLSValue(u32 slot, u32 value);
 
  u32 GetSuspendCount();

  X_STATUS Resume(u32* out_suspend_count = nullptr);

  X_STATUS Suspend(u32* out_suspend_count = nullptr);

  X_STATUS Delay(u32 processor_mode, u32 alertable, u64 interval) const;
 
  rex::platform::Thread* GetThread() { return thread_.get(); }
 
  kernel::ThreadState* GetThreadState() { return thread_state_.get(); }
 
  PinCount pins; 
 
 protected:
  void FreeStack();
  void InitializeGuestObject();
 
  void RundownAPCs();
  void CallThreadNotifyRoutines(bool create);
 
  CreationParams creation_params_ = {0, 0, 0, 0, 0, 0};
 
  u32 thread_id_ = 0;
  u32 scratch_address_ = 0;
  u32 scratch_size_ = 0; 
  u32 tls_static_address_ = 0;
  u32 tls_dynamic_address_ = 0;
  std::atomic<u32> tls_slot_count_{0};
  u32 pcr_address_ = 0;
  u32 stack_alloc_base_ = 0;
  u32 stack_base_ = 0;
  u32 stack_limit_ = 0;
  bool guest_thread_ = false;
  bool main_thread_ = false;
  std::atomic<bool> running_{false};
  std::atomic<bool> exiting_{false};
  std::atomic<i32> stop_exit_code_{0};
  std::mutex stop_mutex_;
  bool stop_requested_ = false;
 
  std::string thread_name_;
  std::array<char, 64> crash_name_{};
  std::atomic<u8> crash_name_length_{0};
  std::unique_ptr<kernel::ThreadState> thread_state_;
 
  i32 priority_ = 0;
 
  struct SuspendWait;
  std::unique_ptr<SuspendWait> suspend_wait_;
  std::atomic<bool> suspend_deferred_{false};
 
  std::mutex thread_lock_; 
 
  std::unique_ptr<rex::platform::Thread> thread_ = nullptr;
  rex::platform::Fiber* main_fiber_ = nullptr;
 
 private:
  friend class ThreadRegistry;

  X_STATUS Create();

  void Start();

  void Abandon();
  void SetHandle(X_HANDLE handle) { handle_ = handle; }
  void SetGuestObject(u32 address) { guest_object_ptr_ = address; }
  int Execute();
  void Finish(int exit_code);
  [[noreturn]] static void ThrowStop();
  bool ShouldStop() const;
  void WaitForResume(std::unique_lock<std::mutex>& lock);
  void ReleaseSelf();

  void ReleaseReference();

  u32 SelfSuspend();

  void TakeDeferredSuspend();

  u32 GetProcessAddress() const;
 
  void WriteExitState(u32 exit_code);
 
  TitleRuntime* runtime_;
  ThreadRegistry* registry_ = nullptr;
  X_HANDLE handle_ = 0;
  u32 guest_object_ptr_ = 0;
  rex::MoveOnlyFunction<int()> host_fn_;
  std::atomic<bool> released_{false};
  std::atomic<bool> abandoned_{false};
  bool exited_ = false;
  bool handles_closed_ = false;
};
 
}  // namespace rex::kernel