NaCl: Send fatal log messages via shared memory.

components/nacl/browser/nacl_process_host.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 "components/nacl/browser/nacl_process_host.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 318 matching lines @@
     // The process failed to launch for some reason.
     // Don't keep the renderer hanging.
     reply_msg_->set_reply_error();
     nacl_host_message_filter_->Send(reply_msg_);
   }
 #if defined(OS_WIN)
   if (process_launched_by_broker_) {
     NaClBrokerService::GetInstance()->OnLoaderDied();
   }
 #endif
+
+  if (base::SharedMemory::IsHandleValid(crash_info_shmem_plugin_handle_))
+    base::SharedMemory::CloseHandle(crash_info_shmem_plugin_handle_);

[Mark Seaborn, 2014/08/17 20:13:45]

Is this a handle in another process's handle namespace?  This looks unsafe on
Windows.

[teravest, 2014/08/18 16:16:26]

Good point. I've changed this to only share the shared memory before sending
messages to the plugin or the renderer. This means that the object hangs around
longer in the browser, but keeping an extra handle in that process doesn't seem
terrible.

+  if (base::SharedMemory::IsHandleValid(crash_info_shmem_renderer_handle_))
+    base::SharedMemory::CloseHandle(crash_info_shmem_renderer_handle_);
 }
 
 void NaClProcessHost::OnProcessCrashed(int exit_status) {
   if (enable_crash_throttling_ &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePnaclCrashThrottling)) {
     NaClBrowser::GetInstance()->OnProcessCrashed();
   }
 }
 
@@ skipping 118 matching lines @@
       SendErrorToRenderer("NaClSocketPair() failed");
       delete this;
       return;
     }
     internal_->socket_for_renderer = pair[0];
     internal_->socket_for_sel_ldr = pair[1];
     SetCloseOnExec(pair[0]);
     SetCloseOnExec(pair[1]);
   }
 
+  // Create a shared memory region that the renderer and plugin share for
+  // reporting crash information.
+  {
+    base::SharedMemory crash_info_shmem;
+    if (crash_info_shmem.CreateAnonymous(kNaClCrashInfoShmemSize)) {
+      crash_info_shmem.ShareToProcess(process_->GetData().handle,

[Mark Seaborn, 2014/08/17 20:13:45]

Should this check for an error?

[teravest, 2014/08/18 16:16:26]

I've added error checking at the ShareToProcess() calls.

+                                      &crash_info_shmem_plugin_handle_);
+      crash_info_shmem.ShareToProcess(nacl_host_message_filter_->PeerHandle(),
+                                      &crash_info_shmem_renderer_handle_);
+    }
+  }
+
   // Launch the process
   if (!LaunchSelLdr()) {
     delete this;
   }
 }
 
 void NaClProcessHost::OnChannelConnected(int32 peer_pid) {
   if (!CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kNaClGdb).empty()) {
     LaunchNaClGdb();
@@ skipping 248 matching lines @@
   imc_handle_for_renderer = imc_handle;
 #endif
 
   const ChildProcessData& data = process_->GetData();
   SendMessageToRenderer(
       NaClLaunchResult(imc_handle_for_renderer,
                        ppapi_channel_handle,
                        trusted_channel_handle,
                        manifest_service_channel_handle,
                        base::GetProcId(data.handle),
-                       data.id),
+                       data.id,
+                       crash_info_shmem_renderer_handle_),
       std::string() /* error_message */);
   internal_->socket_for_renderer = NACL_INVALID_HANDLE;
+  crash_info_shmem_renderer_handle_ = base::SharedMemory::NULLHandle();
   return true;
 }
 
 void NaClProcessHost::SendErrorToRenderer(const std::string& error_message) {
   LOG(ERROR) << "NaCl process launch failed: " << error_message;
   SendMessageToRenderer(NaClLaunchResult(), error_message);
 }
 
 void NaClProcessHost::SendMessageToRenderer(
     const NaClLaunchResult& result,
@@ skipping 135 matching lines @@
 #endif
   }
 
   if (!uses_nonsfi_mode_) {
     internal_->socket_for_sel_ldr = NACL_INVALID_HANDLE;
   }
 
   params.nexe_file = IPC::TakeFileHandleForProcess(nexe_file_.Pass(),
                                                    process_->GetData().handle);
 
+  params.crash_info_shmem_handle = crash_info_shmem_plugin_handle_;
+  crash_info_shmem_plugin_handle_ = base::SharedMemory::NULLHandle();
+
   process_->Send(new NaClProcessMsg_Start(params));
   return true;
 }
 
 // This method is called when NaClProcessHostMsg_PpapiChannelCreated is
 // received.
 void NaClProcessHost::OnPpapiChannelsCreated(
     const IPC::ChannelHandle& browser_channel_handle,
     const IPC::ChannelHandle& ppapi_renderer_channel_handle,
     const IPC::ChannelHandle& trusted_renderer_channel_handle,
@@ skipping 234 matching lines @@
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl