module.h

Go to the documentation of this file.

 
#pragma once
 
#include <span>
#include <string>
#include <string_view>
#include <vector>
#include <atomic>
#include <optional>
 
#include <rex/platform.h>
#include <rex/types.h>
#include <rex/kernel/heap.h>
#include <rex/kernel/symbol_map.h>
#include <memory>
 
#include <rex/kernel/types/xex.h>
#include <rex/memory/endian.h>
#include <rex/ppc/recompiled_code.h>
#include <rex/platform/lock_order.h>
#include <rex/result.h>
#include <rex/kernel/types/status.h>
#include <rex/module.h>
#include <rex/utility.h>
 
namespace rex::filesystem {
class IXEXImage;
struct PEInfo;
struct XEXImportLibrary;
}  // namespace rex::filesystem
 
namespace rex::kernel {
 
class FunctionDispatcher;
 
class REX_KERNEL_API GuestModule {
 public:
  explicit GuestModule(FunctionDispatcher* function_dispatcher);
  virtual ~GuestModule();
 
  kernel::GuestAddressSpace* GetAddressSpace() const { return memory_; }
  FunctionDispatcher* GetFunctionDispatcher() const { return function_dispatcher_; }
 
  virtual const std::string& GetName() const = 0;
  virtual bool IsExecutable() const = 0;

  virtual u32 GetBaseAddress() const { return 0; }
  virtual u32 GetImageSize() const { return 0; }
  virtual u32 GetEntryPoint() const { return 0; }
  virtual u32 GetExportTableAddress() const { return 0; }

  virtual u32 GetExceptionDirectoryRVA() const { return 0; }
  virtual u32 GetExceptionDirectorySize() const { return 0; }
  virtual u32 GetExceptionDirectoryAddress() const { return 0; }
 
  bool IsExecutableAddress(u32 address) const;

  virtual std::span<const BinarySection> GetBinarySections() const;
  virtual const BinarySection* FindSectionByAddress(u32 address) const;

  virtual std::span<const BinarySymbol> GetBinarySymbols() const;
 
 protected:
  FunctionDispatcher* function_dispatcher_ = nullptr;
  kernel::GuestAddressSpace* memory_ = nullptr;

  std::vector<BinarySection> binary_sections_;
  std::vector<BinarySymbol> binary_symbols_;
};
 
}  // namespace rex::kernel
 
namespace rex::kernel {

class REX_KERNEL_API ELFModule : public GuestModule {
 public:
  explicit ELFModule(FunctionDispatcher* function_dispatcher);
  virtual ~ELFModule();
 
  bool IsLoaded() const { return loaded_; }
  const std::string& GetName() const override { return name_; }
  bool IsExecutable() const override;
  const std::string& GetPath() const { return path_; }

  u32 GetBaseAddress() const override { return base_address_; }
  u32 GetImageSize() const override { return image_size_; }
  u32 GetEntryPoint() const override { return entry_point_; }

  bool Load(const std::string_view name, const std::string_view path, const void* elf_addr,
            size_t elf_length);
  bool Unload();
 
 private:
  std::string name_;
  std::string path_;
 
  bool loaded_ = false;
  std::vector<u8> elf_header_mem_;
  u32 entry_point_ = 0;
  u32 base_address_ = 0;
  u32 image_size_ = 0;
};
 
}  // namespace rex::kernel
 
namespace rex {
namespace kernel {
class TitleRuntime;
}  // namespace kernel
}  // namespace rex
 
namespace rex::kernel {
 
constexpr memory::FourCCT kXEX1Signature = memory::make_fourcc("XEX1");
constexpr memory::FourCCT kXEX2Signature = memory::make_fourcc("XEX2");
constexpr memory::FourCCT kELFSignature = memory::make_fourcc(0x7F, 'E', 'L', 'F');

class REX_KERNEL_API XEXModule : public GuestModule {
 public:
  struct LibraryImport {
   public:
    u32 ordinal = 0;
    u32 value_address = 0; 
    u32 thunk_address = 0; 
  };
  struct ImportLibrary {
   public:
    std::string name;      
    std::string file_name; 
    u32 id;
    XEXVersion version;                 
    XEXVersion min_version;             
    std::vector<LibraryImport> imports; 
  };

