Revert "Core: Remove MemoryWatcher"

This reverts commit 0c02e77eee.

CMakeLists.txt

@@ -481,6 +481,8 @@ endif()
 if(UNIX)
   message(STATUS "Using named pipes as controller inputs")
   add_definitions(-DUSE_PIPES=1)
+  message(STATUS "Watching game memory for changes")
+  add_definitions(-DUSE_MEMORYWATCHER=1)
 endif()
 
 if(ENABLE_ANALYTICS)

Source/Core/Common/CommonPaths.h

@@ -63,6 +63,7 @@
 #define STYLES_DIR "Styles"
 #define ANAGLYPH_DIR "Anaglyph"
 #define PIPES_DIR "Pipes"
+#define MEMORYWATCHER_DIR "MemoryWatcher"
 #define WFSROOT_DIR "WFS"
 #define BACKUP_DIR "Backup"
 #define RESOURCEPACK_DIR "ResourcePacks"
@@ -95,6 +96,10 @@
 #define ARAM_DUMP "aram.raw"
 #define FAKEVMEM_DUMP "fakevmem.raw"
 
+// Files in the directory returned by GetUserPath(D_MEMORYWATCHER_IDX)
+#define MEMORYWATCHER_LOCATIONS "Locations.txt"
+#define MEMORYWATCHER_SOCKET "MemoryWatcher"
+
 // Sys files
 #define TOTALDB "totaldb.dsy"
 

Source/Core/Common/FileUtil.cpp

@@ -801,6 +801,12 @@ static void RebuildUserDirectories(unsigned int dir_index)
     s_user_paths[F_GCSRAM_IDX] = s_user_paths[D_GCUSER_IDX] + GC_SRAM;
     s_user_paths[F_WIISDCARD_IDX] = s_user_paths[D_WIIROOT_IDX] + DIR_SEP WII_SDCARD;
 
+    s_user_paths[D_MEMORYWATCHER_IDX] = s_user_paths[D_USER_IDX] + MEMORYWATCHER_DIR DIR_SEP;
+    s_user_paths[F_MEMORYWATCHERLOCATIONS_IDX] =
+        s_user_paths[D_MEMORYWATCHER_IDX] + MEMORYWATCHER_LOCATIONS;
+    s_user_paths[F_MEMORYWATCHERSOCKET_IDX] =
+        s_user_paths[D_MEMORYWATCHER_IDX] + MEMORYWATCHER_SOCKET;
+
     // The shader cache has moved to the cache directory, so remove the old one.
     // TODO: remove that someday.
     File::DeleteDirRecursively(s_user_paths[D_USER_IDX] + SHADERCACHE_LEGACY_DIR DIR_SEP);

Source/Core/Common/FileUtil.h

@@ -48,6 +48,7 @@ enum
   D_THEMES_IDX,
   D_STYLES_IDX,
   D_PIPES_IDX,
+  D_MEMORYWATCHER_IDX,
   D_WFSROOT_IDX,
   D_BACKUP_IDX,
   D_RESOURCEPACK_IDX,
@@ -64,6 +65,8 @@ enum
   F_ARAMDUMP_IDX,
   F_FAKEVMEMDUMP_IDX,
   F_GCSRAM_IDX,
+  F_MEMORYWATCHERLOCATIONS_IDX,
+  F_MEMORYWATCHERSOCKET_IDX,
   F_WIISDCARD_IDX,
   NUM_PATH_INDICES
 };

Source/Core/Core/CMakeLists.txt

@@ -382,3 +382,7 @@ endif()
 if(GDBSTUB)
   target_sources(core PRIVATE PowerPC/GDBStub.cpp)
 endif()
+
+if(UNIX)
+  target_sources(core PRIVATE MemoryWatcher.cpp)
+endif()

Source/Core/Core/Core.cpp

@@ -64,6 +64,10 @@
 #include "Core/PowerPC/GDBStub.h"
 #endif
 
+#ifdef USE_MEMORYWATCHER
+#include "Core/MemoryWatcher.h"
+#endif
+
 #include "InputCommon/ControllerInterface/ControllerInterface.h"
 #include "InputCommon/GCAdapter.h"
 
@@ -266,6 +270,10 @@ void Stop()  // - Hammertime!
   }
 
   ResetRumble();
+
+#ifdef USE_MEMORYWATCHER
+  MemoryWatcher::Shutdown();
+#endif
 }
 
 void DeclareAsCPUThread()
