PNaCl sandboxed linker: Use new IRT interface instead of using SRPC directly

gold/nacl_file.cc

 // nacl_file.cc -- handle file lookups for NaCl version of gold  -*- C++ -*-
 
 // Copyright 2012 Free Software Foundation, Inc.
 // Written by the Native Client authors.
 
 // This file is part of gold.
 
 // This program is free software; you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation; either version 3 of the License, or
@@ skipping 16 matching lines @@
 #error "Cannot build nacl_file.cc without __native_client__"
 #endif
 
 #include <fcntl.h>
 #include <map>
 #include <string>
 #include <unistd.h>
 #include <vector>
 
 #include <irt.h>
-#include "native_client/src/shared/srpc/nacl_srpc.h"
+#include <irt_dev.h>
 
 #include "gold.h"
 
 using namespace gold;
 
 extern int gold_main(int argc, char** argv);
 
 #define FILENAME_OUTPUT   "a.out"
 #define FILENAME_OBJ      "__PNACL_GENERATED"
 
 const int kMaxArgc = 256;
-// This value cannot change without also changing the signature of the
-// RunWithSplit RPC
-const int kMaxObjectFiles = 16;
 
 namespace
 {
 std::map<std::string, int> g_preopened_files;
 struct nacl_irt_resource_open g_irt_resource_open;
+struct nacl_irt_private_pnacl_translator_link g_irt_translator_link;
 
 // Register some filename -> fd mappings that correspond to pre-opened fds.
 // Otherwise files are opened via the IRT open_resource() function.
 void RegisterPreopenedFd(const char* filename, int fd) {
   std::string key(filename);
   std::map<std::string, int>::iterator it = g_preopened_files.find(key);
 
   if (it != g_preopened_files.end()) {
     gold_fatal(_("nacl_file::set_preopened_fd already set %s to %d."),
                filename, it->second);
   } else {
     g_preopened_files[key] = fd;
   }
 }
 
 // Set up interfaces for IRT open_resource.

[jvoung (off chromium), 2015/02/05 19:11:25]

nit: Does a bit more than "for IRT open_resource" now. Could be a bit more
generic if you like, since the code pretty clearly shows which IRT interface
queries are done.

[Mark Seaborn, 2015/02/05 23:19:45]

Good point.  I'll remove the comment, since the function name is descriptive
enough on its own.  Also changed the function name to be plural.

 void GetIRTInterface() {
   size_t query_result = nacl_interface_query(
       NACL_IRT_RESOURCE_OPEN_v0_1,
       &g_irt_resource_open, sizeof(g_irt_resource_open));
   if (query_result != sizeof(g_irt_resource_open)) {
-    gold_fatal(_("nacl_file::GetIRTInterface failed"));
+    gold_fatal(_("Failed to get resource_open IRT interface"));
+  }
+
+  query_result = nacl_interface_query(
+      NACL_IRT_PRIVATE_PNACL_TRANSLATOR_LINK_v0_1,
+      &g_irt_translator_link, sizeof(g_irt_translator_link));
+  if (query_result != sizeof(g_irt_translator_link)) {
+    gold_fatal(_("Failed to get translator_link IRT interface"));
   }
 }
 
 int IrtOpenFile(const char* filename) {
   int fd = -1;
   if (int res = g_irt_resource_open.open_resource(filename, &fd)) {
     gold_fatal(_("IrtOpenFile (%s) failed: %d\n"), filename, res);
   }
   return fd;
 }
 
-void RunCommon(const std::vector<std::string>& arg_vec,
-               NaClSrpcRpc* rpc,
-               NaClSrpcClosure* done) {
+int RunCommon(const std::vector<std::string>& arg_vec) {
   // repackage the commandline to what main() expects
   const char* argv[kMaxArgc];
   if (arg_vec.size() >  kMaxArgc) {
     gold_fatal(_("commandline too long"));
   }
   for (size_t i = 0; i < arg_vec.size(); ++i) argv[i] = arg_vec[i].c_str();
 
   // call hijacked main()
-  int ret = gold_main(arg_vec.size(), const_cast<char**>(&argv[0]));
-  rpc->result = ret > 0 ? NACL_SRPC_RESULT_APP_ERROR : NACL_SRPC_RESULT_OK;
-  done->Run(done);
+  return gold_main(arg_vec.size(), const_cast<char**>(&argv[0]));
 }
 
 // c.f.: pnacl/driver/nativeld.py
 const char* kDefaultCommandCommon[] = {
   "gold",
   "--eh-frame-hdr",
   "-nostdlib",
   // ARM only but added to everything for convenience
   "--no-fix-cortex-a8",
   "-o",
@@ skipping 26 matching lines @@
     if (src[i] == std::string("@shim")) {
       result->push_back("--entry=__pnacl_start");
       result->push_back("libpnacl_irt_shim.a");
     } else {
       gold_fatal(_("unknown meta command line flag"));
     }
   }
 }
 
 
-// SRPC signature: :ihhhhhhhhhhhhhhhhh:
-// i:   number N of object files to use
-// h{16}: handles of objfiles. N of them are valid.
-// h:  handle of nexe file
-void
-SrpcRunWithSplit(NaClSrpcRpc* rpc,
-                 NaClSrpcArg** in_args,
-                 NaClSrpcArg** /* out_args */,
-                 NaClSrpcClosure* done) {
-  int object_count = in_args[0]->u.ival;
-  if (object_count > kMaxObjectFiles || object_count < 1) {
+int HandleLinkRequest(int nexe_fd,
+                      const int* obj_file_fds,
+                      int object_count) {
+  if (object_count < 1) {
     gold_fatal(_("Invalid object count"));
   }
   std::vector<char *> filenames(object_count);
   for (int i = 0; i < object_count; i++) {
     const int len = sizeof(FILENAME_OBJ) + 2;
     filenames[i] = new char[len];
     snprintf(filenames[i], len, "%s%d", FILENAME_OBJ, i);
-    RegisterPreopenedFd(filenames[i], in_args[i + 1]->u.hval);
+    RegisterPreopenedFd(filenames[i], obj_file_fds[i]);
   }
-  int nexe_fd = in_args[kMaxObjectFiles + 1]->u.hval;
   RegisterPreopenedFd(FILENAME_OUTPUT, nexe_fd);
 
   std::vector<std::string> result_arg_vec;
 
   ProcessCommandline(kDefaultCommandCommon, &result_arg_vec);
   // Construct the rest of the command line, replacing FILENAME_OBJ with a list
   // of input files from the descriptors.
   const int cmdline_len = ((sizeof(kDefaultCommandStatic) /
                             sizeof(kDefaultCommandStatic[0])) +
                            object_count - 1);
   const char *command_line[cmdline_len];
 
   int arg = 0;
   for (int i = 0; kDefaultCommandStatic[i] != 0; i++) {
     if (!strcmp(kDefaultCommandStatic[i], FILENAME_OBJ)) {
       for (int k = 0; k < object_count; k++) {
         command_line[arg++] = filenames[k];
       }
     } else {
       command_line[arg++] = kDefaultCommandStatic[i];
     }
   }
   command_line[arg] = 0;
 
   ProcessCommandline(command_line, &result_arg_vec);
   for (int i = 0; i < object_count; i++) {
     delete [] filenames[i];
   }
-  RunCommon(result_arg_vec, rpc, done);
+  return RunCommon(result_arg_vec);
 }
 
 } // End anonymous namespace.
 
 namespace nacl_file
 {
 
 int NaClOpenFileDescriptor(const char *filename) {
   std::string key(filename);
   std::map<std::string, int>::iterator it = g_preopened_files.find(key);
@@ skipping 15 matching lines @@
   // Note: we do not close the fd as it maybe opened again.
   // For now we are getting lucky:
   // gold is not closing any of the libraries. And it IS closing
   // the nexe for us in Output_file::close
 }
 
 } // End namespace nacl_file.
 
 
 int main() {
-  if (!NaClSrpcModuleInit()) {
-    gold_fatal(_("NaClSrpcModuleInit failed\n"));
-  }
   GetIRTInterface();
 
-  // Start the message loop to process SRPCs.
-  // It usually never terminates unless killed.
-  const struct NaClSrpcHandlerDesc srpc_methods[] = {
-    { "RunWithSplit:ihhhhhhhhhhhhhhhhh:", SrpcRunWithSplit },
-    { NULL, NULL },
-  };
+  g_irt_translator_link.serve_link_request(HandleLinkRequest);
 
-  if (!NaClSrpcAcceptClientConnection(srpc_methods)) {
-    gold_fatal(_("NaClSrpcAcceptClientConnection failed\n"));
-  }
-
-  NaClSrpcModuleFini();
   return 0;
 }