core

.vscode/settings.json

@@ -19,7 +19,6 @@
   "cmake.sourceDirectory": "${workspaceFolder}",
   "cmake.buildDirectory": "${workspaceFolder}/_build/_Release",
   "cmake.configureArgs": [
-    // "-DBUILD_CORE=1",
     "-DISDEBUG=1"
   ],
   "cmake.configureSettings": {

CMakeLists.txt

@@ -9,7 +9,7 @@ set(CMAKE_CXX_VISIBILITY_PRESET hidden)
 set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
 
 set(PSOFF_LIB_VERSION v.0.3)
-set(PSOFF_RENDER_VERSION v.0.5)
+set(PSOFF_RENDER_VERSION v.0.6-nightly_03.06.2024)
 
 set(ProjectName psOff_${CMAKE_BUILD_TYPE})
 project(${ProjectName} VERSION 0.0.1)
@@ -89,11 +89,11 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   )
 endif()
 
-# set(TEST_BENCH OFF CACHE BOOL "Enable testing")
+set(TEST_BENCH OFF CACHE BOOL "Enable testing")
 
-# if(TEST_BENCH)
-# add_subdirectory(tests)
-# endif()
+if(TEST_BENCH)
+ add_subdirectory(tests)
+endif()
 
 # include before link_libraries
 add_subdirectory(tools/logging)
@@ -113,12 +113,7 @@ add_compile_definitions(IMAGE_BASE=${IMAGE_BASE})
 add_subdirectory(modules)
 add_subdirectory(utility)
 add_subdirectory(tools/gamereport)
-
-if(BUILD_CORE)
-  add_subdirectory(core)
-else()
-  add_custom_target(core)
-endif()
+add_subdirectory(core)
 
 # #- Projects
 

core/CMakeLists.txt

@@ -0,0 +1,85 @@
+# Place before add_subdir -> define for all childs
+add_compile_definitions(
+  BOOST_ALL_NO_LIB
+)
+
+set(DST_INCLUDE_DIR "${CMAKE_BINARY_DIR}/core/export/include/core/")
+
+# Add directories
+add_subdirectory(kernel)
+add_subdirectory(videoout)
+add_subdirectory(initParams)
+add_subdirectory(timer)
+add_subdirectory(systemContent)
+add_subdirectory(networking)
+add_subdirectory(hotkeys)
+add_subdirectory(trophies)
+add_subdirectory(fileManager)
+add_subdirectory(memory)
+add_subdirectory(dmem)
+add_subdirectory(unwinding)
+add_subdirectory(runtime)
+
+# Build
+add_library(core SHARED
+  $<TARGET_OBJECTS:kernel>
+  $<TARGET_OBJECTS:initParams>
+  $<TARGET_OBJECTS:timer>
+  $<TARGET_OBJECTS:systemContent>
+  $<TARGET_OBJECTS:networking>
+  $<TARGET_OBJECTS:hotkeys>
+  $<TARGET_OBJECTS:trophies>
+  $<TARGET_OBJECTS:videoout>
+  $<TARGET_OBJECTS:fileManager>
+  $<TARGET_OBJECTS:memory>
+  $<TARGET_OBJECTS:dmem>
+  $<TARGET_OBJECTS:unwinding>
+  $<TARGET_OBJECTS:runtime>
+)
+
+add_dependencies(core logging third_party config_emu psoff_render)
+target_link_libraries(core PRIVATE
+  libboost_url
+  libboost_thread
+  libboost_chrono
+  libboost_program_options
+  libboost_filesystem
+  sdl2
+  psoff_render.lib
+  OptickCore
+  psOff_utility
+  config_emu.lib
+  onecore.lib
+  IPHLPAPI.lib
+  Dbghelp.lib
+  wepoll.lib
+  Ws2_32.lib
+  libcrypto.lib
+  libssl.lib
+  pugixml.lib
+  ntdll.dll
+  imgui
+  VulkanMemoryAllocator
+  ${Vulkan_LIBRARIES}
+)
+
+install(FILES $<TARGET_PDB_FILE:core> DESTINATION debug OPTIONAL)
+install(TARGETS core LIBRARY DESTINATION .)
+
+# Manage symbols
+if(NOT ISDEBUG)
+  add_custom_command(
+    TARGET core POST_BUILD
+    COMMAND $<$<CONFIG:release>:${CMAKE_STRIP}>
+    ARGS --strip-all $<TARGET_FILE:core>
+  )
+endif()
+
+set_target_properties(core
+  PROPERTIES
+  LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/core/export/lib"
+  ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/core/export/bin"
+  PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/"
+)
+
+file(COPY imports/exports/pm4_custom.h DESTINATION ${DST_INCLUDE_DIR}/imports/exports)

