win: Only capture the loader lock for now

snapshot/win/process_snapshot_win.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 312 matching lines @@
                                      &extra_memory_);
   AddMemorySnapshot(
       process_parameters.Environment,
       DetermineSizeOfEnvironmentBlock(process_parameters.Environment),
       &extra_memory_);
 
   // Walk the loader lock which is directly referenced by the PEB. It may or may
   // not have a .DebugInfo list, but doesn't on more recent OSs (it does on
   // Vista). If it does, then we may walk the lock list more than once, but
   // AddMemorySnapshot() will take care of deduplicating the added regions.
   ReadLocks<Traits>(peb_data.LoaderLock, &extra_memory_);

[Mark Mentovai, 2015/11/30 18:32:06]

If we really only care about the loader lock, maybe we should just do this one
and #if 0 out the next one until we have a better mechanism to control it.

 
   // Traverse the locks with valid .DebugInfo if a starting point was supplied.
   if (debug_critical_section_address)
     ReadLocks<Traits>(debug_critical_section_address, &extra_memory_);
 }
 
 void ProcessSnapshotWin::AddMemorySnapshot(
     WinVMAddress address,
     WinVMSize size,
     PointerVector<internal::MemorySnapshotWin>* into) {
@@ skipping 97 matching lines @@
 
   const decltype(critical_section.DebugInfo) kInvalid =
       static_cast<decltype(critical_section.DebugInfo)>(-1);
   if (critical_section.DebugInfo == kInvalid)
     return;
 
   const WinVMAddress start_address_backward = critical_section.DebugInfo;
   WinVMAddress current_address = start_address_backward;
   WinVMAddress last_good_address;
 
+  // Cap the list of locks we capture arbitrarily so we don't walk forever.
+  const int kMaxWalkLength = 100;

[Mark Mentovai, 2015/11/30 18:32:06]

…and maybe we should just grab the loader lock here instead of grabbing an
arbitrary number of other locks.

+  int walk_count = 0;
+
   // Typically, this seems to be a circular list, but it's not clear that it
   // always is, so follow Blink fields back to the head (or where we started)
   // before following Flink to capture memory.
   do {
     last_good_address = current_address;
     // Read the RTL_CRITICAL_SECTION_DEBUG structure to get ProcessLocksList.
     process_types::RTL_CRITICAL_SECTION_DEBUG<Traits> critical_section_debug;
     if (!process_reader_.ReadMemory(current_address,
                                     sizeof(critical_section_debug),
                                     &critical_section_debug)) {
       LOG(ERROR) << "failed to read RTL_CRITICAL_SECTION_DEBUG";
       return;
     }
 
     if (critical_section_debug.ProcessLocksList.Blink == 0) {
       // At the head of the list.
       break;
     }
 
     // Move to the previous RTL_CRITICAL_SECTION_DEBUG by walking
     // ProcessLocksList.Blink.
     current_address =
         critical_section_debug.ProcessLocksList.Blink -
         offsetof(process_types::RTL_CRITICAL_SECTION_DEBUG<Traits>,
                  ProcessLocksList);
+    walk_count++;
+    if (walk_count == kMaxWalkLength)
+      break;
   } while (current_address != start_address_backward &&
            current_address != kInvalid);
 
   if (current_address == kInvalid) {
     // Unexpectedly encountered a bad record, so step back one.
     current_address = last_good_address;
   }
 
+  walk_count = 0;
+
   const WinVMAddress start_address_forward = current_address;
 
   // current_address is now the head of the list, walk Flink to add the whole
   // list.
   do {
     // Read the RTL_CRITICAL_SECTION_DEBUG structure to get ProcessLocksList.
     process_types::RTL_CRITICAL_SECTION_DEBUG<Traits> critical_section_debug;
     if (!process_reader_.ReadMemory(current_address,
                                     sizeof(critical_section_debug),
                                     &critical_section_debug)) {
@@ skipping 12 matching lines @@
 
     if (critical_section_debug.ProcessLocksList.Flink == 0)
       break;
 
     // Move to the next RTL_CRITICAL_SECTION_DEBUG by walking
     // ProcessLocksList.Flink.
     current_address =
         critical_section_debug.ProcessLocksList.Flink -
         offsetof(process_types::RTL_CRITICAL_SECTION_DEBUG<Traits>,
                  ProcessLocksList);
+    walk_count++;
+    // Walk twice as far on the forward walk, so that if we started at an
+    // important one (for example the Loader Lock), we get it, and ones that
+    // were presumably allocated temporally near it.
+    if (walk_count == kMaxWalkLength * 2)
+      break;
   } while (current_address != start_address_forward &&
            current_address != kInvalid);
 }
 
 }  // namespace crashpad