  XEXModule(FunctionDispatcher* function_dispatcher, TitleRuntime& runtime);
  ~XEXModule() override;
 
  bool IsLoaded() const { return loaded_; }
  const filesystem::IXEXImage& GetImage() const { return *image_; }
  const filesystem::PEInfo& GetPE() const { return *pe_; }

  u32 GetImageSize() const override;

  u32 GetBaseAddress() const override { return base_address_; }

  u32 GetEntryPoint() const override;

  u32 GetExportTableAddress() const override;
 
  u32 GetExceptionDirectoryRVA() const override;
  u32 GetExceptionDirectorySize() const override;
  u32 GetExceptionDirectoryAddress() const override;
 
  std::span<const BinarySection> GetBinarySections() const override;
  std::span<const BinarySymbol> GetBinarySymbols() const override;

  u32 GetExportAddress(u16 ordinal) const;
 
  const std::vector<ImportLibrary>& GetImportLibraries() const { return import_libs_; }
  u32 GetExportAddress(const std::string_view name) const;

  int ApplyPatch(XEXModule* module);
  bool Load(const std::string_view name, const std::string_view path, const void* xex_addr,
            size_t xex_length);
  std::span<const u8> GetPendingImage() const { return pending_image_; }
  bool LoadContinue();
  bool Unload();
 
  const std::string& GetName() const override { return name_; }
  bool IsExecutable() const override;
 
 private:
  bool SetupLibraryImports(std::string_view name, const filesystem::XEXImportLibrary& library);
  void PopulateBinaryData();
 
  TitleRuntime* runtime_ = nullptr;
  std::string name_;
  std::string path_;
  std::unique_ptr<filesystem::IXEXImage> image_;
  std::unique_ptr<filesystem::PEInfo> pe_;
  std::vector<u8> pending_image_;
  std::vector<ImportLibrary> import_libs_;
 
  bool loaded_ = false;
  bool finished_load_ = false;
 
  u32 base_address_ = 0;
};
 
}  // namespace rex::kernel
 
namespace rex::kernel {

struct ModuleImport {
  constexpr ModuleImport(const char* library_name, u16 export_ordinal)
      : library(library_name), ordinal(export_ordinal) {}
 
  const char* library; 
  u16 ordinal;
  std::atomic<PPCFunc*> function{nullptr};
  std::atomic<u64> generation{0}; 
};

REX_KERNEL_API PPCFunc* ResolveModuleImport(ModuleImport& target);
 
}  // namespace rex::kernel
 
namespace rex::kernel {

REX_DECLARE_INTERFACE(IModuleRegistry, 1)
  virtual ~IModuleRegistry() = default;

  [[nodiscard]] virtual std::optional<X_HANDLE> GetModule(std::string_view name,
                                                          bool user_only = false) = 0;

  [[nodiscard]] virtual std::optional<X_HANDLE> GetExecutable() const = 0;

  [[nodiscard]] virtual std::optional<X_HANDLE> FindKernelModule(std::string_view name) = 0;

  [[nodiscard]] virtual std::optional<X_HANDLE> FindUserModule(std::string_view name) = 0;

  [[nodiscard]] virtual bool IsKernelModule(std::string_view name) = 0;

  [[nodiscard]] virtual std::vector<X_HANDLE> GetKernelModules() = 0;

  [[nodiscard]] virtual std::vector<X_HANDLE> GetUserModules() = 0;

  [[nodiscard]] virtual Result<X_HANDLE> LoadUserModule(std::string_view name,
                                                        bool call_entry = true) = 0;

  virtual void UnloadUserModule(X_HANDLE module, bool call_entry = true) = 0;

  virtual void AddImportCandidate(std::string_view path) = 0;

  [[nodiscard]] virtual Result<X_HANDLE> RegisterKernelModule(X_HANDLE created) = 0;

  virtual void RegisterRecompiledModule(const char* pe_name, const char* guest_path,
                                        const char* shared_lib_name) = 0;

  [[nodiscard]] virtual rex::platform::RankedMutex& GetLoadCountMutex() = 0;
};
 
}  // namespace rex::kernel