NaCl: Send fatal log messages via shared memory.

components/nacl/renderer/nexe_load_manager.cc

 // Copyright 2014 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 "components/nacl/renderer/nexe_load_manager.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 71 matching lines @@
 
 NexeLoadManager::NexeLoadManager(
     PP_Instance pp_instance)
     : pp_instance_(pp_instance),
       nacl_ready_state_(PP_NACL_READY_STATE_UNSENT),
       nexe_error_reported_(false),
       is_installed_(false),
       exit_status_(-1),
       nexe_size_(0),
       plugin_instance_(content::PepperPluginInstance::Get(pp_instance)),
+      crash_info_shmem_handle_(base::SharedMemory::NULLHandle()),
       weak_factory_(this) {
   SetLastError("");
   HistogramEnumerateOsArch(GetSandboxArch());
   if (plugin_instance_) {
     plugin_base_url_ =
         plugin_instance_->GetContainer()->element().document().url();
   }
 }
 
 NexeLoadManager::~NexeLoadManager() {
   if (!nexe_error_reported_) {
     base::TimeDelta uptime = base::Time::Now() - ready_time_;
     HistogramTimeLarge("NaCl.ModuleUptime.Normal", uptime.InMilliseconds());
   }
+  if (base::SharedMemory::IsHandleValid(crash_info_shmem_handle_))
+    base::SharedMemory::CloseHandle(crash_info_shmem_handle_);
 }
 
 void NexeLoadManager::NexeFileDidOpen(int32_t pp_error,
                                       const base::File& file,
                                       int32_t http_status,
                                       int64_t nexe_bytes_read,
                                       const std::string& url,
                                       base::TimeDelta time_since_open) {
   // Check that we are on the main renderer thread.
   DCHECK(content::RenderThread::Get());
@@ skipping 108 matching lines @@
   SetLastError(error_string);
 
   // Inform JavaScript that loading was aborted and is complete.
   DispatchProgressEvent(pp_instance_, ProgressEvent(PP_NACL_EVENT_ABORT));
   DispatchProgressEvent(pp_instance_, ProgressEvent(PP_NACL_EVENT_LOADEND));
 
   HistogramEnumerateLoadStatus(PP_NACL_ERROR_LOAD_ABORTED, is_installed_);
   LogToConsole(error_string);
 }
 
-void NexeLoadManager::NexeDidCrash(const char* crash_log) {
+void NexeLoadManager::NexeDidCrash() {
   VLOG(1) << "Plugin::NexeDidCrash: crash event!";
     // The NaCl module voluntarily exited.  However, this is still a
     // crash from the point of view of Pepper, since PPAPI plugins are
     // event handlers and should never exit.
   VLOG_IF(1, exit_status_ != -1)
       << "Plugin::NexeDidCrash: nexe exited with status " << exit_status_
       << " so this is a \"controlled crash\".";
   // If the crash occurs during load, we just want to report an error
   // that fits into our load progress event grammar.  If the crash
   // occurs after loaded/loadend, then we use ReportDeadNexe to send a
   // "crash" event.
   if (nexe_error_reported_) {
     VLOG(1) << "Plugin::NexeDidCrash: error already reported; suppressing";
   } else {
     if (nacl_ready_state_ == PP_NACL_READY_STATE_DONE) {
       ReportDeadNexe();
     } else {
       ReportLoadError(PP_NACL_ERROR_START_PROXY_CRASH,
                       "Nexe crashed during startup");
     }
   }
   // In all cases, try to grab the crash log.  The first error
   // reported may have come from the start_module RPC reply indicating
   // a validation error or something similar, which wouldn't grab the
   // crash log.  In the event that this is called twice, the second
   // invocation will just be a no-op, since the entire crash log will
   // have been received and we'll just get an EOF indication.
-  CopyCrashLogToJsConsole(crash_log);
+
+  base::SharedMemory shmem(crash_info_shmem_handle_, true);
+  if (shmem.Map(kNaClCrashInfoShmemSize)) {
+    uint32_t crash_log_length;
+    crash_log_length = *(volatile uint32_t *) shmem.memory();

[Mark Seaborn, 2014/08/18 19:04:09]

Nit: this should probably be a C++-style cast

Also, can you comment the reason for the use of 'volatile'?

[teravest, 2014/08/19 19:58:16]

Done.

+    memcpy(&crash_log_length, shmem.memory(), sizeof(uint32_t));

[Mark Seaborn, 2014/08/18 19:04:09]

Redundant -- you forgot to remove this.

[teravest, 2014/08/19 19:58:16]

Removed.

+    crash_log_length = std::min<size_t>(crash_log_length,
+                                        kNaClCrashInfoMaxLogSize);
+
+    char crash_log_data[kNaClCrashInfoShmemSize];

[Mark Seaborn, 2014/08/18 19:04:09]

Let's not allocate this on the stack, since this is big(ish), especially given
that this doesn't have test coverage.

Can you use a heap-allocated scoped array, please?  (With
base/memory/scoped_vector.h perhaps.)

[teravest, 2014/08/19 19:58:16]

Changed to use scoped_ptr<char[]>

+    memcpy(crash_log_data,
+           (char*) shmem.memory() + sizeof(uint32_t),

[Mark Seaborn, 2014/08/18 19:04:09]

Nit: use C++ cast

[teravest, 2014/08/19 19:58:16]

Done.

+           crash_log_length);
+    std::string crash_log(crash_log_data, crash_log_length);
+    CopyCrashLogToJsConsole(crash_log);
+  }
 }
 
 void NexeLoadManager::set_trusted_plugin_channel(
     scoped_ptr<TrustedPluginChannel> channel) {
   trusted_plugin_channel_ = channel.Pass();
 }
 
 void NexeLoadManager::set_manifest_service_channel(
     scoped_ptr<ManifestServiceChannel> channel) {
   manifest_service_channel_ = channel.Pass();
@@ skipping 144 matching lines @@
   // to provide error handling.
 }
 
 void NexeLoadManager::CopyCrashLogToJsConsole(const std::string& crash_log) {
   base::StringTokenizer t(crash_log, "\n");
   while (t.GetNext())
     LogToConsole(t.token());
 }
 
 }  // namespace nacl