core/dmem/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_library(dmem OBJECT
+  memoryManager.cpp
+
+  types/directmem.cpp
+  types/flexiblemem.cpp
+)
+
+add_dependencies(dmem third_party psOff_utility)
+
+target_include_directories(dmem PRIVATE
+  ${Vulkan_INCLUDE_DIRS}
+)
+
+file(COPY memoryManager.h imemory.h DESTINATION ${DST_INCLUDE_DIR}/dmem)

core/dmem/imemory.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "utility/utility.h"
+
+struct SceKernelVirtualQueryInfo;
+struct SceKernelDirectMemoryQueryInfo;
+
+class IMemoryType {
+  CLASS_NO_COPY(IMemoryType);
+  CLASS_NO_MOVE(IMemoryType);
+
+  protected:
+  IMemoryType() {}
+
+  public:
+  virtual ~IMemoryType() = default;
+
+  /**
+   * @brief Only for init
+   *
+   */
+  virtual void setTotalSize(uint64_t totalSize) = 0;
+
+  virtual int alloc(size_t len, size_t alignment, int memoryType, uint64_t* outAddr) = 0;
+  virtual int free(off_t start, size_t len)                                          = 0;
+
+  virtual int map(uint64_t vaddr, off_t directMemoryOffset, size_t len, int prot, int flags, size_t alignment, uint64_t* outAddr) = 0;
+  virtual int unmap(uint64_t vaddr, uint64_t size)                                                                                = 0;
+
+  virtual int reserve(uint64_t start, size_t len, size_t alignment, int flags, uint64_t* outAddr) = 0;
+
+  virtual uint64_t size() const = 0;
+
+  virtual int getAvailableSize(uint32_t start, uint32_t end, size_t alignment, uint32_t* startOut, size_t* sizeOut) const = 0;
+
+  virtual int32_t virtualQuery(uint64_t addr, SceKernelVirtualQueryInfo* info) const       = 0;
+  virtual int32_t directQuery(uint64_t offset, SceKernelDirectMemoryQueryInfo* info) const = 0;
+
+  virtual void deinit() = 0;
+};

core/dmem/memoryManager.cpp

