Enable mmap and identity-based validation caching on pnacl-{llc,ld}.nexe

ppapi/native_client/src/trusted/plugin/plugin.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <string>
@@ skipping 23 matching lines @@
 
 namespace plugin {
 
 namespace {
 
 // Up to 20 seconds
 const int64_t kTimeSmallMin = 1;         // in ms
 const int64_t kTimeSmallMax = 20000;     // in ms
 const uint32_t kTimeSmallBuckets = 100;
 
-const PP_NaClFileInfo kInvalidNaClFileInfo = {
-  PP_kInvalidFileHandle,
-  0,  // token_lo
-  0,  // token_hi
-};
-
 }  // namespace
 
 void Plugin::ShutDownSubprocesses() {
   PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (this=%p)\n",
                  static_cast<void*>(this)));
   PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (%s)\n",
                  main_subprocess_.detailed_description().c_str()));
 
   // Shut down service runtime. This must be done before all other calls so
   // they don't block forever when waiting for the upcall thread to exit.
   main_subprocess_.Shutdown();
 
   PLUGIN_PRINTF(("Plugin::ShutDownSubprocess (this=%p, return)\n",
                  static_cast<void*>(this)));
 }
 
 void Plugin::HistogramTimeSmall(const std::string& name,
                                 int64_t ms) {
   if (ms < 0) return;
   uma_interface_.HistogramCustomTimes(name,
                                       ms,
                                       kTimeSmallMin, kTimeSmallMax,
                                       kTimeSmallBuckets);
 }
 
