Heuristically avoid reporting crashes during DLL loading....

chrome_frame/crash_reporting/nt_loader_unittest.cc

 // 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.
 #include "chrome_frame/crash_reporting/nt_loader.h"
 
 #include <tlhelp32.h>
 #include <winnt.h>
 #include <base/at_exit.h>
 #include <base/scoped_handle.h>
+#include <base/string_util.h>
 #include <base/sys_info.h>
 #include <base/thread.h>
 #include "chrome_frame/crash_reporting/crash_dll.h"
 #include "gtest/gtest.h"
 
 namespace {
 void AssertIsCriticalSection(CRITICAL_SECTION* critsec) {
   // Assert on some of the internals of the debug info if it has one.
   RTL_CRITICAL_SECTION_DEBUG* debug = critsec->DebugInfo;
   if (debug) {
@@ skipping 89 matching lines @@
   CRITICAL_SECTION* loader_lock = GetLoaderLock();
 
   EXPECT_FALSE(OwnsLoaderLock());
   EnterCriticalSection(loader_lock);
   EXPECT_TRUE(OwnsLoaderLock());
   LeaveCriticalSection(loader_lock);
   EXPECT_FALSE(OwnsLoaderLock());
 }
 
 TEST(NtLoader, GetLoaderEntry) {
-  ScopedEnterCriticalSection lock(GetLoaderLock());
-
   // Get all modules in the current process.
   ScopedHandle snap(::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,
                                                ::GetCurrentProcessId()));
   EXPECT_TRUE(snap.Get() != NULL);
 
   // Walk them, while checking we get an entry for each, and that it
   // contains sane information.
   MODULEENTRY32 module = { sizeof(module) };
   ASSERT_TRUE(::Module32First(snap.Get(), &module));
   do {
+    ScopedEnterCriticalSection lock(GetLoaderLock());
+
     nt_loader::LDR_DATA_TABLE_ENTRY* entry =
         nt_loader::GetLoaderEntry(module.hModule);
     ASSERT_TRUE(entry != NULL);
-    ASSERT_EQ(module.hModule, reinterpret_cast<HMODULE>(entry->DllBase));
-    ASSERT_STREQ(module.szModule,
+    EXPECT_EQ(module.hModule, reinterpret_cast<HMODULE>(entry->DllBase));
+    EXPECT_STREQ(module.szModule,
                  FromUnicodeString(entry->BaseDllName).c_str());
-    ASSERT_STREQ(module.szExePath,
+    EXPECT_STREQ(module.szExePath,
                  FromUnicodeString(entry->FullDllName).c_str());
+
+    ULONG flags = entry->Flags;
+
+    // All entries should have this flag set.
+    ASSERT_TRUE(flags & LDRP_ENTRY_PROCESSED);
+
+    if (0 == (flags & LDRP_IMAGE_DLL)) {

[robertshield, 2010/03/11 22:10:56]

nit: if you feel like it, and are bored, and are very bored then you could add a
test to see what happens when you LoadLibrary() an exe module into the running
process.

[Sigurður Ásgeirsson, 2010/03/11 22:13:52]

Adding a TODO.

+      // Dlls have the LDRP_IMAGE_DLL flag set, any module that doesn't
+      // have that flag has to be the main executable.
+      EXPECT_TRUE(module.hModule == ::GetModuleHandle(NULL));
+    } else {
+      // Since we're not currently loading any modules, all loaded
+      // modules should either have the LDRP_PROCESS_ATTACH_CALLED,
+      // or a NULL entrypoint.
+      if (entry->EntryPoint == NULL) {
+        EXPECT_FALSE(flags & LDRP_PROCESS_ATTACH_CALLED);
+      } else {
+        // Shimeng.dll is an exception to the above, it's loaded
+        // in a special way, see e.g. http://www.alex-ionescu.com/?p=41
+        // for details.
+        bool is_shimeng = LowerCaseEqualsASCII(
+            FromUnicodeString(entry->BaseDllName), "shimeng.dll");
+
+        EXPECT_TRUE(is_shimeng || (flags & LDRP_PROCESS_ATTACH_CALLED));
+      }
+    }
+
   } while(::Module32Next(snap.Get(), &module));
 }
 
 namespace {
 
 typedef void (*ExceptionFunction)(EXCEPTION_POINTERS* ex_ptrs);
 
 class NtLoaderTest: public testing::Test {
  public:
   NtLoaderTest() : veh_id_(NULL), exception_function_(NULL) {
@@ skipping 43 matching lines @@
   void* veh_id_;
   ExceptionFunction exception_function_;
 
   static NtLoaderTest* current_;
   static DWORD main_thread_;
 };
 
 NtLoaderTest* NtLoaderTest::current_ = NULL;
 DWORD NtLoaderTest::main_thread_ = ::GetCurrentThreadId();
 
-const wchar_t kCrashDllName[] = L"crash_dll.dll";
-
 }  // namespace
 
 static int exceptions_handled = 0;
 static void OnCrashDuringLoadLibrary(EXCEPTION_POINTERS* ex_ptrs) {
   ASSERT_EQ(STATUS_ACCESS_VIOLATION, ex_ptrs->ExceptionRecord->ExceptionCode);
   ASSERT_EQ(2, ex_ptrs->ExceptionRecord->NumberParameters);
   ASSERT_EQ(EXCEPTION_WRITE_FAULT,
             ex_ptrs->ExceptionRecord->ExceptionInformation[0]);
   ASSERT_EQ(kCrashAddress,
             ex_ptrs->ExceptionRecord->ExceptionInformation[1]);
@@ skipping 59 matching lines @@
 
   exceptions_handled = 0;
   set_exception_function(OnCrashDuringUnloadLibrary);
 
   // We should crash during unload.
   if (module != NULL)
     ::FreeLibrary(module);
 
   EXPECT_EQ(1, exceptions_handled);
 }