object.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <atomic>
#include <chrono>
#include <concepts>
#include <cstddef>
#include <format>
#include <memory>
#include <span>
#include <string>
#include <vector>
 
#include <rex/kernel/types/thread.h>
#include <rex/platform.h>
#include <rex/types.h>
#include <rex/assert.h>
#include <rex/memory/endian.h>
#include <rex/platform/thread.h>
#include <rex/platform/sync.h>
#include <rex/kernel/heap.h>
#include <rex/kernel/types/status.h>
#include <rex/memory/host.h>
 
namespace rex {
namespace kernel {
class TitleRuntime;
}  // namespace kernel
}  // namespace rex
 
namespace rex::kernel {

constexpr memory::FourCCT kStashSignature = memory::make_fourcc('R', 'E', 'X', '\0');
 
enum class ObjectType : u8 {
  kEvent,
  kSemaphore,
  kMutant,
  kTimer,
  kFile,
  kNotifyListener,
  kIOCompletion,
  kSymbolicLink,
  kModule,
  kThread,
  kXAM,
};

inline constexpr u32 kHandleBase = 0xF8000000;

REX_KERNEL_API std::chrono::milliseconds TimeoutFromTicks(i64 timeout_ticks);

REX_KERNEL_API std::chrono::microseconds DelayFromTicks(i64 delay_ticks);

REX_KERNEL_API std::string NameFromAttributes(kernel::GuestAddressSpace* memory,
                                              u32 obj_attributes_ptr);
 
template <typename T>
class Pinned;
class ObjectPin;

REX_KERNEL_API X_STATUS Wait(TitleRuntime& runtime, const ObjectPin& object, u32 wait_reason,
                             u32 processor_mode, u32 alertable, u64* opt_timeout);

REX_KERNEL_API X_STATUS WaitMultiple(TitleRuntime& runtime, std::span<const ObjectPin> objects,
                                     u32 wait_type, u32 wait_reason, u32 processor_mode,
                                     u32 alertable, u64* opt_timeout);

REX_KERNEL_API X_STATUS SignalAndWait(TitleRuntime& runtime, const ObjectPin& signal_object,
                                      const ObjectPin& wait_object, u32 wait_reason,
                                      u32 processor_mode, u32 alertable, u64* opt_timeout);
 
}  // namespace rex::kernel

template <>
struct std::formatter<rex::kernel::ObjectType> : std::formatter<rex::u32> {
  auto format(rex::kernel::ObjectType value, std::format_context& ctx) const {
    return std::formatter<rex::u32>::format(static_cast<rex::u32>(value), ctx);
  }
};
 
namespace rex::kernel {

class PinCount {
 public:
  void Pin() noexcept { count_.fetch_add(1, std::memory_order_acquire); }

  [[nodiscard]] bool Unpin() noexcept {
    return count_.fetch_sub(1, std::memory_order_acq_rel) - 1 == kRetired;
  }

  [[nodiscard]] bool Retire() noexcept {
    return count_.fetch_or(kRetired, std::memory_order_acq_rel) == 0;
  }

  [[nodiscard]] u32 GetPins() const noexcept {
    return count_.load(std::memory_order_acquire) & ~kRetired;
  }
 
 private:
  static constexpr u32 kRetired = 0x80000000u;
  std::atomic<u32> count_{0};
};

template <typename T>
class PublishedPtr {
 public:
  PublishedPtr() = default;

  PublishedPtr(std::unique_ptr<T> owner) { Replace(std::move(owner)); }
 
  PublishedPtr& operator=(std::unique_ptr<T> owner) {
    Replace(std::move(owner));
    return *this;
  }

  T* get() noexcept { return current_.load(std::memory_order_acquire); }
 
  const T* get() const noexcept { return current_.load(std::memory_order_acquire); }
 
  T* operator->() noexcept { return get(); }
 
  const T* operator->() const noexcept { return get(); }
 
  explicit operator bool() const noexcept { return get() != nullptr; }
 
  friend bool operator==(const PublishedPtr& value, std::nullptr_t) noexcept {
    return value.get() == nullptr;
  }

  void Replace(std::unique_ptr<T> next) {
    if (owner_) {
      retired_.push_back(std::move(owner_));
    }
    owner_ = std::move(next);
    current_.store(owner_.get(), std::memory_order_release);
  }

  [[nodiscard]] std::unique_ptr<T> Take() noexcept {
    current_.store(nullptr, std::memory_order_relaxed);
    return std::move(owner_);
  }
 
 private:
  std::atomic<T*> current_{nullptr};
  std::unique_ptr<T> owner_;
  std::vector<std::unique_ptr<T>> retired_;
};
 
}  // namespace rex::kernel
 
namespace rex::kernel {
 
inline constexpr memory::Tag kRuntime{2};
 
}  // namespace rex::kernel