win: Capture some CRITICAL_SECTION debugging data

util/win/exception_handler_server.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 87 matching lines @@
 //! This object must be created and destroyed on the main thread. Access must be
 //! guarded by use of the lock() with the exception of the threadpool wait
 //! variables which are accessed only by the main thread.
 class ClientData {
  public:
   ClientData(HANDLE port,
              ExceptionHandlerServer::Delegate* delegate,
              ScopedKernelHANDLE process,
              WinVMAddress crash_exception_information_address,
              WinVMAddress non_crash_exception_information_address,
+             WinVMAddress debug_critical_section_address,
              WAITORTIMERCALLBACK crash_dump_request_callback,
              WAITORTIMERCALLBACK non_crash_dump_request_callback,
              WAITORTIMERCALLBACK process_end_callback)
       : crash_dump_request_thread_pool_wait_(INVALID_HANDLE_VALUE),
         non_crash_dump_request_thread_pool_wait_(INVALID_HANDLE_VALUE),
         process_end_thread_pool_wait_(INVALID_HANDLE_VALUE),
         lock_(),
         port_(port),
         delegate_(delegate),
         crash_dump_requested_event_(
             CreateEvent(nullptr, false /* auto reset */, false, nullptr)),
         non_crash_dump_requested_event_(
             CreateEvent(nullptr, false /* auto reset */, false, nullptr)),
         non_crash_dump_completed_event_(
             CreateEvent(nullptr, false /* auto reset */, false, nullptr)),
         process_(process.Pass()),
         crash_exception_information_address_(
             crash_exception_information_address),
         non_crash_exception_information_address_(
-            non_crash_exception_information_address) {
+            non_crash_exception_information_address),
+        debug_critical_section_address_(debug_critical_section_address) {
     RegisterThreadPoolWaits(crash_dump_request_callback,
                             non_crash_dump_request_callback,
                             process_end_callback);
   }
 
   ~ClientData() {
     // It is important that this only access the threadpool waits (it's called
     // from the main thread) until the waits are unregistered, to ensure that
     // any outstanding callbacks are complete.
     UnregisterThreadPoolWaits();
@@ skipping 10 matching lines @@
   }
   HANDLE non_crash_dump_completed_event() const {
     return non_crash_dump_completed_event_.get();
   }
   WinVMAddress crash_exception_information_address() const {
     return crash_exception_information_address_;
   }
   WinVMAddress non_crash_exception_information_address() const {
     return non_crash_exception_information_address_;
   }
+  WinVMAddress debug_critical_section_address() const {
+    return debug_critical_section_address_;
+  }
   HANDLE process() const { return process_.get(); }
 
  private:
   void RegisterThreadPoolWaits(
       WAITORTIMERCALLBACK crash_dump_request_callback,
       WAITORTIMERCALLBACK non_crash_dump_request_callback,
       WAITORTIMERCALLBACK process_end_callback) {
     if (!RegisterWaitForSingleObject(&crash_dump_request_thread_pool_wait_,
                                      crash_dump_requested_event_.get(),
                                      crash_dump_request_callback,
@@ skipping 44 matching lines @@
   base::Lock lock_;
   // Access to these fields must be guarded by lock_.
   HANDLE port_;  // weak
   ExceptionHandlerServer::Delegate* delegate_;  // weak
   ScopedKernelHANDLE crash_dump_requested_event_;
   ScopedKernelHANDLE non_crash_dump_requested_event_;
   ScopedKernelHANDLE non_crash_dump_completed_event_;
   ScopedKernelHANDLE process_;
   WinVMAddress crash_exception_information_address_;
   WinVMAddress non_crash_exception_information_address_;
+  WinVMAddress debug_critical_section_address_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientData);
 };
 
 }  // namespace internal
 
 ExceptionHandlerServer::Delegate::~Delegate() {
 }
 
 ExceptionHandlerServer::ExceptionHandlerServer()
@@ skipping 173 matching lines @@
 
   internal::ClientData* client;
   {
     base::AutoLock lock(*service_context.clients_lock());
     client = new internal::ClientData(
         service_context.port(),
         service_context.delegate(),
         ScopedKernelHANDLE(client_process),
         message.registration.crash_exception_information,
         message.registration.non_crash_exception_information,
+        message.registration.critical_section_address,
         &OnCrashDumpEvent,
         &OnNonCrashDumpEvent,
         &OnProcessEnd);
     service_context.clients()->insert(client);
   }
 
   // Duplicate the events back to the client so they can request a dump.
   ServerToClientMessage response;
   response.registration.request_crash_dump_event =
       base::checked_cast<uint32_t>(reinterpret_cast<uintptr_t>(DuplicateEvent(
@@ skipping 33 matching lines @@
 }
 
 // static
 void __stdcall ExceptionHandlerServer::OnCrashDumpEvent(void* ctx, BOOLEAN) {
   // This function is executed on the thread pool.
   internal::ClientData* client = reinterpret_cast<internal::ClientData*>(ctx);
   base::AutoLock lock(*client->lock());
 
   // Capture the exception.
   unsigned int exit_code = client->delegate()->ExceptionHandlerServerException(
-      client->process(), client->crash_exception_information_address());
+      client->process(),
+      client->crash_exception_information_address(),
+      client->debug_critical_section_address());
 
   TerminateProcess(client->process(), exit_code);
 }
 
 // static
 void __stdcall ExceptionHandlerServer::OnNonCrashDumpEvent(void* ctx, BOOLEAN) {
   // This function is executed on the thread pool.
   internal::ClientData* client = reinterpret_cast<internal::ClientData*>(ctx);
   base::AutoLock lock(*client->lock());
 
   // Capture the exception.
   client->delegate()->ExceptionHandlerServerException(
-      client->process(), client->non_crash_exception_information_address());
+      client->process(),
+      client->non_crash_exception_information_address(),
+      client->debug_critical_section_address());
 
   bool result = SetEvent(client->non_crash_dump_completed_event());
   PLOG_IF(ERROR, !result) << "SetEvent";
 }
 
 // static
 void __stdcall ExceptionHandlerServer::OnProcessEnd(void* ctx, BOOLEAN) {
   // This function is executed on the thread pool.
   internal::ClientData* client = reinterpret_cast<internal::ClientData*>(ctx);
   base::AutoLock lock(*client->lock());
 
   // Post back to the main thread to have it delete this client record.
   PostQueuedCompletionStatus(client->port(), 0, ULONG_PTR(client), nullptr);
 }
 
 }  // namespace crashpad