Home | History | Annotate | Download | only in crash_reporting 
      1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome_frame/crash_reporting/nt_loader.h"
      6 
      7 #include <tlhelp32.h>
      8 #include <winnt.h>
      9 
     10 #include "base/at_exit.h"
     11 #include "base/bind.h"
     12 #include "base/bind_helpers.h"
     13 #include "base/environment.h"
     14 #include "base/memory/scoped_ptr.h"
     15 #include "base/message_loop/message_loop.h"
     16 #include "base/strings/string_util.h"
     17 #include "base/strings/utf_string_conversions.h"
     18 #include "base/sys_info.h"
     19 #include "base/threading/thread.h"
     20 #include "base/win/scoped_handle.h"
     21 #include "chrome_frame/crash_reporting/crash_dll.h"
     22 #include "gtest/gtest.h"
     23 
     24 namespace {
     25 void AssertIsCriticalSection(CRITICAL_SECTION* critsec) {
     26   // Assert on some of the internals of the debug info if it has one.
     27   RTL_CRITICAL_SECTION_DEBUG* debug = critsec->DebugInfo;
     28   if (debug) {
     29     ASSERT_EQ(RTL_CRITSECT_TYPE, debug->Type);
     30     ASSERT_EQ(critsec, debug->CriticalSection);
     31   }
     32 
     33   // TODO(siggi): assert on the semaphore handle & object type?
     34 }
     35 
     36 class ScopedEnterCriticalSection {
     37  public:
     38   explicit ScopedEnterCriticalSection(CRITICAL_SECTION* critsec)
     39       : critsec_(critsec) {
     40     ::EnterCriticalSection(critsec_);
     41   }
     42 
     43   ~ScopedEnterCriticalSection() {
     44     ::LeaveCriticalSection(critsec_);
     45   }
     46 
     47  private:
     48   CRITICAL_SECTION* critsec_;
     49 };
     50 
     51 std::wstring FromUnicodeString(const UNICODE_STRING& str) {
     52   return std::wstring(str.Buffer, str.Length / sizeof(str.Buffer[0]));
     53 }
     54 
     55 }  // namespace
     56 
     57 using namespace nt_loader;
     58 
     59 TEST(NtLoader, OwnsCriticalSection) {
     60   // Use of Thread requires an atexit manager.
     61   base::AtExitManager at_exit;
     62 
     63   CRITICAL_SECTION cs = {};
     64   ::InitializeCriticalSection(&cs);
     65   EXPECT_FALSE(OwnsCriticalSection(&cs));
     66 
     67   // Enter the critsec and assert we own it.
     68   {
     69     ScopedEnterCriticalSection lock1(&cs);
     70 
     71     EXPECT_TRUE(OwnsCriticalSection(&cs));
     72 
     73     // Re-enter the critsec and assert we own it.
     74     ScopedEnterCriticalSection lock2(&cs);
     75 
     76     EXPECT_TRUE(OwnsCriticalSection(&cs));
     77   }
     78 
     79   // Should no longer own it.
     80   EXPECT_FALSE(OwnsCriticalSection(&cs));
     81 
     82   // Make another thread grab it.
     83   base::Thread other("Other threads");
     84   ASSERT_TRUE(other.Start());
     85   other.message_loop()->PostTask(
     86       FROM_HERE, base::Bind(::EnterCriticalSection, &cs));
     87 
     88   base::win::ScopedHandle event(::CreateEvent(NULL, FALSE, FALSE, NULL));
     89   other.message_loop()->PostTask(
     90       FROM_HERE, base::Bind(base::IgnoreResult(::SetEvent), event.Get()));
     91 
     92   ASSERT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(event.Get(), INFINITE));
     93 
     94   // We still shouldn't own it - the other thread does.
     95   EXPECT_FALSE(OwnsCriticalSection(&cs));
     96   // And we shouldn't be able to enter it.
     97   EXPECT_EQ(0, ::TryEnterCriticalSection(&cs));
     98 
     99   // Make the other thread release it.
    100   other.message_loop()->PostTask(
    101       FROM_HERE, base::Bind(::LeaveCriticalSection, &cs));
    102 
    103   other.Stop();
    104 
    105   ::DeleteCriticalSection(&cs);
    106 }
    107 
    108 TEST(NtLoader, GetLoaderLock) {
    109   CRITICAL_SECTION* loader_lock = GetLoaderLock();
    110 
    111   AssertIsCriticalSection(loader_lock);
    112 
    113   // We should be able to enter and leave the loader's lock without trouble.
    114   EnterCriticalSection(loader_lock);
    115   LeaveCriticalSection(loader_lock);
    116 }
    117 
    118 TEST(NtLoader, OwnsLoaderLock) {
    119   CRITICAL_SECTION* loader_lock = GetLoaderLock();
    120 
    121   EXPECT_FALSE(OwnsLoaderLock());
    122   EnterCriticalSection(loader_lock);
    123   EXPECT_TRUE(OwnsLoaderLock());
    124   LeaveCriticalSection(loader_lock);
    125   EXPECT_FALSE(OwnsLoaderLock());
    126 }
    127 
    128 TEST(NtLoader, GetLoaderEntry) {
    129   // Get all modules in the current process.
    130   base::win::ScopedHandle snap(
    131       ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, ::GetCurrentProcessId()));
    132   EXPECT_TRUE(snap.Get() != NULL);
    133 
    134   // Walk them, while checking we get an entry for each, and that it
    135   // contains sane information.
    136   MODULEENTRY32 module = { sizeof(module) };
    137   ASSERT_TRUE(::Module32First(snap.Get(), &module));
    138   do {
    139     ScopedEnterCriticalSection lock(GetLoaderLock());
    140 
    141     nt_loader::LDR_DATA_TABLE_ENTRY* entry =
    142         nt_loader::GetLoaderEntry(module.hModule);
    143     ASSERT_TRUE(entry != NULL);
    144     EXPECT_EQ(module.hModule, reinterpret_cast<HMODULE>(entry->DllBase));
    145     EXPECT_STREQ(module.szModule,
    146                  FromUnicodeString(entry->BaseDllName).c_str());
    147     EXPECT_STREQ(module.szExePath,
    148                  FromUnicodeString(entry->FullDllName).c_str());
    149 
    150     ULONG flags = entry->Flags;
    151 
    152     // All entries should have this flag set.
    153     EXPECT_TRUE(flags & LDRP_ENTRY_PROCESSED);
    154 
    155     if (0 == (flags & LDRP_IMAGE_DLL)) {
    156       // TODO(siggi): write a test to assert this holds true for loading
    157       //    non-DLL, e.g. exe image files.
    158       // Dlls have the LDRP_IMAGE_DLL flag set, any module that doesn't
    159       // have that flag has to be the main executable.
    160       EXPECT_TRUE(module.hModule == ::GetModuleHandle(NULL));
    161     } else {
    162       // Since we're not currently loading any modules, all loaded
    163       // modules should either have the LDRP_PROCESS_ATTACH_CALLED,
    164       // or a NULL entrypoint.
    165       if (entry->EntryPoint == NULL) {
    166         EXPECT_FALSE(flags & LDRP_PROCESS_ATTACH_CALLED);
    167       } else {
    168         // Shimeng.dll is an exception to the above, it's loaded
    169         // in a special way, see e.g. http://www.alex-ionescu.com/?p=41
    170         // for details.
    171         bool is_shimeng = LowerCaseEqualsASCII(
    172             FromUnicodeString(entry->BaseDllName), "shimeng.dll");
    173 
    174         EXPECT_TRUE(is_shimeng || (flags & LDRP_PROCESS_ATTACH_CALLED));
    175       }
    176     }
    177   } while (::Module32Next(snap.Get(), &module));
    178 }
    179 
    180 namespace {
    181 
    182 typedef void (*ExceptionFunction)(EXCEPTION_POINTERS* ex_ptrs);
    183 
    184 class NtLoaderTest: public testing::Test {
    185  public:
    186   NtLoaderTest() : veh_id_(NULL), exception_function_(NULL) {
    187     EXPECT_EQ(NULL, current_);
    188     current_ = this;
    189   }
    190 
    191   ~NtLoaderTest() {
    192     EXPECT_TRUE(this == current_);
    193     current_ = NULL;
    194   }
    195 
    196   void SetUp() {
    197     veh_id_ = ::AddVectoredExceptionHandler(FALSE, &ExceptionHandler);
    198     EXPECT_TRUE(veh_id_ != NULL);
    199 
    200     // Clear the crash DLL environment.
    201     scoped_ptr<base::Environment> env(base::Environment::Create());
    202     env->UnSetVar(WideToASCII(kCrashOnLoadMode).c_str());
    203     env->UnSetVar(WideToASCII(kCrashOnUnloadMode).c_str());
    204   }
    205 
    206   void TearDown() {
    207     if (veh_id_ != NULL)
    208       EXPECT_NE(0, ::RemoveVectoredExceptionHandler(veh_id_));
    209 
    210     // Clear the crash DLL environment.
    211     scoped_ptr<base::Environment> env(base::Environment::Create());
    212     env->UnSetVar(WideToASCII(kCrashOnLoadMode).c_str());
    213     env->UnSetVar(WideToASCII(kCrashOnUnloadMode).c_str());
    214   }
    215 
    216   void set_exception_function(ExceptionFunction func) {
    217     exception_function_ = func;
    218   }
    219 
    220  private:
    221   static LONG NTAPI ExceptionHandler(EXCEPTION_POINTERS* ex_ptrs){
    222     // Dispatch the exception to any exception function,
    223     // but only on the main thread.
    224     if (main_thread_ == ::GetCurrentThreadId() &&
    225         current_ != NULL &&
    226         current_->exception_function_ != NULL)
    227       current_->exception_function_(ex_ptrs);
    228 
    229     return ExceptionContinueSearch;
    230   }
    231 
    232   void* veh_id_;
    233   ExceptionFunction exception_function_;
    234 
    235   static NtLoaderTest* current_;
    236   static DWORD main_thread_;
    237 };
    238 
    239 NtLoaderTest* NtLoaderTest::current_ = NULL;
    240 DWORD NtLoaderTest::main_thread_ = ::GetCurrentThreadId();
    241 
    242 }  // namespace
    243 
    244 static int exceptions_handled = 0;
    245 static void OnCrashDuringLoadLibrary(EXCEPTION_POINTERS* ex_ptrs) {
    246   ASSERT_EQ(STATUS_ACCESS_VIOLATION, ex_ptrs->ExceptionRecord->ExceptionCode);
    247   ASSERT_EQ(2, ex_ptrs->ExceptionRecord->NumberParameters);
    248   ASSERT_EQ(EXCEPTION_WRITE_FAULT,
    249             ex_ptrs->ExceptionRecord->ExceptionInformation[0]);
    250   ASSERT_EQ(kCrashAddress,
    251             ex_ptrs->ExceptionRecord->ExceptionInformation[1]);
    252 
    253   // Bump the exceptions count.
    254   exceptions_handled++;
    255 
    256   EXPECT_TRUE(OwnsLoaderLock());
    257 
    258   HMODULE crash_dll = ::GetModuleHandle(kCrashDllName);
    259   ASSERT_TRUE(crash_dll != NULL);
    260 
    261   nt_loader::LDR_DATA_TABLE_ENTRY* entry = GetLoaderEntry(crash_dll);
    262   ASSERT_TRUE(entry != NULL);
    263   ASSERT_EQ(0, entry->Flags & LDRP_PROCESS_ATTACH_CALLED);
    264 }
    265 
    266 TEST_F(NtLoaderTest, CrashOnLoadLibrary) {
    267   exceptions_handled = 0;
    268   set_exception_function(OnCrashDuringLoadLibrary);
    269 
    270   // Setup to crash on load.
    271   scoped_ptr<base::Environment> env(base::Environment::Create());
    272   env->SetVar(WideToASCII(kCrashOnLoadMode).c_str(), "1");
    273 
    274   // And load it.
    275   HMODULE module = ::LoadLibrary(kCrashDllName);
    276   DWORD err = ::GetLastError();
    277   EXPECT_EQ(NULL, module);
    278   EXPECT_EQ(ERROR_NOACCESS, err);
    279   EXPECT_EQ(1, exceptions_handled);
    280 
    281   if (module != NULL)
    282     ::FreeLibrary(module);
    283 }
    284 
    285 static void OnCrashDuringUnloadLibrary(EXCEPTION_POINTERS* ex_ptrs) {
    286   ASSERT_EQ(STATUS_ACCESS_VIOLATION, ex_ptrs->ExceptionRecord->ExceptionCode);
    287   ASSERT_EQ(2, ex_ptrs->ExceptionRecord->NumberParameters);
    288   ASSERT_EQ(EXCEPTION_WRITE_FAULT,
    289             ex_ptrs->ExceptionRecord->ExceptionInformation[0]);
    290   ASSERT_EQ(kCrashAddress,
    291             ex_ptrs->ExceptionRecord->ExceptionInformation[1]);
    292 
    293   // Bump the exceptions count.
    294   exceptions_handled++;
    295 
    296   EXPECT_TRUE(OwnsLoaderLock());
    297 
    298   HMODULE crash_dll = ::GetModuleHandle(kCrashDllName);
    299   ASSERT_TRUE(crash_dll == NULL);
    300 
    301   nt_loader::LDR_DATA_TABLE_ENTRY* entry = GetLoaderEntry(crash_dll);
    302   ASSERT_TRUE(entry == NULL);
    303 }
    304 
    305 TEST_F(NtLoaderTest, CrashOnUnloadLibrary) {
    306   // Setup to crash on unload.
    307   scoped_ptr<base::Environment> env(base::Environment::Create());
    308   env->SetVar(WideToASCII(kCrashOnUnloadMode).c_str(), "1");
    309 
    310   // And load it.
    311   HMODULE module = ::LoadLibrary(kCrashDllName);
    312   EXPECT_TRUE(module != NULL);
    313 
    314   exceptions_handled = 0;
    315   set_exception_function(OnCrashDuringUnloadLibrary);
    316 
    317   // We should crash during unload.
    318   if (module != NULL)
    319     ::FreeLibrary(module);
    320 
    321   EXPECT_EQ(1, exceptions_handled);
    322 }
    323