Gold translator: Use IRT open_resource instead of SRPC conn to nameservice.

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 15 matching lines @@
 #if !defined(__native_client__)
 #error "Cannot build nacl_file.cc without __native_client__"
 #endif
 
 #include <fcntl.h>
 #include <map>
 #include <string>
 #include <unistd.h>
 #include <vector>
 
-#include "native_client/src/public/imc_syscalls.h"
-#include "native_client/src/public/name_service.h"
+#include "native_client/src/untrusted/irt/irt.h"

[Mark Seaborn, 2014/12/01 19:26:43]

I believe this can be #included as <irt.h>, which would be preferable for code
that lives in a separate repo.

[jvoung (off chromium), 2014/12/01 20:35:19]

Done.

 #include "native_client/src/shared/srpc/nacl_srpc.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;
 
-// Register some filename -> fd mappings so that we do not
-// need to use the ManifestNameService  (aka directory) service.
-// Note, there seems to be the following convention:
-// the directory service knows about files like  "files/<filename>".
-// Locally, we refer to the files as <filename>.
-// For object files passed in via Srpc, we register the incoming .o
-// descriptor as FILENAME_OBJ WITHOUT the "files/" prefix.
+// 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;
   }
 }
 
-// Look up additional resource files through the nacl manifest service
-// which essentially maps a (file)name to a (file)descriptor
-NaClSrpcChannel g_nacl_manifest_channel;
+static struct nacl_irt_resource_open g_irt_resource_open;

[Mark Seaborn, 2014/12/01 19:26:43]

"static" not neeed -- this is inside an anon namespace.

Style nit: maybe put this next to the other g_* variable (to keep globals at the
top)

[jvoung (off chromium), 2014/12/01 20:35:19]

Done.

 
-// Make ManifestNameService service available for lookups.
-void ManifestLookupInit() {
-  int nameservice_address = -1;
-  int nameservice_fd = -1;
-  int manifest_address = -1;
-  int manifest_fd = -1;
-  int status;
-  NaClSrpcChannel nameservice_channel;
-
-  /* Attach to the reverse service for doing manifest file queries. */
-  nacl_nameservice(&nameservice_address);
-  if (nameservice_address == -1) {
-    gold_fatal(_("nacl_nameservice failed\n"));
-  }
-  nameservice_fd = imc_connect(nameservice_address);
-  close(nameservice_address);
-  if (nameservice_fd == -1) {
-    gold_fatal(_("name service connect failed\n"));
-  }
-  if (!NaClSrpcClientCtor(&nameservice_channel, nameservice_fd)) {
-    gold_fatal(_("name service channel ctor failed\n"));
-  }
-  if (NACL_SRPC_RESULT_OK !=
-      NaClSrpcInvokeBySignature(&nameservice_channel, NACL_NAME_SERVICE_LOOKUP,
-                                "ManifestNameService", O_RDWR,
-                                &status, &manifest_address)) {
-    gold_fatal(_("ManifestNameService SRPC failed, status %d\n"), status);
-  }
-  NaClSrpcDtor(&nameservice_channel);
-  if (manifest_address == -1) {
-    gold_fatal(_("manifest name service address is -1\n"));
-  }
-  manifest_fd = imc_connect(manifest_address);
-  close(manifest_address);
-  if (manifest_fd == -1) {
-    gold_fatal(_("manifest name service connect failed\n"));
-  }
-  if (!NaClSrpcClientCtor(&g_nacl_manifest_channel, manifest_fd)) {
-    gold_fatal(_("manifest channel ctor failed\n"));
+// Set up interfaces for IRT open_resource.
+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"));
   }
 }
 
-void ManifestLookupFini() {
-  NaClSrpcDtor(&g_nacl_manifest_channel);
-}
-
-const int kUnknownFd = -1;
-
-int LookupFileByName(const char* filename) {
-  int fd = kUnknownFd;
-  int status;
-  // Files looked up via the nameservice are assumed to have a "files/" prefix.
-  std::string prefix("files/");
-  std::string full_filename = prefix + std::string(filename);
-  NaClSrpcError error =
-      NaClSrpcInvokeBySignature(&g_nacl_manifest_channel,
-                                NACL_NAME_SERVICE_LOOKUP,
-                                full_filename.c_str(),
-                                O_RDONLY,
-                                &status,
-                                &fd);
-  if (error != NACL_SRPC_RESULT_OK) {
-    gold_fatal(_("Lookup (%s) failed.\n"), filename);
+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) {
   // 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);
 }
 
-
-// c.f.: pnacl/driver/pnacl-nativeld.py
+// 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",
   FILENAME_OUTPUT,
   0
 };
@@ skipping 75 matching lines @@
   }
   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);
 }
 
-} // End namespace gold.
+} // End anonymous namespace.
 
 namespace nacl_file
 {
 
-// This is the only exported API from this file
 int NaClOpenFileDescriptor(const char *filename) {
   std::string key(filename);
   std::map<std::string, int>::iterator it = g_preopened_files.find(key);
   int fd;
+  // First check if it is a pre-opened file.
   if (it != g_preopened_files.end()) {
     fd = it->second;
   } else {
-    // Otherwise, ask the nameservice.
-    fd = LookupFileByName(filename);
+    // Otherwise, open the file through the IRT.
+    fd = IrtOpenFile(filename);
   }
-  // in case the file was re-opened, say to do --start/end-group
+  // In case the file was re-opened, seek back to the beginning.
+  // This might be the case for the --start/end-group implementation.
   lseek(fd, 0, SEEK_SET);
   return fd;
 }
 
 void NaClReleaseFileDescriptor(int fd) {
   // 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()
-{
+int main() {
   if (!NaClSrpcModuleInit()) {
     gold_fatal(_("NaClSrpcModuleInit failed\n"));
   }
-  ManifestLookupInit();
+  GetIRTInterface();
 
   // Start the message loop to process SRPCs.
   // It usually never terminates unless killed.
   const struct NaClSrpcHandlerDesc srpc_methods[] = {
     { "RunWithSplit:ihhhhhhhhhhhhhhhhh:", SrpcRunWithSplit },
     { NULL, NULL },
   };
 
   if (!NaClSrpcAcceptClientConnection(srpc_methods)) {
     gold_fatal(_("NaClSrpcAcceptClientConnection failed\n"));
   }
 
-  ManifestLookupFini();
   NaClSrpcModuleFini();
   return 0;
 }