-bool Plugin::LoadHelperNaClModule(PP_FileHandle file_handle,
+bool Plugin::LoadHelperNaClModule(PP_NaClFileInfo file_info,
                                   NaClSubprocess* subprocess,
                                   const SelLdrStartParams& params) {
   CHECK(!pp::Module::Get()->core()->IsMainThread());
   ServiceRuntime* service_runtime =
       new ServiceRuntime(this,
                          pp_instance(),
                          false,  // No main_service_runtime.
                          false,  // No non-SFI mode (i.e. in SFI-mode).
                          pp::BlockUntilComplete(), pp::BlockUntilComplete());
   subprocess->set_service_runtime(service_runtime);
@@ skipping 15 matching lines @@
   if (!service_runtime->WaitForSelLdrStart()) {
     PLUGIN_PRINTF(("Plugin::LoadHelperNaClModule "
                    "WaitForSelLdrStart timed out!\n"));
     return false;
   }
   PLUGIN_PRINTF(("Plugin::LoadHelperNaClModule (service_runtime_started=%d)\n",
                  service_runtime_started));
   if (!service_runtime_started)
     return false;
 
-  PP_NaClFileInfo info;
-  info.handle = file_handle;
-  info.token_lo = 0;
-  info.token_hi = 0;
-
   // Now actually load the nexe, which can happen on a background thread.
   //
   // We can't use pp::BlockUntilComplete() inside an in-process plugin, so we
   // have to roll our own blocking logic, similar to WaitForSelLdrStart()
   // above, except without timeout logic.
   pp::Module::Get()->core()->CallOnMainThread(
       0,
       callback_factory_.NewCallback(
           &Plugin::LoadNexeAndStart,
           service_runtime,
-          info));
+          file_info));
   return service_runtime->WaitForNexeStart();
 }
 
 void Plugin::StartSelLdrOnMainThread(int32_t pp_error,
                                      ServiceRuntime* service_runtime,
                                      const SelLdrStartParams& params,
                                      pp::CompletionCallback callback) {
   if (pp_error != PP_OK) {
     PLUGIN_PRINTF(("Plugin::StartSelLdrOnMainThread: non-PP_OK arg "
                    "-- SHOULD NOT HAPPEN\n"));
@@ skipping 95 matching lines @@
 
   bool result = PP_ToBool(nacl_interface_->StartPpapiProxy(pp_instance()));
   if (result) {
     PLUGIN_PRINTF(("Plugin::LoadNaClModule (%s)\n",
                    main_subprocess_.detailed_description().c_str()));
   }
   return result;
 }
 
 NaClSubprocess* Plugin::LoadHelperNaClModule(const nacl::string& helper_url,
-                                             PP_FileHandle file_handle,
+                                             PP_NaClFileInfo file_info,
                                              ErrorInfo* error_info) {
   nacl::scoped_ptr<NaClSubprocess> nacl_subprocess(
       new NaClSubprocess("helper module", NULL, NULL));
   if (NULL == nacl_subprocess.get()) {
     error_info->SetReport(PP_NACL_ERROR_SEL_LDR_INIT,
                           "unable to allocate helper subprocess.");
     return NULL;
   }
 
   // Do not report UMA stats for translator-related nexes.
   // TODO(sehr): define new UMA stats for translator related nexe events.
   // NOTE: The PNaCl translator nexes are not built to use the IRT.  This is
   // done to save on address space and swap space.
   //
   // Currently, this works only in SFI-mode. So, LoadModule SRPC is still used.
-  // So, pass kInvalidNaClFileInfo here, and instead |file_handle| is passed
+  // So, pass kInvalidNaClFileInfo here, and instead |file_info| is passed
   // to LoadNaClModuleFromBackgroundThread() below.
-  // TODO(teravest, hidehiko): Pass file_handle to params, so that LaunchSelLdr
+  // TODO(teravest, hidehiko): Pass file_info to params, so that LaunchSelLdr
   // will look at the info.
   SelLdrStartParams params(helper_url,
                            kInvalidNaClFileInfo,
                            false /* uses_irt */,
                            false /* uses_ppapi */,
                            false /* enable_dyncode_syscalls */,
                            false /* enable_exception_handling */,
                            true /* enable_crash_throttling */);
 
   // Helper NaCl modules always use the PNaCl manifest, as there is no
   // corresponding NMF.
-  if (!LoadHelperNaClModule(file_handle, nacl_subprocess.get(), params)) {
+  if (!LoadHelperNaClModule(file_info,
+                            nacl_subprocess.get(),
+                            params)) {
     return NULL;
   }
   // We need not wait for the init_done callback.  We can block
   // here in StartSrpcServices, since helper NaCl modules
   // are spawned from a private thread.
   //
   // TODO(bsy): if helper module crashes, we should abort.
   // crash_cb is not used here, so we are relying on crashes
   // being detected in StartSrpcServices or later.
   //
@@ skipping 41 matching lines @@
   callback_factory_.Initialize(this);
   nacl_interface_ = GetNaClInterface();
   CHECK(nacl_interface_ != NULL);
 
   // Notify PPB_NaCl_Private that the instance is created before altering any
   // state that it tracks.
   nacl_interface_->InstanceCreated(pp_instance);
   // We call set_exit_status() here to ensure that the 'exitStatus' property is
   // set. This can only be called when nacl_interface_ is not NULL.
   set_exit_status(-1);
-  nexe_file_info_.handle = PP_kInvalidFileHandle;
-  nexe_file_info_.token_lo = 0;
-  nexe_file_info_.token_hi = 0;
+  nexe_file_info_ = kInvalidNaClFileInfo;
 }
 
 
 Plugin::~Plugin() {
   int64_t shutdown_start = NaClGetTimeOfDayMicroseconds();
 
   PLUGIN_PRINTF(("Plugin::~Plugin (this=%p)\n",
                  static_cast<void*>(this)));
   // Destroy the coordinator while the rest of the data is still there
   pnacl_coordinator_.reset(NULL);
@@ skipping 192 matching lines @@
 
 void Plugin::SetExitStatusOnMainThread(int32_t pp_error,
                                        int exit_status) {
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   nacl_interface_->SetExitStatus(pp_instance(), exit_status);
 }
 
 
 }  // namespace plugin