Add a handler to DM to print out what was running when we crash.

dm/DM.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
 #include "DMSrcSinkAndroid.h"
 #include "OverwriteLine.h"
 #include "ProcStats.h"
 #include "SkBBHFactory.h"
 #include "SkChecksum.h"
 #include "SkCodec.h"
 #include "SkCommonFlags.h"
 #include "SkCommonFlagsConfig.h"
 #include "SkFontMgr.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkMD5.h"
 #include "SkMutex.h"
 #include "SkOSFile.h"
+#include "SkSpinlock.h"
 #include "SkTHash.h"
 #include "SkTaskGroup.h"
 #include "SkThreadUtils.h"
 #include "Test.h"
 #include "Timer.h"
 #include "sk_tool_utils.h"
 
 #ifdef SK_PDF_IMAGE_STATS
 extern void SkPDFImageDumpStats();
 #endif
@@ skipping 41 matching lines @@
 static SkTArray<SkString> gFailures;
 
 static void fail(ImplicitString err) {
     SkAutoMutexAcquire lock(gFailuresMutex);
     SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
     gFailures.push_back(err);
 }
 
 static int32_t gPending = 0;  // Atomic.  Total number of running and queued tasks.
 
-SK_DECLARE_STATIC_MUTEX(gRunningAndTallyMutex);
+// We use a spinlock to make locking this in a signal handler _somewhat_ safe.
+SK_DECLARE_STATIC_SPINLOCK(gRunningAndTallyMutex);
 static SkTArray<SkString>        gRunning;
 static SkTHashMap<SkString, int> gNoteTally;
 
 static void done(double ms,
                  ImplicitString config, ImplicitString src, ImplicitString srcOptions,
                  ImplicitString name, ImplicitString note, ImplicitString log) {
     SkString id = SkStringPrintf("%s %s %s %s", config.c_str(), src.c_str(),
                                                 srcOptions.c_str(), name.c_str());
     {
-        SkAutoMutexAcquire lock(gRunningAndTallyMutex);
+        SkAutoTAcquire<SkPODSpinlock> lock(gRunningAndTallyMutex);
         for (int i = 0; i < gRunning.count(); i++) {
             if (gRunning[i] == id) {
                 gRunning.removeShuffle(i);
                 break;
             }
         }
         if (!note.isEmpty()) {
             if (int* tally = gNoteTally.find(note)) {
                 *tally += 1;
             } else {
@@ skipping 18 matching lines @@
     // Notice this also handles the final dm.json when pending == 0.
     if (pending % 500 == 0) {
         JsonWriter::DumpJson();
     }
 }
 
 static void start(ImplicitString config, ImplicitString src,
                   ImplicitString srcOptions, ImplicitString name) {
     SkString id = SkStringPrintf("%s %s %s %s", config.c_str(), src.c_str(),
                                                 srcOptions.c_str(), name.c_str());
-    SkAutoMutexAcquire lock(gRunningAndTallyMutex);
+    SkAutoTAcquire<SkPODSpinlock> lock(gRunningAndTallyMutex);
     gRunning.push_back(id);
 }
 
+#if defined(SK_BUILD_FOR_WIN32)
+    static void setup_crash_handler() {
+        // TODO: custom crash handler like below to print out what was running
+        SetupCrashHandler();
+    }
+
+#else
+    #include <signal.h>
+    static void setup_crash_handler() {
+        const int kSignals[] = { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV };
+        for (int sig : kSignals) {
+            signal(sig, [](int sig) {
+                SkAutoTAcquire<SkPODSpinlock> lock(gRunningAndTallyMutex);
+                SkDebugf("\nCaught signal %d [%s] while running %d tasks:\n",
+                         sig, strsignal(sig), gRunning.count());
+                for (auto& task : gRunning) {
+                    SkDebugf("\t%s\n", task.c_str());
+                }
+            });
+        }
+    }
+#endif
+
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 struct Gold : public SkString {
     Gold() : SkString("") {}
     Gold(ImplicitString sink, ImplicitString src, ImplicitString srcOptions,
          ImplicitString name, ImplicitString md5)
         : SkString("") {
         this->append(sink);
         this->append(src);
         this->append(srcOptions);
@@ skipping 943 matching lines @@
         static void forever(void*) {
             for (;;) {
                 static const int kSec = 300;
             #if defined(SK_BUILD_FOR_WIN)
                 Sleep(kSec * 1000);
             #else
                 sleep(kSec);
             #endif
                 SkString running;
                 {
-                    SkAutoMutexAcquire lock(gRunningAndTallyMutex);
+                    SkAutoTAcquire<SkPODSpinlock> lock(gRunningAndTallyMutex);
                     for (int i = 0; i < gRunning.count(); i++) {
                         running.appendf("\n\t%s", gRunning[i].c_str());
                     }
                 }
                 SkDebugf("\nCurrently running:%s\n", running.c_str());
             }
         }
     };
     static SkThread* intentionallyLeaked = new SkThread(Loop::forever);
     intentionallyLeaked->start();
 }
 
 #define PORTABLE_FONT_PREFIX "Toy Liberation "
 
 static SkTypeface* create_from_name(const char familyName[], SkTypeface::Style style) {
     if (familyName && strlen(familyName) > sizeof(PORTABLE_FONT_PREFIX)
             && !strncmp(familyName, PORTABLE_FONT_PREFIX, sizeof(PORTABLE_FONT_PREFIX) - 1)) {
         return sk_tool_utils::create_portable_typeface(familyName, style);
     }
     return nullptr;
 }
 
 #undef PORTABLE_FONT_PREFIX
 
 extern SkTypeface* (*gCreateTypefaceDelegate)(const char [], SkTypeface::Style );
 
 int dm_main();
 int dm_main() {
-    SetupCrashHandler();
+    setup_crash_handler();
     JsonWriter::DumpJson();  // It's handy for the bots to assume this is ~never missing.
     SkAutoGraphics ag;
     SkTaskGroup::Enabler enabled(FLAGS_threads);
     gCreateTypefaceDelegate = &create_from_name;
 
     start_keepalive();
 
     gather_gold();
     gather_uninteresting_hashes();
 
@@ skipping 149 matching lines @@
                                                            Reporter* reporter,
                                                            GrContextFactory* factory);
 } // namespace skiatest
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif