Heuristically avoid reporting crashes during DLL loading....

chrome_frame/crash_reporting/vectored_handler-impl.h

 // Copyright (c) 2009 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.
 
 #ifndef CHROME_FRAME_CRASH_REPORTING_VECTORED_HANDLER_IMPL_H_
 #define CHROME_FRAME_CRASH_REPORTING_VECTORED_HANDLER_IMPL_H_
 #include "chrome_frame/crash_reporting/vectored_handler.h"
+#include "chrome_frame/crash_reporting/nt_loader.h"
 
 #if defined(_M_IX86)
 #ifndef EXCEPTION_CHAIN_END
 #define EXCEPTION_CHAIN_END ((struct _EXCEPTION_REGISTRATION_RECORD*)-1)
 typedef struct _EXCEPTION_REGISTRATION_RECORD {
   struct _EXCEPTION_REGISTRATION_RECORD* Next;
   PVOID Handler;
 } EXCEPTION_REGISTRATION_RECORD;
 #endif  // EXCEPTION_CHAIN_END
 #else
@@ skipping 73 matching lines @@
   if (IS_DISPATCHING(exceptionFlags)) {
     if (ModuleHasInstalledSEHFilter())
       return ExceptionContinueSearch;
 
     if (api_->IsOurModule(exceptionInfo->ExceptionRecord->ExceptionAddress)) {
       api_->WriteDump(exceptionInfo);
       return ExceptionContinueSearch;
     }
 
     // See whether our module is somewhere in the call stack.
-    void* back_trace[api_->max_back_trace] = {0};
+    void* back_trace[E::max_back_trace] = {0};
     DWORD captured = api_->RtlCaptureStackBackTrace(0, api_->max_back_trace,
                                                     &back_trace[0], NULL);
     for (DWORD i = 0; i < captured; ++i) {
       if (api_->IsOurModule(back_trace[i])) {
         api_->WriteDump(exceptionInfo);
         return ExceptionContinueSearch;
       }
     }
   }
 
@@ skipping 20 matching lines @@
 
 // Here comes the default Windows 32-bit implementation.
 namespace {
   __declspec(naked)
     static EXCEPTION_REGISTRATION_RECORD* InternalRtlpGetExceptionList() {
       __asm {
         mov eax, fs:0
         ret
       }
   }
+
   __declspec(naked)
   static char* GetStackTopLimit() {
     __asm {
       mov eax, fs:8
       ret
     }
   }
 }  // end of namespace
 
 // Class which methods simply forwards to Win32 API.
@@ skipping 17 matching lines @@
     const void* address = exceptionInfo->ExceptionRecord->ExceptionAddress;
     for (int i = 0; i < kIgnoreEntries; i++) {
       const CodeBlock& code_block = IgnoreExceptions[i];
       DCHECK(code_block.code) << "Win32VEHTraits::CodeBlocks not initialized!";
       if ((CodeOffset(code_block.code, code_block.begin_offset) <= address) &&
           (address < CodeOffset(code_block.code, code_block.end_offset))) {
         return true;
       }
     }
 
+    // We don't want to report exceptions that occur during DLL loading,
+    // as those are captured and ignored by the NT loader. If this thread
+    // is holding the loader's lock, there's a possiblity that the crash
+    // is occurring in a loading DLL, in which case we resolve the
+    // crash address to a module and check on the module's status.
+    const DWORD flags = GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
+        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS;
+    HMODULE crashing_module = NULL;
+    if (nt_loader::OwnsLoaderLock() && ::GetModuleHandleEx(
+            flags, reinterpret_cast<LPCWSTR>(address), &crashing_module)) {
+      nt_loader::LDR_DATA_TABLE_ENTRY* entry =
+          nt_loader::GetLoaderEntry(crashing_module);
+
+      // If:
+      //  1. we found the entry in question, and
+      //  2. the entry is a DLL (has the IMAGE_DLL flag set), and
+      //  3. the DLL has a non-null entrypoint, and
+      //  4. the loader has not tagged it with the process attached called flag
+      // we conclude that the crash is most likely during the loading of the
+      // module and bail on reporting the crash to avoid false positives
+      // during crashes that occur during module loads, such as e.g. when
+      // the hook manager attempts to load buggy window hook DLLs.
+      if (entry &&
+          (entry->Flags & LDRP_IMAGE_DLL) != 0 &&
+          (entry->EntryPoint != NULL) &&
+          (entry->Flags & LDRP_PROCESS_ATTACH_CALLED) == 0)
+        return true;
+    }
+
     return false;
   }
 
   static bool CheckForStackOverflow() {
     MEMORY_BASIC_INFORMATION mi;
     const DWORD kPageSize = 0x1000;
     void* stack_top = GetStackTopLimit() - kPageSize;
     ::VirtualQuery(stack_top, &mi, sizeof(mi));
     // The above call may result in moving the top of the stack.
     // Check once more.
@@ skipping 36 matching lines @@
 
 DECLSPEC_SELECTANY Win32VEHTraits::CodeBlock
 Win32VEHTraits::IgnoreExceptions[kIgnoreEntries] = {
   { "kernel32.dll", "IsBadReadPtr", 0, 100, NULL },
   { "kernel32.dll", "IsBadWritePtr", 0, 100, NULL },
   { "kernel32.dll", "IsBadStringPtrA", 0, 100, NULL },
   { "kernel32.dll", "IsBadStringPtrW", 0, 100, NULL },
 };
 
 #endif  // CHROME_FRAME_CRASH_REPORTING_VECTORED_HANDLER_IMPL_H_