Support non-SFI mode in NaCl manifest file.

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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
@@ skipping 265 matching lines @@
   HistogramEnumerate(name, sample, 7, 6);
 }
 
 bool Plugin::LoadNaClModuleFromBackgroundThread(
     nacl::DescWrapper* wrapper,
     NaClSubprocess* subprocess,
     const Manifest* manifest,
     const SelLdrStartParams& params) {
   CHECK(!pp::Module::Get()->core()->IsMainThread());
   ServiceRuntime* service_runtime =
-      new ServiceRuntime(this, manifest, false,
+      new ServiceRuntime(this, manifest, false, uses_nonsfi_mode_,
                          pp::BlockUntilComplete(), pp::BlockUntilComplete());
   subprocess->set_service_runtime(service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleFromBackgroundThread "
                  "(service_runtime=%p)\n",
                  static_cast<void*>(service_runtime)));
 
   // Now start the SelLdr instance.  This must be created on the main thread.
   bool service_runtime_started;
   pp::CompletionCallback sel_ldr_callback =
       callback_factory_.NewCallback(&Plugin::SignalStartSelLdrDone,
@@ skipping 35 matching lines @@
 }
 
 void Plugin::SignalStartSelLdrDone(int32_t pp_error,
                                    bool* started,
                                    ServiceRuntime* service_runtime) {
   *started = (pp_error == PP_OK);
   service_runtime->SignalStartSelLdrDone();
 }
 
 void Plugin::LoadNaClModule(nacl::DescWrapper* wrapper,
+                            bool uses_nonsfi_mode,
                             bool enable_dyncode_syscalls,
                             bool enable_exception_handling,
                             bool enable_crash_throttling,
                             const pp::CompletionCallback& init_done_cb,
                             const pp::CompletionCallback& crash_cb) {
   nacl::scoped_ptr<nacl::DescWrapper> scoped_wrapper(wrapper);
   CHECK(pp::Module::Get()->core()->IsMainThread());
   // Before forking a new sel_ldr process, ensure that we do not leak
   // the ServiceRuntime object for an existing subprocess, and that any
   // associated listener threads do not go unjoined because if they
   // outlive the Plugin object, they will not be memory safe.
   ShutDownSubprocesses();
   SelLdrStartParams params(manifest_base_url(),
                            true /* uses_irt */,
                            true /* uses_ppapi */,
+                           uses_nonsfi_mode,
                            enable_dev_interfaces_,
                            enable_dyncode_syscalls,
                            enable_exception_handling,
                            enable_crash_throttling);
   ErrorInfo error_info;
   ServiceRuntime* service_runtime =
-      new ServiceRuntime(this, manifest_.get(), true, init_done_cb, crash_cb);
+      new ServiceRuntime(this, manifest_.get(), true, uses_nonsfi_mode,
+                         init_done_cb, crash_cb);
   main_subprocess_.set_service_runtime(service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (service_runtime=%p)\n",
                  static_cast<void*>(service_runtime)));
   if (NULL == service_runtime) {
     error_info.SetReport(
         PP_NACL_ERROR_SEL_LDR_INIT,
         "sel_ldr init failure " + main_subprocess_.description());
     ReportLoadError(error_info);
     return;
   }
@@ skipping 17 matching lines @@
   bool nexe_loaded = service_runtime->LoadNexeAndStart(wrapper, crash_cb);
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (nexe_loaded=%d)\n",
                  nexe_loaded));
   if (nexe_loaded) {
     PLUGIN_PRINTF(("Plugin::LoadNaClModule (%s)\n",
                    main_subprocess_.detailed_description().c_str()));
   }
 }
 
 bool Plugin::LoadNaClModuleContinuationIntern(ErrorInfo* error_info) {
-  if (!main_subprocess_.StartSrpcServices()) {
-    // The NaCl process probably crashed. On Linux, a crash causes this error,
-    // while on other platforms, the error is detected below, when we attempt to
-    // start the proxy. Report a module initialization error here, to make it
-    // less confusing for developers.
-    NaClLog(LOG_ERROR, "LoadNaClModuleContinuationIntern: "
-            "StartSrpcServices failed\n");
-    error_info->SetReport(PP_NACL_ERROR_START_PROXY_MODULE,
-                          "could not initialize module.");
-    return false;
+  if (!uses_nonsfi_mode_) {
+    if (!main_subprocess_.StartSrpcServices()) {
+      // The NaCl process probably crashed. On Linux, a crash causes this
+      // error, while on other platforms, the error is detected below, when we
+      // attempt to start the proxy. Report a module initialization error here,
+      // to make it less confusing for developers.
+      NaClLog(LOG_ERROR, "LoadNaClModuleContinuationIntern: "
+              "StartSrpcServices failed\n");
+      error_info->SetReport(PP_NACL_ERROR_START_PROXY_MODULE,
+                            "could not initialize module.");
+      return false;
+    }
   }
   PP_ExternalPluginResult ipc_result =
       nacl_interface_->StartPpapiProxy(pp_instance());
   if (ipc_result == PP_EXTERNAL_PLUGIN_OK) {
     // Log the amound of time that has passed between the trusted plugin being
     // initialized and the untrusted plugin being initialized.  This is
     // (roughly) the cost of using NaCl, in terms of startup time.
     HistogramStartupTimeMedium(
         "NaCl.Perf.StartupTime.NaClOverhead",
         static_cast<float>(NaClGetTimeOfDayMicroseconds() - init_time_)
@@ skipping 27 matching lines @@
 
   // 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.
   // TODO(jvoung): See if we still need the uses_ppapi variable, now that
   // LaunchSelLdr always happens on the main thread.
   SelLdrStartParams params(manifest_base_url(),
                            false /* uses_irt */,
                            false /* uses_ppapi */,
+                           false /* uses_nonsfi_mode */,
                            enable_dev_interfaces_,
                            false /* enable_dyncode_syscalls */,
                            false /* enable_exception_handling */,
                            true /* enable_crash_throttling */);
   if (!LoadNaClModuleFromBackgroundThread(wrapper, nacl_subprocess.get(),
                                           manifest, params)) {
     return NULL;
   }
   // We need not wait for the init_done callback.  We can block
   // here in StartSrpcServices, since helper NaCl modules
@@ skipping 111 matching lines @@
     }
   }
 
   PLUGIN_PRINTF(("Plugin::Init (status=%d)\n", status));
   return status;
 }
 
 Plugin::Plugin(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
       main_subprocess_("main subprocess", NULL, NULL),
+      uses_nonsfi_mode_(false),
       nexe_error_reported_(false),
       wrapper_factory_(NULL),
       enable_dev_interfaces_(false),
       is_installed_(false),
       init_time_(0),
       ready_time_(0),
       nexe_size_(0),
       time_of_last_progress_event_(0),
       exit_status_(-1),
       nacl_interface_(NULL),
@@ skipping 154 matching lines @@
                        LENGTH_IS_COMPUTABLE,
                        nexe_bytes_read,
                        nexe_bytes_read);
 
   load_start_ = NaClGetTimeOfDayMicroseconds();
   nacl::scoped_ptr<nacl::DescWrapper>
       wrapper(wrapper_factory()->MakeFileDesc(file_desc_ok_to_close, O_RDONLY));
   NaClLog(4, "NexeFileDidOpen: invoking LoadNaClModule\n");
   LoadNaClModule(
       wrapper.release(),
+      uses_nonsfi_mode_,
       true, /* enable_dyncode_syscalls */
       true, /* enable_exception_handling */
       false, /* enable_crash_throttling */
       callback_factory_.NewCallback(&Plugin::NexeFileDidOpenContinuation),
       callback_factory_.NewCallback(&Plugin::NexeDidCrash));
 }
 
 void Plugin::NexeFileDidOpenContinuation(int32_t pp_error) {
   ErrorInfo error_info;
   bool was_successful;
@@ skipping 97 matching lines @@
     // Error should have been reported by pnacl. Just return.
     PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate error in Pnacl\n"));
     return;
   }
 
   // Inform JavaScript that we successfully translated the bitcode to a nexe.
   nacl::scoped_ptr<nacl::DescWrapper>
       wrapper(pnacl_coordinator_.get()->ReleaseTranslatedFD());
   LoadNaClModule(
       wrapper.release(),
+      false, /* uses_nonsfi_mode */
       false, /* enable_dyncode_syscalls */
       false, /* enable_exception_handling */
       true, /* enable_crash_throttling */
       callback_factory_.NewCallback(&Plugin::BitcodeDidTranslateContinuation),
       callback_factory_.NewCallback(&Plugin::NexeDidCrash));
 }
 
 void Plugin::BitcodeDidTranslateContinuation(int32_t pp_error) {
   ErrorInfo error_info;
   bool was_successful = LoadNaClModuleContinuationIntern(&error_info);
@@ skipping 137 matching lines @@
     ReportLoadError(error_info);
     return;
   }
 
   ProcessNaClManifest(json_buffer);
 }
 
 void Plugin::ProcessNaClManifest(const nacl::string& manifest_json) {
   HistogramSizeKB("NaCl.Perf.Size.Manifest",
                   static_cast<int32_t>(manifest_json.length() / 1024));
-  nacl::string program_url;
-  PnaclOptions pnacl_options;
   ErrorInfo error_info;
   if (!SetManifestObject(manifest_json, &error_info)) {
     ReportLoadError(error_info);
     return;
   }
 
-  if (manifest_->GetProgramURL(&program_url, &pnacl_options, &error_info)) {
+  nacl::string program_url;
+  PnaclOptions pnacl_options;
+  bool uses_nonsfi_mode;
+  if (manifest_->GetProgramURL(
+          &program_url, &pnacl_options, &uses_nonsfi_mode, &error_info)) {
     is_installed_ = GetUrlScheme(program_url) == SCHEME_CHROME_EXTENSION;
+    uses_nonsfi_mode_ = uses_nonsfi_mode;
     set_nacl_ready_state(LOADING);
     // Inform JavaScript that we found a nexe URL to load.
     EnqueueProgressEvent(PP_NACL_EVENT_PROGRESS);
     if (pnacl_options.translate()) {
       pp::CompletionCallback translate_callback =
           callback_factory_.NewCallback(&Plugin::BitcodeDidTranslate);
       // Will always call the callback on success or failure.
       pnacl_coordinator_.reset(
           PnaclCoordinator::BitcodeToNative(this,
                                             program_url,
@@ skipping 73 matching lines @@
 
 bool Plugin::SetManifestObject(const nacl::string& manifest_json,
                                ErrorInfo* error_info) {
   PLUGIN_PRINTF(("Plugin::SetManifestObject(): manifest_json='%s'.\n",
        manifest_json.c_str()));
   if (error_info == NULL)
     return false;
   // Determine whether lookups should use portable (i.e., pnacl versions)
   // rather than platform-specific files.
   bool is_pnacl = (mime_type() == kPnaclMIMEType);
+  bool nonsfi_mode_enabled =
+      PP_ToBool(nacl_interface_->IsNonSFIModeEnabled());
   bool pnacl_debug = GetNaClInterface()->NaClDebugStubEnabled();
   nacl::scoped_ptr<JsonManifest> json_manifest(
       new JsonManifest(url_util_,
                        manifest_base_url(),
                        (is_pnacl ? kPortableISA : GetSandboxISA()),
+                       nonsfi_mode_enabled,
                        pnacl_debug));
   if (!json_manifest->Init(manifest_json, error_info)) {
     return false;
   }
   manifest_.reset(json_manifest.release());
   return true;
 }
 
 void Plugin::UrlDidOpenForStreamAsFile(int32_t pp_error,
                                        FileDownloader*& url_downloader,
@@ skipping 324 matching lines @@
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   exit_status_ = exit_status;
   nacl_interface_->SetReadOnlyProperty(pp_instance(),
                                        pp::Var("exitStatus").pp_var(),
                                        pp::Var(exit_status_).pp_var());
 }
 
 
 }  // namespace plugin