Add shutdown trace functions

chrome/browser/browser_main_posix.cc

 // Copyright (c) 2011 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 "chrome/browser/browser_main_posix.h"
 
 #include <errno.h>
+#include <limits.h>
 #include <signal.h>
 #include <sys/resource.h>
+#include <unistd.h>
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
-#include "base/threading/platform_thread.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/browser/browser_thread.h"
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include "chrome/browser/printing/print_dialog_gtk.h"
 #endif
 
 namespace {
@@ skipping 54 matching lines @@
   const int shutdown_fd_;
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownDetector);
 };
 
 ShutdownDetector::ShutdownDetector(int shutdown_fd)
     : shutdown_fd_(shutdown_fd) {
   CHECK_NE(shutdown_fd_, -1);
 }
 
+
+// These functions are used to help us diagnose crash dumps that happen
+// during the shutdown process.
+NOINLINE void ShutdownFDReadError() {
+  // Ensure function isn't optimized away.
+  asm("");
+  sleep(UINT_MAX);
+}
+
+NOINLINE void ShutdownFDClosedError() {
+  // Ensure function isn't optimized away.
+  asm("");
+  sleep(UINT_MAX);
+}
+
+NOINLINE void CloseAllBrowsersAndExitPosted() {
+  // Ensure function isn't optimized away.
+  asm("");
+  sleep(UINT_MAX);
+}
+
 void ShutdownDetector::ThreadMain() {
   base::PlatformThread::SetName("CrShutdownDetector");
 
   int signal;
   size_t bytes_read = 0;
   ssize_t ret;
   do {
     ret = HANDLE_EINTR(
         read(shutdown_fd_,
              reinterpret_cast<char*>(&signal) + bytes_read,
              sizeof(signal) - bytes_read));
     if (ret < 0) {
       NOTREACHED() << "Unexpected error: " << strerror(errno);
+      ShutdownFDReadError();
       break;
     } else if (ret == 0) {
       NOTREACHED() << "Unexpected closure of shutdown pipe.";
+      ShutdownFDClosedError();
       break;
     }
     bytes_read += ret;
   } while (bytes_read < sizeof(signal));
 
   VLOG(1) << "Handling shutdown for signal " << signal << ".";
 
   if (!BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableFunction(BrowserList::CloseAllBrowsersAndExit))) {
     // Without a UI thread to post the exit task to, there aren't many
     // options.  Raise the signal again.  The default handler will pick it up
     // and cause an ungraceful exit.
     RAW_LOG(WARNING, "No UI thread, exiting ungracefully.");
     kill(getpid(), signal);
 
     // The signal may be handled on another thread.  Give that a chance to
     // happen.
     sleep(3);
 
     // We really should be dead by now.  For whatever reason, we're not. Exit
     // immediately, with the exit status set to the signal number with bit 8
     // set.  On the systems that we care about, this exit status is what is
     // normally used to indicate an exit by this signal's default handler.
     // This mechanism isn't a de jure standard, but even in the worst case, it
     // should at least result in an immediate exit.
     RAW_LOG(WARNING, "Still here, exiting really ungracefully.");
     _exit(signal | (1 << 7));
   }
+  CloseAllBrowsersAndExitPosted();
 }
 
 // Sets the file descriptor soft limit to |max_descriptors| or the OS hard
 // limit, whichever is lower.
 void SetFileDescriptorLimit(unsigned int max_descriptors) {
   struct rlimit limits;
   if (getrlimit(RLIMIT_NOFILE, &limits) == 0) {
     unsigned int new_limit = max_descriptors;
     if (limits.rlim_max > 0 && limits.rlim_max < max_descriptors) {
       new_limit = limits.rlim_max;
@@ skipping 81 matching lines @@
             new ShutdownDetector(g_shutdown_pipe_read_fd))) {
       LOG(DFATAL) << "Failed to create shutdown detector task.";
     }
   }
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   printing::PrintingContextCairo::SetCreatePrintDialogFunction(
       &PrintDialogGtk::CreatePrintDialog);
 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
 }