@@ -0,0 +1,124 @@
+#define __APICALL_EXTERN
+#include "memoryManager.h"
+#undef __APICALL_EXTERN
+
+#include "logging.h"
+#include "modules/libkernel/dmem.h"
+#include "types/memory.h"
+
+#include <boost/thread.hpp>
+#include <map>
+
+LOG_DEFINE_MODULE(MemoryManager);
+
+namespace {
+struct MappingData {
+  MappingType type;
+  uint64_t    size;
+};
+} // namespace
+
+class MemoryManager: public IMemoryManager {
+
+  std::unique_ptr<IMemoryType> m_directMemory;
+  std::unique_ptr<IMemoryType> m_flexibleMemory;
+
+  mutable boost::mutex m_mutexInt;
+
+  std::map<uint64_t, MappingData> m_mappings;
+
+  std::map<uint64_t, uint64_t> m_stackAddrMap;
+
+  public:
+  MemoryManager() {
+    m_directMemory   = createDirectMemory(this);
+    m_flexibleMemory = createFlexibleMemory(this);
+  }
+
+  ~MemoryManager() = default;
+
+  // ### Interface
+  void        registerMapping(uint64_t vaddr, uint64_t size, MappingType type) final;
+  MappingType unregisterMapping(uint64_t vaddr) final;
+
+  void registerStack(uint64_t addr, uint64_t size) final;
+  void unregisterStack(uint64_t addr) final;
+
+  int32_t virtualQuery(uint64_t addr, SceKernelVirtualQueryInfo* info) const final;
+
+  IMemoryType* directMemory() final { return m_directMemory.get(); }
+
+  IMemoryType* flexibleMemory() final { return m_flexibleMemory.get(); }
+};
+
+IMemoryManager* accessMemoryManager() {
+  static MemoryManager inst;
+  return &inst;
+}
+
+void MemoryManager::registerMapping(uint64_t vaddr, uint64_t size, MappingType type) {
+
+  boost::unique_lock lock(m_mutexInt);
+
+  m_mappings.emplace(std::make_pair(vaddr, MappingData {.type = type, .size = size}));
+}
+
+MappingType MemoryManager::unregisterMapping(uint64_t vaddr) {
+  boost::unique_lock lock(m_mutexInt);
+
+  if (auto it = m_mappings.find((uint64_t)vaddr); it != m_mappings.end()) {
+    auto type = it->second.type;
+    m_mappings.erase(it);
+    return type;
+  }
+
+  return MappingType::None;
+}
+
+void MemoryManager::registerStack(uint64_t addr, uint64_t size) {
+  boost::unique_lock lock(m_mutexInt);
+  m_stackAddrMap[addr] = size;
+}
+
+void MemoryManager::unregisterStack(uint64_t addr) {
+  boost::unique_lock lock(m_mutexInt);
+  m_stackAddrMap.erase(addr);
+}
+
+int32_t MemoryManager::virtualQuery(uint64_t addr, SceKernelVirtualQueryInfo* info) const {
+  LOG_USE_MODULE(MemoryManager);
+
+  boost::unique_lock lock(m_mutexInt);
+
+  auto itItem = m_mappings.lower_bound(addr);
+
+  if (itItem == m_mappings.end() && addr > (itItem->first + itItem->second.size)) return getErr(ErrCode::_EACCES); // End reached
+
+  if (itItem == m_mappings.end() || (itItem != m_mappings.begin() && itItem->first != addr)) --itItem; // Get the correct item
+
+  int res = getErr(ErrCode::_EACCES);
+
+  switch (itItem->second.type) {
+    case MappingType::Direct: {
+      res = m_directMemory->virtualQuery(itItem->first, info);
+    } break;
+    case MappingType::Flexible: {
+      res = m_flexibleMemory->virtualQuery(itItem->first, info);
+    } break;
+    case MappingType::Fixed: {
+    } break;
+    case MappingType::File: {
+    } break;
+
+    default: break;
+  }
+
+  if (res == Ok) {
+    LOG_TRACE(L"Query OK: addr:0x%08llx - start:0x%08llx end:0x%08llx prot:%d type:%d", itItem->first, info->start, info->end, info->protection,
+              info->memoryType);
+  } else {
+    LOG_TRACE(L"Query Error: addr:0x%08llx", addr);
+  }
+
+  return res;
+};

core/dmem/memoryManager.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "imemory.h"
+#include "utility/utility.h"
+
+#include <stdint.h>
+
+enum class MappingType { None, File, Flexible, Fixed, Direct };
+
+struct SceKernelVirtualQueryInfo;
+
+class IMemoryManager {
+  CLASS_NO_COPY(IMemoryManager);
+  CLASS_NO_MOVE(IMemoryManager);
+
+  public:
+  IMemoryManager() = default;
+
+  virtual ~IMemoryManager() = default;
+
+  /**
+   * @brief Register mapped memory
+   *
+   * @param vaddr
+   * @param type
+   */
+  virtual void registerMapping(uint64_t vaddr, uint64_t size, MappingType type) = 0;
+
+  /**
+   * @brief Unregisters mapping and returns the type of the mapping
+   *
+   * @param vaddr
+   * @return None: Mapping didn't exist
+   */
+  virtual MappingType unregisterMapping(uint64_t vaddr) = 0;
+
+  virtual void registerStack(uint64_t addr, uint64_t size) = 0;
+  virtual void unregisterStack(uint64_t addr)              = 0;
+
+  virtual int32_t virtualQuery(uint64_t addr, SceKernelVirtualQueryInfo* info) const = 0;
+
+  virtual IMemoryType* directMemory()   = 0;
+  virtual IMemoryType* flexibleMemory() = 0;
+};
+
+#if defined(__APICALL_EXTERN)
+#define __APICALL __declspec(dllexport)
+#elif defined(__APICALL_IMPORT)
+#define __APICALL __declspec(dllimport)
+#else
+#define __APICALL
+#endif
+
+__APICALL IMemoryManager* accessMemoryManager();
+#undef __APICALL