win: Capture some CRITICAL_SECTION debugging data

snapshot/win/process_snapshot_win.h

 // 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 41 matching lines @@
 class ProcessSnapshotWin final : public ProcessSnapshot {
  public:
   ProcessSnapshotWin();
   ~ProcessSnapshotWin() override;
 
   //! \brief Initializes the object.
   //!
   //! \param[in] process The handle to create a snapshot from.
   //! \param[in] suspension_state Whether \a process has been suspended by the
   //!     caller.
+  //! \param[in] debug_critical_section_address The address in the target
+  //!     process's address space of a `CRITICAL_SECTION` allocated with valid
+  //!     `.DebugInfo`. Used as a starting point to walk the process's locks.
+  //!     May be `0`.
   //!
   //! \return `true` if the snapshot could be created, `false` otherwise with
   //!     an appropriate message logged.
   //!
   //! \sa ScopedProcessSuspend
-  bool Initialize(HANDLE process, ProcessSuspensionState suspension_state);
+  bool Initialize(HANDLE process,
+                  ProcessSuspensionState suspension_state,
+                  WinVMAddress debug_critical_section_address);
 
   //! \brief Initializes the object's exception.
   //!
   //! This populates the data to be returned by Exception().
   //!
   //! This method must not be called until after a successful call to
   //! Initialize().
   //!
   //! \param[in] exception_information_address The address in the client
   //!     process's address space of an ExceptionInformation structure.
@@ skipping 53 matching lines @@
   std::vector<const MemoryMapRegionSnapshot*> MemoryMap() const override;
   std::vector<const MemorySnapshot*> ExtraMemory() const override;
 
  private:
   // Initializes threads_ on behalf of Initialize().
   void InitializeThreads();
 
   // Initializes modules_ on behalf of Initialize().
   void InitializeModules();
 
-  // Initializes peb_memory_ on behalf of Initialize().
+  // Initializes various memory blocks reachable from the PEB on behalf of
+  // Initialize().
   template <class Traits>
-  void InitializePebData();
+  void InitializePebData(WinVMAddress debug_critical_section_address);
 
   void AddMemorySnapshot(WinVMAddress address,
                          WinVMSize size,
                          PointerVector<internal::MemorySnapshotWin>* into);
 
   template <class Traits>
   void AddMemorySnapshotForUNICODE_STRING(
       const process_types::UNICODE_STRING<Traits>& us,
       PointerVector<internal::MemorySnapshotWin>* into);
 
   template <class Traits>
   void AddMemorySnapshotForLdrLIST_ENTRY(
       const process_types::LIST_ENTRY<Traits>& le,
       size_t offset_of_member,
       PointerVector<internal::MemorySnapshotWin>* into);
 
   WinVMSize DetermineSizeOfEnvironmentBlock(
       WinVMAddress start_of_environment_block);
 
+  // Starting from the address of a CRITICAL_SECTION, walks the doubly-linked
+  // list stored in RTL_CRITICAL_SECTION.DebugInfo.ProcessLocksList adding both
+  // the RTL_CRITICAL_SECTION and the RTL_CRITICAL_SECTION_DEBUG memory blocks
+  // to the snapshot.
+  template <class Traits>
+  void ReadLocks(WinVMAddress start,
+                 PointerVector<internal::MemorySnapshotWin>* into);
+
   internal::SystemSnapshotWin system_;
-  PointerVector<internal::MemorySnapshotWin> peb_memory_;
+  PointerVector<internal::MemorySnapshotWin> extra_memory_;
   PointerVector<internal::ThreadSnapshotWin> threads_;
   PointerVector<internal::ModuleSnapshotWin> modules_;
   scoped_ptr<internal::ExceptionSnapshotWin> exception_;
   PointerVector<internal::MemoryMapRegionSnapshotWin> memory_map_;
   ProcessReaderWin process_reader_;
   UUID report_id_;
   UUID client_id_;
   std::map<std::string, std::string> annotations_simple_map_;
   timeval snapshot_time_;
   InitializationStateDcheck initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessSnapshotWin);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_SNAPSHOT_WIN_PROCESS_SNAPSHOT_WIN_H_