guest_allocator.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <mutex>
 
#include <rex/platform.h>
#include <rex/result.h>
#include <rex/types.h>
#include <rex/utility.h>
 
namespace rex {
namespace kernel {
class GuestMemory;
}  // namespace kernel
}  // namespace rex
 
namespace rex::kernel::shim {
class GuestHeap;
}  // namespace rex::kernel::shim
 
namespace rex::kernel {
 
class GuestAddressSpace;
class BestFitRangeAllocator;
class WorkspaceHeap;

enum class GuestPool : u8 {
  kHeap, 
  kWorkspace,
  kTitle,
  kCount, 
};

class REX_KERNEL_API GuestAllocator : public NonCopyable {
  struct Key {};
 
 public:
  static constexpr u32 kBlockAlignment = 16;
 
  struct AllocatorStats {
    u64 capacity;
    u64 allocated;
    u64 peak_allocated;
    u64 peak_request_size;
    u64 oom_count;
  };

  GuestAllocator(Key, GuestAddressSpace& memory, u32 base, u32 size, void* state, GuestPool pool);

  [[nodiscard]] static Result<std::unique_ptr<GuestAllocator>> Create(
      rex::kernel::GuestMemory& memory, u32 size, u32 alignment, bool physical, u32 page_size,
      u32 flags, GuestPool pool);

  [[nodiscard]] static const char* GetPoolPlotName(GuestPool pool);
 
  ~GuestAllocator();
 
  [[nodiscard]] u32 GetBase() const;
 
  [[nodiscard]] u32 GetSize() const;
 
  [[nodiscard]] GuestPool GetPool() const;
 
  [[nodiscard]] bool Contains(u32 address) const;

  [[nodiscard]] void* Allocate(u32 size);

  [[nodiscard]] void* Reallocate(void* block, u32 size);

  void Free(void* block);
 
  [[nodiscard]] AllocatorStats GetStats() const;
 
  [[nodiscard]] bool IsConsistent() const;
 
 private:
  friend class rex::kernel::shim::GuestHeap;
 
  [[nodiscard]] static Result<std::unique_ptr<GuestAllocator>> Create(GuestAddressSpace& memory,
                                                                      u32 size, u32 alignment,
                                                                      bool physical, u32 page_size,
                                                                      u32 flags, GuestPool pool);
 
  GuestAddressSpace& memory_;
  u32 base_;
  u32 size_;
  void* state_;
  GuestPool pool_;
  mutable std::mutex mutex_;
  u64 capacity_ = 0;
  u64 allocated_ = 0;
  u64 peak_allocated_ = 0;
  u64 peak_request_size_ = 0;
  u64 oom_count_ = 0;
};
 
}  // namespace rex::kernel
 
namespace rex::kernel {
 
class GuestAddressSpace;

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

  [[nodiscard]] virtual Result<u32> Allocate(u32 size, bool zero) = 0;

  virtual void Free(u32 address) = 0;
};

class REX_KERNEL_API WorkspaceHeap : public ITitleWorkspace, public NonCopyable {
  struct Key {};
 
 public:
  WorkspaceHeap(Key, GuestAddressSpace& memory, u32 base, u32 size);
 
  ~WorkspaceHeap() override;

  [[nodiscard]] static Result<std::unique_ptr<WorkspaceHeap>> Create(GuestAddressSpace& memory,
                                                                     u32 size);

  [[nodiscard]] static u32 ResolveSize(u32 header_size);
 
  [[nodiscard]] u32 GetSize() const;

  [[nodiscard]] u32 GetAllocated() const;

  [[nodiscard]] Result<u32> Allocate(u32 size, bool zero) override;

  void Free(u32 address) override;
 
 private:
  GuestAddressSpace& memory_;
  u32 base_;
  u32 size_;
  std::unique_ptr<BestFitRangeAllocator> ranges_;
  mutable std::mutex mutex_;
};
 
}  // namespace rex::kernel