NaCl: Send fatal log messages via shared memory.

components/nacl/loader/nacl_listener.cc

 // Copyright 2013 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/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
+#include <string.h>
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
@@ skipping 19 matching lines @@
 #endif
 
 #if defined(OS_WIN)
 #include <fcntl.h>
 #include <io.h>
 
 #include "content/public/common/sandbox_init.h"
 #endif
 
 namespace {
+
+NaClListener* g_listener;
+
+void FatalLogHandler(const char* data, size_t bytes) {
+  // We use uint32_t rather than size_t for the case when the browser and NaCl
+  // processes are a mix of 32-bit and 64-bit processes.
+  uint32_t copy_bytes = std::min<uint32_t>(static_cast<uint32_t>(bytes),
+                                           nacl::kNaClCrashInfoMaxLogSize);
+
+  // We copy the length of the crash data to the start of the shared memory
+  // segment so we know how much to copy.
+  memcpy(g_listener->crash_info_shmem_memory(), &copy_bytes, sizeof(uint32_t));
+
+  memcpy((char*)g_listener->crash_info_shmem_memory() + sizeof(uint32_t),
+         data,
+         copy_bytes);
+}
+
 #if defined(OS_MACOSX)
 
 // On Mac OS X, shm_open() works in the sandbox but does not give us
 // an FD that we can map as PROT_EXEC.  Rather than doing an IPC to
 // get an executable SHM region when CreateMemoryObject() is called,
 // we preallocate one on startup, since NaCl's sel_ldr only needs one
 // of them.  This saves a round trip.
 
 base::subtle::Atomic32 g_shm_fd = -1;
 
@@ skipping 19 matching lines @@
   return -1;
 }
 
 #elif defined(OS_LINUX)
 
 int CreateMemoryObject(size_t size, int executable) {
   return content::MakeSharedMemorySegmentViaIPC(size, executable);
 }
 
 #elif defined(OS_WIN)
-
-NaClListener* g_listener;
-
 // We wrap the function to convert the bool return value to an int.
 int BrokerDuplicateHandle(NaClHandle source_handle,
                           uint32_t process_id,
                           NaClHandle* target_handle,
                           uint32_t desired_access,
                           uint32_t options) {
   return content::BrokerDuplicateHandle(source_handle, process_id,
                                         target_handle, desired_access,
                                         options);
 }
@@ skipping 105 matching lines @@
                                io_thread_("NaCl_IOThread"),
 #if defined(OS_LINUX)
                                prereserved_sandbox_size_(0),
 #endif
 #if defined(OS_POSIX)
                                number_of_cores_(-1),  // unknown/error
 #endif
                                main_loop_(NULL) {
   io_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
-#if defined(OS_WIN)
   DCHECK(g_listener == NULL);
   g_listener = this;
-#endif
 }
 
 NaClListener::~NaClListener() {
   NOTREACHED();
   shutdown_event_.Signal();
-#if defined(OS_WIN)
   g_listener = NULL;
-#endif
 }
 
 bool NaClListener::Send(IPC::Message* msg) {
   DCHECK(main_loop_ != NULL);
   if (base::MessageLoop::current() == main_loop_) {
     // This thread owns the channel.
     return channel_->Send(msg);
   } else {
     // This thread does not own the channel.
     return filter_->Send(msg);
@@ skipping 24 matching lines @@
 
 void NaClListener::OnStart(const nacl::NaClStartParams& params) {
 #if defined(OS_LINUX) || defined(OS_MACOSX)
   int urandom_fd = dup(base::GetUrandomFD());
   if (urandom_fd < 0) {
     LOG(ERROR) << "Failed to dup() the urandom FD";
     return;
   }
   NaClChromeMainSetUrandomFd(urandom_fd);
 #endif
-
   struct NaClApp* nap = NULL;
   NaClChromeMainInit();
+
+  crash_info_shmem_.reset(new base::SharedMemory(params.crash_info_shmem_handle,
+                                                 false));
+  CHECK(crash_info_shmem_->Map(nacl::kNaClCrashInfoShmemSize));
+  NaClSetFatalErrorCallback(&FatalLogHandler);
+
   nap = NaClAppCreate();
   if (nap == NULL) {
     LOG(ERROR) << "NaClAppCreate() failed";
     return;
   }
 
   IPC::ChannelHandle browser_handle;
   IPC::ChannelHandle ppapi_renderer_handle;
 
   if (params.enable_ipc_proxy) {
@@ skipping 110 matching lines @@
   nexe_file_info.desc = nexe_file;
 #else
 #error Unsupported target platform.
 #endif
   nexe_file_info.file_token.lo = params.nexe_token_lo;
   nexe_file_info.file_token.hi = params.nexe_token_hi;
   args->nexe_desc = NaClDescIoFromFileInfo(nexe_file_info, NACL_ABI_O_RDONLY);
 
   NaClChromeMainStartApp(nap, args);
 }