memory.h

Go to the documentation of this file.

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

enum X_MEM : u32 {
  kXMemCommit = 0x00001000,
  kXMemReserve = 0x00002000,
  kXMemDecommit = 0x00004000, 
  kXMemRelease = 0x00008000,  
  kXMemFree = 0x00010000,     
  kXMemPrivate = 0x00020000,  
  kXMemReset = 0x00080000,    
  kXMemTopDown = 0x00100000,
  kXMemNoZero = 0x00800000,
  kXMemLargePages = 0x20000000, 
  kXMemHeap = 0x40000000,       
  kXMem16MBPages = 0x80000000   
};

enum X_PAGE : u16 {
  kXPageNoAccess = 0x00000001, 
  kXPageReadOnly = 0x00000002,
  kXPageReadWrite = 0x00000004,
  kXPageWriteCopy = 0x00000008,        
  kXPageExecute = 0x00000010,          
  kXPageExecuteRead = 0x00000020,      
  kXPageExecuteReadWrite = 0x00000040, 
  kXPageExecuteWriteCopy =
      0x00000080,           
  kXPageGuard = 0x00000100, 
  kXPageNoCache = 0x00000200, 
  kXPageWriteCombine =
      0x00000400 
};
 
}  // namespace rex::kernel
 
namespace rex::kernel {
 
namespace detail {

template <typename P, typename T>
inline constexpr bool kIsHostPointerFor =
    (std::is_pointer_v<P> || std::is_null_pointer_v<P>) && std::is_convertible_v<P, const T*>;
 
}  // namespace detail

template <typename T>
struct be_ptr {
  be_u32 value;
 
  operator u32() const { return value; }

  u32 GetAddress() const { return value; }
 
  explicit operator bool() const { return value != 0; }

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

  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*>(value);
  }

  T* GetHost(const rex::kernel::MemoryView& view) const {
    return value == 0 ? nullptr : view.TranslateVirtual<T*>(value);
  }

  T* TryGetHost(const rex::kernel::MemoryView& view) const {
    return view.TryTranslateVirtual<T*>(value);
  }
 
  T* operator->() const { return GetHost(); }
 
  be_ptr& operator=(u32 v) {
    value = v;
    return *this;
  }

  template <typename P>
    requires(detail::kIsHostPointerFor<P, T>)
  be_ptr& operator=(P host_pointer) {
    if constexpr (std::is_null_pointer_v<P>) {
      value = 0;
    } else {
      if (host_pointer == nullptr) {
        value = 0;
        return *this;
      }
      auto* thread_state = rex::kernel::ThreadState::Get();
      REX_ASSERT(thread_state != nullptr);
      value = rex::memory::HostPtrToGuest(thread_state->GetAddressSpace()->GetVirtualMembase(),
                                          reinterpret_cast<const void*>(host_pointer));
    }
    return *this;
  }
};

template <typename T>
struct GuestVector {
  be_ptr<T> first; 
  be_ptr<T> last;  
  be_ptr<T> limit; 

  size_t size() const {
    const u32 begin_address = first.GetAddress();
    const u32 end_address = last.GetAddress();
    return end_address > begin_address ? (end_address - begin_address) / sizeof(T) : 0;
  }
 
  bool empty() const { return size() == 0; }

  const T* begin() const { return first.GetHost(); }

  const T* end() const { return last.GetHost(); }

  const T* begin(const rex::kernel::MemoryView& view) const { return first.GetHost(view); }

  const T* end(const rex::kernel::MemoryView& view) const { return last.GetHost(view); }

  const T& operator[](size_t index) const { return begin()[index]; }

  u32 GetAddress(size_t index) const {
    return index < size() ? first.GetAddress() + static_cast<u32>(index * sizeof(T)) : 0;
  }

  const T* TryAt(size_t index, const rex::kernel::MemoryView& view) const {
    const u32 address = GetAddress(index);
    const u64 last_byte = static_cast<u64>(address) + sizeof(T) - 1;
    if (address == 0 || last_byte > 0xFFFFFFFFull) {
      return nullptr;
    }
    const T* element = view.TryTranslateVirtual<const T*>(address);
    if (element == nullptr ||
        view.TryTranslateVirtual<const u8*>(static_cast<u32>(last_byte)) == nullptr) {
      return nullptr;
    }
    return element;
  }

  std::optional<T> TryGet(size_t index, const rex::kernel::MemoryView& view) const
    requires(rex::kernel::detail::GuestScalar<T>)
  {
    const u32 address = GetAddress(index);
    if (address == 0) {
      return std::nullopt;
    }
    return view.TryLoad<T>(address);
  }

  const T* TryAt(size_t index) const {
    auto* thread_state = rex::kernel::ThreadState::Get();
    if (thread_state == nullptr || thread_state->GetAddressSpace() == nullptr) {
      return nullptr;
    }
    return TryAt(index, rex::kernel::MemoryView(*thread_state->GetAddressSpace()));
  }
};
REX_STATIC_ASSERT_SIZE(GuestVector<u8>, 12);
 
}  // namespace rex::kernel