FEXServer: Add protocol interface to request code cache population

Source/Common/FEXServerClient.cpp

@@ -405,6 +405,29 @@ int RequestPIDFD(int ServerSocket) {
   return RequestPIDFDPacket(ServerSocket, PacketType::TYPE_GET_PID_FD);
 }
 
+void PopulateCodeCache(int ServerSocket, int ProgramFD, bool HasMultiblock) {
+  fasio::error ec;
+  fasio::tcp_socket Socket {ServerSocket};
+
+  // Send request
+  FEXServerRequestPacket Req {
+    .Header {.Type = HasMultiblock ? PacketType::TYPE_POPULATE_CODE_CACHE : PacketType::TYPE_POPULATE_CODE_CACHE_NO_MULTIBLOCK}};
+
+  fasio::mutable_buffer WriteBuffer {std::as_writable_bytes(std::span {&Req, 1})};
+  WriteBuffer.FD = &ProgramFD;
+  write(Socket, WriteBuffer, ec);
+  if (ec != fasio::error::success) {
+    return;
+  }
+
+  // Wait for success response to ensure FEXServer completed any pending cache generation.
+  // The cache loading code handles missing caches gracefully, so we don't
+  // actually care about the result here.
+  FEXServerResultPacket Res {};
+  fasio::mutable_buffer ResBuffer {std::as_writable_bytes(std::span {&Res, 1})};
+  read(Socket, ResBuffer, ec);
+}
+
 int RequestCodeMapFD(int ServerSocket, int ProgramFD, bool HasMultiblock) {
   fasio::tcp_socket Socket {ServerSocket};
   FEXServerRequestPacket Req {

Source/Common/FEXServerClient.h

@@ -19,6 +19,8 @@ enum class PacketType {
   TYPE_GET_LOG_FD,
   TYPE_GET_ROOTFS_PATH,
   TYPE_GET_PID_FD,
+  TYPE_POPULATE_CODE_CACHE,
+  TYPE_POPULATE_CODE_CACHE_NO_MULTIBLOCK,
   TYPE_QUERY_CODE_MAP,
   TYPE_QUERY_CODE_MAP_NO_MULTIBLOCK,
 
@@ -122,6 +124,16 @@ fextl::string RequestRootFSPath(int ServerSocket);
  */
 int RequestPIDFD(int ServerSocket);
 
+/**
+ * @brief Request FEXServer to populate the disk cache for the given executable
+ *        and any libraries referenced in its code map
+ *
+ * @param ServerSocket - Socket to the server
+ * @param ProgramFD - FD for program binary
+ * @param HasMultiblock - true if multiblock is enabled (used for selecting code maps)
+ */
+void PopulateCodeCache(int ServerSocket, int ProgramFD, bool HasMultiblock);
+
 /**
  * @brief Request FEXServer to create a new code map for disk cache population
  *

Source/Tools/FEXInterpreter/FEXInterpreter.cpp

@@ -520,6 +520,9 @@ int main(int argc, char** argv, char** const envp) {
     SyscallHandler->FM.TrackFEXFD(FEXServerLogging::FEXServerFD);
   }
 
+  // query ProgramFD now since MapMemory will close it
+  const int ProgramFD = dup(Loader.GetMainElfFD());
+
   {
     Loader.SetVDSOBase(VDSOMapping.VDSOBase);
     Loader.CalculateHWCaps(CTX.get());
@@ -558,6 +561,12 @@ int main(int argc, char** argv, char** const envp) {
 
   SyscallHandler->DeserializeSeccompFD(ParentThread, FEXSeccompFD);
 
+  // Request code cache generation
+  if (FEXCore::Config::Get_ENABLECODECACHINGWIP()) {
+    FEXServerClient::PopulateCodeCache(FEXServerClient::GetServerFD(), ProgramFD, FEXCore::Config::Get_MULTIBLOCK());
+  }
+  close(ProgramFD);
+
   CTX->ExecuteThread(ParentThread->Thread);
 
   DebugServer.reset();

Source/Tools/FEXServer/ProcessPipe.cpp

@@ -385,6 +385,36 @@ void HandleSocketData(fasio::tcp_socket& Socket) {
       break;
     }
 
+    case FEXServerClient::PacketType::TYPE_POPULATE_CODE_CACHE:
+    case FEXServerClient::PacketType::TYPE_POPULATE_CODE_CACHE_NO_MULTIBLOCK: {
+      char Tmp[PATH_MAX];
+      int TmpLen = FEX::get_fdpath(inFD, Tmp);
+      assert(TmpLen != -1);
+
+      std::filesystem::path Path {std::string_view(Tmp, TmpLen)};
+      auto filename_hash = XXH3_64bits(Tmp, TmpLen);
+      const bool HasMultiblock = (Req->Header.Type == FEXServerClient::PacketType::TYPE_POPULATE_CODE_CACHE);
+
+      FEXCore::ExecutableFileInfo MainFileId = {nullptr, filename_hash, fextl::string(Tmp, TmpLen)};
+      fmt::print("Requested {}cache generation for {}\n", HasMultiblock ? "" : "nomb-", MainFileId.Filename);
+
+      // TODO: Implement
+
+      FEXServerClient::FEXServerResultPacket Res {
+        .Header {
+          .Type = FEXServerClient::PacketType::TYPE_SUCCESS,
+        },
+      };
+
+      fasio::mutable_buffer Data = {.Data = std::as_writable_bytes(std::span(&Res, 1))};
+      fasio::error ec;
+      write(Socket, Data, ec);
+      buffer += sizeof(FEXServerClient::FEXServerRequestPacket::Header);
+      close(inFD);
+      inFD = -1;
+      break;
+    }
+
     case FEXServerClient::PacketType::TYPE_QUERY_CODE_MAP:
     case FEXServerClient::PacketType::TYPE_QUERY_CODE_MAP_NO_MULTIBLOCK: {
       char Tmp[PATH_MAX];