@@ -308,6 +316,10 @@ static void CpuThread(const std::optional<std::string>& savestate_path, bool del
   if (_CoreParameter.bFastmem)
     EMM::InstallExceptionHandler();  // Let's run under memory watch
 
+#ifdef USE_MEMORYWATCHER
+  MemoryWatcher::Init();
+#endif
+
   if (savestate_path)
   {
     ::State::LoadAs(*savestate_path);

Source/Core/Core/MemoryWatcher.cpp

@@ -0,0 +1,130 @@
+// Copyright 2015 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <unistd.h>
+
+#include "Common/FileUtil.h"
+#include "Core/CoreTiming.h"
+#include "Core/HW/Memmap.h"
+#include "Core/HW/SystemTimers.h"
+#include "Core/MemoryWatcher.h"
+
+static std::unique_ptr<MemoryWatcher> s_memory_watcher;
+static CoreTiming::EventType* s_event;
+static const int MW_RATE = 600;  // Steps per second
+
+static void MWCallback(u64 userdata, s64 cyclesLate)
+{
+  s_memory_watcher->Step();
+  CoreTiming::ScheduleEvent(SystemTimers::GetTicksPerSecond() / MW_RATE - cyclesLate, s_event);
+}
+
+void MemoryWatcher::Init()
+{
+  s_memory_watcher = std::make_unique<MemoryWatcher>();
+  s_event = CoreTiming::RegisterEvent("MemoryWatcher", MWCallback);
+  CoreTiming::ScheduleEvent(0, s_event);
+}
+
+void MemoryWatcher::Shutdown()
+{
+  CoreTiming::RemoveEvent(s_event);
+  s_memory_watcher.reset();
+}
+
+MemoryWatcher::MemoryWatcher()
+{
+  m_running = false;
+  if (!LoadAddresses(File::GetUserPath(F_MEMORYWATCHERLOCATIONS_IDX)))
+    return;
+  if (!OpenSocket(File::GetUserPath(F_MEMORYWATCHERSOCKET_IDX)))
+    return;
+  m_running = true;
+}
+
+MemoryWatcher::~MemoryWatcher()
+{
+  if (!m_running)
+    return;
+
+  m_running = false;
+  close(m_fd);
+}
+
+bool MemoryWatcher::LoadAddresses(const std::string& path)
+{
+  std::ifstream locations;
+  File::OpenFStream(locations, path, std::ios_base::in);
+  if (!locations)
+    return false;
+
+  std::string line;
+  while (std::getline(locations, line))
+    ParseLine(line);
+
+  return !m_values.empty();
+}
+
+void MemoryWatcher::ParseLine(const std::string& line)
+{
+  m_values[line] = 0;
+  m_addresses[line] = std::vector<u32>();
+
+  std::stringstream offsets(line);
+  offsets >> std::hex;
+  u32 offset;
+  while (offsets >> offset)
+    m_addresses[line].push_back(offset);
+}
+
+bool MemoryWatcher::OpenSocket(const std::string& path)
+{
+  memset(&m_addr, 0, sizeof(m_addr));
+  m_addr.sun_family = AF_UNIX;
+  strncpy(m_addr.sun_path, path.c_str(), sizeof(m_addr.sun_path) - 1);
+
+  m_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+  return m_fd >= 0;
+}
+
+u32 MemoryWatcher::ChasePointer(const std::string& line)
+{
+  u32 value = 0;
+  for (u32 offset : m_addresses[line])
+    value = Memory::Read_U32(value + offset);
+  return value;
+}
+
+std::string MemoryWatcher::ComposeMessage(const std::string& line, u32 value)
+{
+  std::stringstream message_stream;
+  message_stream << line << '\n' << std::hex << value;
+  return message_stream.str();
+}
+
+void MemoryWatcher::Step()
+{
+  if (!m_running)
+    return;
+
+  for (auto& entry : m_values)
+  {
+    std::string address = entry.first;
+    u32& current_value = entry.second;
+
+    u32 new_value = ChasePointer(address);
+    if (new_value != current_value)
+    {
+      // Update the value
+      current_value = new_value;
+      std::string message = ComposeMessage(address, new_value);
+      sendto(m_fd, message.c_str(), message.size() + 1, 0, reinterpret_cast<sockaddr*>(&m_addr),
+             sizeof(m_addr));
+    }
+  }
+}

Source/Core/Core/MemoryWatcher.h

@@ -0,0 +1,47 @@
+// Copyright 2015 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <map>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <vector>
+
+// MemoryWatcher reads a file containing in-game memory addresses and outputs
+// changes to those memory addresses to a unix domain socket as the game runs.
+//
+// The input file is a newline-separated list of hex memory addresses, without
+// the "0x". To follow pointers, separate addresses with a space. For example,
+// "ABCD EF" will watch the address at (*0xABCD) + 0xEF.
+// The output to the socket is two lines. The first is the address from the
+// input file, and the second is the new value in hex.
+class MemoryWatcher final
+{
+public:
+  MemoryWatcher();
+  ~MemoryWatcher();
+  void Step();
+
+  static void Init();
+  static void Shutdown();
+
+private:
+  bool LoadAddresses(const std::string& path);
+  bool OpenSocket(const std::string& path);
+
+  void ParseLine(const std::string& line);
+  u32 ChasePointer(const std::string& line);
+  std::string ComposeMessage(const std::string& line, u32 value);
+
+  bool m_running;
+
+  int m_fd;
+  sockaddr_un m_addr;
+
+  // Address as stored in the file -> list of offsets to follow
+  std::map<std::string, std::vector<u32>> m_addresses;
+  // Address as stored in the file -> current value
+  std::map<std::string, u32> m_values;
+};