module_object.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include <rex/kernel/types/status.h>
#include <rex/platform.h>
#include <rex/assert.h>
#include <rex/kernel/types/xex.h>
#include <rex/platform/thread.h>
#include <rex/utility.h>
#include <rex/platform/timer.h>
#include <rex/kernel/export.h>
#include <rex/kernel/module.h>
#include <rex/kernel/types/io.h>
#include <rex/kernel/object/object.h>
#include <rex/kernel/types/list.h>
#include <rex/types.h>
 
namespace rex {
namespace kernel {
class TitleRuntime;
}  // namespace kernel
}  // namespace rex
 
namespace rex::kernel {
 
class GuestAddressSpace;

struct X_LDR_DATA_TABLE_ENTRY {
  X_LIST_ENTRY in_load_order_links;
  X_LIST_ENTRY in_memory_order_links;
  X_LIST_ENTRY in_initialization_order_links;
 
  be_u32 dll_base; 
  be_u32 image_base;
  be_u32 image_size;
 
  X_UNICODE_STRING full_dll_name;
  X_UNICODE_STRING base_dll_name;
 
  be_u32 flags;
  be_u32 full_image_size; 
  be_u32 entry_point;
  be_u16 load_count; 
  be_u16 module_index;
  be_u32 dll_base_original;
  be_u32 checksum; 
  be_u32 load_flags;
  be_u32 time_date_stamp;
  be_u32 loaded_imports;
  be_u32 xex_header_base; 
  be_u32 closure_root;
  be_u32 traversal_parent;
};
REX_STATIC_ASSERT_SIZE(X_LDR_DATA_TABLE_ENTRY, 0x64);

enum class ModuleType : u8 { kKernel, kUser };
 
enum class ModuleFormat : u8 { kUndefined, kXEX, kELF };
 
struct KernelModuleState {
  struct ThunkKey {
    u32 caller_module_base;
    u16 ordinal;
    bool operator==(const ThunkKey&) const = default;
  };
 
  struct ThunkKeyHash {
    REX_KERNEL_API size_t operator()(const ThunkKey& key) const noexcept;
  };

  std::unordered_map<ThunkKey, u32, ThunkKeyHash> thunk_cache;

  rex::kernel::ExportVariableTable variables;
  std::unique_ptr<rex::platform::HighResolutionTimer> timestamp_timer;
};
 
struct UserModuleState {
  u32 guest_xex_header = 0;
 
  ModuleFormat module_format = ModuleFormat::kUndefined;

  bool is_dll_module = false;

  u32 entry_point = 0;
  u32 stack_size = 0; 

  std::string recompiled_key;

  std::vector<X_HANDLE> dependencies;

  std::unordered_map<KernelModuleState::ThunkKey, u32, KernelModuleState::ThunkKeyHash> thunk_cache;
};

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

  [[nodiscard]] virtual const std::string& GetPath() const = 0;

  virtual X_STATUS GetSection(std::string_view section_name, u32* out_section_data,
                              u32* out_section_size) const = 0;

  [[nodiscard]] virtual u32 GetTitleID() const = 0;

  [[nodiscard]] virtual std::vector<u32> GetAlternateTitleIDs() const = 0;

  virtual X_STATUS GetOptHeader(XEXHeaderKey key, void** out_ptr) = 0;

  template <typename T>
  X_STATUS OptHeader(XEXHeaderKey key, T* out_ptr) {
    return GetOptHeader(key, reinterpret_cast<void**>(out_ptr));
  }

  virtual X_STATUS GetOptHeaderGuestAddress(XEXHeaderKey key, u32* out_guest_address) const = 0;
};
 
struct ModuleObject : public ILoadedModule, public rex::NonCopyable {
  REX_KERNEL_API ModuleObject(TitleRuntime* runtime_in, ModuleType type_in);

  REX_KERNEL_API ~ModuleObject();
 
  ModuleType type;  
  std::string name; 
  std::string path; 
  PropagateConst<std::unique_ptr<rex::kernel::GuestModule>> processor_module;

  u32 hmodule_ptr = 0;
  TitleRuntime* runtime;    
  UserModuleState user;     
  KernelModuleState kernel; 

  REX_KERNEL_API bool IsNamed(std::string_view query) const;
 
  REX_KERNEL_API X_STATUS GetSection(std::string_view section_name, u32* out_section_data,
                                     u32* out_section_size) const override;

  REX_KERNEL_API u32 GetExportAddress(TitleRuntime& owning_runtime, u16 ordinal,
                                      u32 caller_address = 0);

  REX_KERNEL_API u32 GetExportAddress(std::string_view export_name) const;

  REX_KERNEL_API rex::kernel::XEXModule* GetXEX();
 
  REX_KERNEL_API const rex::kernel::XEXModule* GetXEX() const;
 
  REX_KERNEL_API u32 GetTitleID() const override;
 
  REX_KERNEL_API std::vector<u32> GetAlternateTitleIDs() const override;
 
  const std::string& GetPath() const override { return path; }

  REX_KERNEL_API X_STATUS LoadFromFile(TitleRuntime& owning_runtime, std::string_view guest_path);

  REX_KERNEL_API X_STATUS LoadFromMemory(TitleRuntime& owning_runtime, const void* addr,
                                         size_t length);

  REX_KERNEL_API X_STATUS Unload();
 
  REX_KERNEL_API X_STATUS GetOptHeader(XEXHeaderKey key, void** out_ptr) override;

  template <typename T>
  X_STATUS OptHeader(XEXHeaderKey key, T* out_ptr) {
    return GetOptHeader(key, reinterpret_cast<void**>(out_ptr));
  }
 
  REX_KERNEL_API X_STATUS GetOptHeaderGuestAddress(XEXHeaderKey key,
                                                   u32* out_guest_address) const override;

  REX_KERNEL_API void InvalidateThunkCache(u32 lo, u32 hi);

  void SetVariable(u16 ordinal, u32 address) { kernel.variables.SetAddress(ordinal, address); }

  u32 GetVariable(u16 ordinal) const { return kernel.variables.GetAddress(ordinal); }

  REX_KERNEL_API static u32 HandleFromHModule(void* hmodule);

  REX_KERNEL_API static X_HANDLE FromHModule(TitleRuntime& runtime, void* hmodule);

  REX_KERNEL_API static X_HANDLE CreateKernelModule(TitleRuntime& runtime, std::string_view path);

  REX_KERNEL_API static X_HANDLE CreateUserModule(TitleRuntime& runtime);

  REX_KERNEL_API static X_STATUS GetOptHeader(const kernel::GuestAddressSpace* memory,
                                              const XEXHeader* header, XEXHeaderKey key,
                                              u32* out_header_guest_ptr);
};

REX_KERNEL_API X_HANDLE CreateModule(TitleRuntime& runtime, ModuleType type);
 
}  // namespace rex::kernel