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 <signal.h>
 #include <sys/resource.h>
 
@@ skipping 71 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.
+#define NOINLINE __attribute__((noinline))
+
+NOINLINE void ShutdownFDReadError() {
+  sleep(UINT_MAX);

[willchan no longer on Chromium, 2011/05/04 21:06:49]

I think you need <limits.h> for this constant and <unistd.h> for sleep (or you
could use PlatformThread::Sleep(), which might make this easier to port to
Windows if we ever do that).

Note that the noinline attribute is probably gcc only and this will probably
cause the clang bot to break. You should probably add this to
compiler_specific.h.

Also, I'm not completely sure this works, please note
http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html says: 
=====
noinline
This function attribute prevents a function from being considered for inlining.
If the function does not have side-effects, there are optimizations other than
inlining that causes function calls to be optimized away, although the function
call is live. To keep such calls from being optimized away, put
          asm ("");
     
(see Extended Asm) in the called function, to serve as a special side-effect.
=====

I think sleep() counts as a side effect, so it probably works as is, but I
thought I'd point that out.

[DaveMoore, 2011/05/09 17:41:42]

Done. I kept the sleep() call, added the asm("") and included the necessary
files.

+}
+
+NOINLINE void ShutdownFDClosedError() {
+  sleep(UINT_MAX);
+}
+
+NOINLINE void CloseAllBrowsersAndExitPosted() {
+  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)
 }