guest_memory.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstring>
#include <span>
#include <string>
#include <type_traits>
 
#include <rex/platform.h>
#include <rex/result.h>
#include <rex/types.h>
 
namespace rex::kernel {
 
class TitleState;
class GuestAllocator;
class GuestAddressSpace;
class MemoryView;
 
enum class GuestProtect : u8 {
  kReadOnly,
  kReadWrite,
};
 
enum class GuestHeap : u8 {
  kTitle,    
  kSystem,   
  kPhysical, 
};

class REX_KERNEL_API GuestMemory {
 public:
  GuestMemory(const GuestMemory&) = delete;
  GuestMemory& operator=(const GuestMemory&) = delete;

  [[nodiscard]] Result<void> CopyFrom(u32 address, std::span<std::byte> out) const;

  [[nodiscard]] Result<void> CopyTo(u32 address, std::span<const std::byte> data);

  [[nodiscard]] Result<std::span<const std::byte>> GetReadOnlySpan(u32 address, u32 length) const;

  [[nodiscard]] Result<std::span<std::byte>> GetWritableSpan(u32 address, u32 length);

  template <typename T>
    requires std::is_trivially_copyable_v<T>
  [[nodiscard]] Result<T> Load(u32 address) const;

  template <typename T>
    requires std::is_trivially_copyable_v<T>
  [[nodiscard]] Result<void> Store(u32 address, const T& value);

  [[nodiscard]] Result<std::string> ReadString(u32 address, u32 max_length = 4096) const;

  [[nodiscard]] Result<std::u16string> ReadString16(u32 address, u32 max_length = 4096) const;

  [[nodiscard]] Result<u32> Allocate(u32 size, u32 alignment, GuestProtect protect,
                                     GuestHeap heap = GuestHeap::kTitle);

  [[nodiscard]] Result<void> Free(u32 address);

  [[nodiscard]] Result<void> Protect(u32 address, u32 length, GuestProtect protect);

  [[nodiscard]] kernel::MemoryView GetView() const;

  [[nodiscard]] Result<u32> HostToGuest(const void* host) const;
 
 private:
  friend class TitleRuntime;
  friend class kernel::GuestAllocator;
  friend class kernel::TitleState;
  explicit GuestMemory(kernel::GuestAddressSpace& memory);
  kernel::GuestAddressSpace& GetAddressSpace() const;
  ~GuestMemory();
 
  struct State;
  State* state_ = nullptr;
};

template <typename T>
  requires std::is_trivially_copyable_v<T>
[[nodiscard]] Result<T> GuestMemory::Load(u32 address) const {
  T value;
  REX_TRY_VOID(CopyFrom(address, std::as_writable_bytes(std::span(&value, 1))));
  return value;
}

template <typename T>
  requires std::is_trivially_copyable_v<T>
[[nodiscard]] Result<void> GuestMemory::Store(u32 address, const T& value) {
  return CopyTo(address, std::as_bytes(std::span(&value, 1)));
}
 
}  // namespace rex::kernel