memory_view.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstring>
#include <optional>
#include <string_view>
#include <type_traits>
 
#include <rex/kernel/heap.h>
#include <rex/types.h>
#include <rex/assert.h>
#include <rex/kernel/thread_state.h>
 
namespace rex::kernel {
 
namespace detail {

template <typename T>
concept GuestScalar = std::is_arithmetic_v<T> && !std::is_same_v<T, bool>;
 
}  // namespace detail

class MemoryView {
 public:
  explicit MemoryView(const GuestAddressSpace& memory)
      : memory_(&memory), membase_(memory.GetMembase()) {}
 
  u8* GetVirtualMembase() const { return membase_.GetBase(); }
 
  template <typename T = u8*>
  T TranslateVirtual(u32 address) const {
    return membase_.TranslateVirtual<T>(address);
  }

  template <typename T = u8*>
  T TryTranslateVirtual(u32 address, u32 required = kMemoryProtectRead) const {
    return memory_->TryTranslateVirtual<T>(address, required);
  }

  u32 HostToGuestVirtual(const void* host_address) const {
    return membase_.HostToGuestVirtual(host_address);
  }

  template <typename T>
    requires(detail::GuestScalar<T>)
  T Load(u32 address) const {
    BE<T> raw;
    std::memcpy(&raw, TranslateVirtual<const u8*>(address), sizeof(raw));
    return raw.Get();
  }

  template <typename T>
    requires(detail::GuestScalar<T>)
  void Store(u32 address, T value) const {
    const BE<T> raw(value);
    std::memcpy(TranslateVirtual<u8*>(address), &raw, sizeof(raw));
  }

  template <typename T>
    requires(detail::GuestScalar<T>)
  std::optional<T> TryLoad(u32 address) const {
    if (!IsAccessible(address, sizeof(T), kMemoryProtectRead)) {
      return std::nullopt;
    }
    return Load<T>(address);
  }

  template <typename T>
    requires(detail::GuestScalar<T>)
  bool TryStore(u32 address, T value) const {
    if (!IsAccessible(address, sizeof(T), kMemoryProtectRead | kMemoryProtectWrite)) {
      return false;
    }
    Store<T>(address, value);
    return true;
  }

  std::string_view GetCString(u32 address) const {
    if (address == 0) {
      return {};
    }
    return std::string_view(TranslateVirtual<const char*>(address));
  }

  std::optional<std::string_view> TryGetCString(u32 address,
                                                size_t max_length = std::string_view::npos) const {
    const char* start = memory_->TryTranslateVirtual<const char*>(address);
    if (start == nullptr) {
      return std::nullopt;
    }
    constexpr u64 kBlock = 0x1000;
    size_t length = 0;
    while (length < max_length) {
      const u64 current = static_cast<u64>(address) + length;
      if (current > 0xFFFFFFFFull) {
        break;
      }
      if (length != 0 && current % kBlock == 0 &&
          memory_->TryTranslateVirtual<const char*>(static_cast<u32>(current)) != start + length) {
        break;
      }
      const size_t block = static_cast<size_t>(kBlock - current % kBlock);
      const size_t count = max_length - length < block ? max_length - length : block;
      if (const void* end = std::memchr(start + length, '\0', count)) {
        length = static_cast<size_t>(static_cast<const char*>(end) - start);
        break;
      }
      length += count;
    }
    return std::string_view(start, length);
  }
 
 private:
  bool IsAccessible(u32 address, u32 size, u32 required) const {
    const u32 last = address + (size - 1);
    return last >= address && memory_->TryTranslateVirtual<const u8*>(address, required) &&
           memory_->TryTranslateVirtual<const u8*>(last, required);
  }
 
  const GuestAddressSpace* memory_;
  rex::memory::GuestMembase membase_;
};
 
}  // namespace rex::kernel
 
namespace rex::kernel {

template <typename T, u32 Address>
struct GuestGlobal {
  static_assert(Address != 0, "A guest global needs a nonzero address");
  static_assert(Address % alignof(T) == 0, "A guest global address must be aligned for its type");
  static_assert(std::is_trivially_copyable_v<T>, "A guest global holds a trivially copyable type");
 
  static constexpr u32 GetAddress() { return Address; }

  T* GetHost() const {
    auto* thread_state = rex::kernel::ThreadState::Get();
    REX_ASSERT(thread_state != nullptr);
    return rex::memory::GuestPtr<T*>(thread_state->GetAddressSpace()->GetVirtualMembase(), Address);
  }

  T* GetHost(const rex::kernel::MemoryView& view) const {
    return view.TranslateVirtual<T*>(Address);
  }

  T* TryGetHost() const {
    auto* thread_state = rex::kernel::ThreadState::Get();
    if (thread_state == nullptr || thread_state->GetAddressSpace() == nullptr) {
      return nullptr;
    }
    return thread_state->GetAddressSpace()->TryTranslateVirtual<T*>(Address);
  }

  T* TryGetHost(const rex::kernel::MemoryView& view) const {
    return view.TryTranslateVirtual<T*>(Address);
  }
 
  T* operator->() const { return GetHost(); }
 
  T& operator*() const { return *GetHost(); }
};
 
}  // namespace rex::kernel

#define REX_GUEST_GLOBAL(type, name, address) \
  inline constexpr rex::kernel::GuestGlobal<type, address> name {}