thread_registry.h

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <memory>
#include <optional>
#include <span>
#include <vector>
 
#include <rex/platform.h>
#include <rex/platform/socket.h>
#include <rex/platform/sync.h>
#include <rex/platform/thread.h>
#include <rex/ppc/context.h>
#include <rex/result.h>
#include <rex/kernel/object/kernel_thread.h>
#include <rex/kernel/types/status.h>
#include <rex/types.h>
#include <rex/module.h>
#include <rex/utility.h>
 
namespace rex::kernel {

class ThreadPin : public rex::MoveOnly {
 public:
  ThreadPin() = default;
  explicit ThreadPin(KernelThread* thread) noexcept : thread_(thread) {}
  ThreadPin(ThreadPin&& other) noexcept : thread_(other.thread_) { other.thread_ = nullptr; }
  ThreadPin& operator=(ThreadPin&& other) noexcept {
    if (this != &other) {
      Reset();
      thread_ = other.thread_;
      other.thread_ = nullptr;
    }
    return *this;
  }
  ~ThreadPin() { Reset(); }
 
  explicit operator bool() const noexcept { return thread_ != nullptr; }
  KernelThread* operator->() const noexcept { return thread_; }
  KernelThread& operator*() const noexcept { return *thread_; }
  [[nodiscard]] KernelThread* GetThread() const noexcept { return thread_; }
 
  void Reset() noexcept {
    if (thread_ != nullptr) {
      if (thread_->pins.Unpin()) {
        delete thread_;
      }
      thread_ = nullptr;
    }
  }
 
 private:
  KernelThread* thread_ = nullptr;
};

struct GuestFiber {
  rex::platform::Fiber* host_fiber;
  u32 uid; 
  u32 guest_context_addr;
  u32 guest_stack_bottom; 
  bool is_thread_fiber;   
};

class IObjectWaiter {
 public:
  virtual ~IObjectWaiter() = default;

  virtual rex::platform::WaitResult WaitHostObject(rex::platform::WaitHandle* handle,
                                                   std::chrono::milliseconds timeout) = 0;

  virtual X_STATUS WaitGuestObject(X_HANDLE handle, u32 wait_reason, u32 processor_mode,
                                   u32 alertable, u64* opt_timeout) = 0;

  virtual X_STATUS WaitGuestObjects(std::span<const X_HANDLE> handles, u32 wait_type,
                                    u32 wait_reason, u32 processor_mode, u32 alertable,
                                    u64* opt_timeout) = 0;

  virtual rex::platform::WaitResult WaitHostSockets(
      std::span<const rex::platform::SocketWait> sockets, std::chrono::milliseconds timeout) = 0;
};

REX_DECLARE_INTERFACE(IThreadRegistry, 2)
  virtual ~IThreadRegistry() = default;

  [[nodiscard]] virtual Result<X_HANDLE> Launch(std::unique_ptr<KernelThread> thread) = 0;

  [[nodiscard]] virtual Result<X_HANDLE> CreateTaskThread(u32 start_address, u32 start_context) = 0;

  [[nodiscard]] virtual ICallingThread* GetCallingThread() = 0;
 
  [[nodiscard]] virtual IObjectWaiter& GetObjectWaiter() = 0;

  virtual void SleepCurrentThread(std::chrono::microseconds duration) = 0;

  [[nodiscard]] virtual ThreadPin Find(u32 thread_id) = 0;

  [[nodiscard]] virtual ThreadPin FindByHandle(X_HANDLE handle) = 0;
 
  [[nodiscard]] virtual std::vector<ThreadPin> All() = 0;

  [[nodiscard]] virtual std::optional<u32> AllocateTLS(PPCContext* context) = 0;

  virtual void FreeTLS(PPCContext* context, u32 slot) = 0;

  [[nodiscard]] virtual std::optional<GuestFiber> FindFiber(u32 address) = 0;

  virtual void RegisterFiber(u32 address, const GuestFiber& info) = 0;
 
  virtual void UnregisterFiber(u32 address) = 0;

  [[nodiscard]] virtual const char* GetOrCreateFiberName(u32 fiber_uid,
                                                         const char* thread_name) = 0;

  virtual void RegisterThreadNotify(u32 notification) = 0;

  virtual void UnregisterThreadNotify(u32 notification) = 0;
};
 
}  // namespace rex::kernel
 
namespace rex::kernel {

struct CompletionOptions {
  X_RESULT result;
  std::optional<u32> extended_error =
      std::nullopt;                         
  std::optional<u32> length = std::nullopt; 
};

REX_DECLARE_INTERFACE(IOverlappedDispatcher, 1)
  virtual ~IOverlappedDispatcher() = default;

  virtual void Complete(u32 overlapped, const CompletionOptions& options) = 0;

  virtual void Publish(rex::MoveOnlyFunction<void()> publish) = 0;

  virtual u32 Observe(rex::MoveOnlyFunction<u32()> observe) = 0;

  virtual void CompleteDeferred(u32 overlapped, rex::MoveOnlyFunction<void()> work,
                                const CompletionOptions& options,
                                rex::MoveOnlyFunction<void()> pre = {},
                                rex::MoveOnlyFunction<void()> post = {}) = 0;

  virtual void CompleteDeferred(u32 overlapped, rex::MoveOnlyFunction<CompletionOptions()> work,
                                rex::MoveOnlyFunction<void()> pre = {},
                                rex::MoveOnlyFunction<void()> post = {}) = 0;
};

REX_DECLARE_INTERFACE(IDPCQueue, 1)
  virtual ~IDPCQueue() = default;

  virtual bool Queue(u32 dpc, u32 arg1, u32 arg2) = 0;

  virtual bool Remove(u32 dpc) = 0;

  virtual void Drain() = 0;
};
 
}  // namespace rex::kernel