win: Add more memory regions to gathering of PEB

snapshot/win/process_reader_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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "snapshot/win/process_reader_win.h"
 
 #include <winternl.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "util/win/capture_context.h"
 #include "util/win/nt_internals.h"
 #include "util/win/ntstatus_logging.h"
 #include "util/win/process_structs.h"
 #include "util/win/scoped_handle.h"
 #include "util/win/time.h"
 
 namespace crashpad {
 
 namespace {
@@ skipping 176 matching lines @@
   suspension_state_ = suspension_state;
   process_info_.Initialize(process);
 
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 
 bool ProcessReaderWin::ReadMemory(WinVMAddress at,
                                   WinVMSize num_bytes,
                                   void* into) const {
+  if (num_bytes == 0)
+    return 0;
+
   SIZE_T bytes_read;
   if (!ReadProcessMemory(process_,
                          reinterpret_cast<void*>(at),
                          into,
                          base::checked_cast<SIZE_T>(num_bytes),
                          &bytes_read) ||
       num_bytes != bytes_read) {
     PLOG(ERROR) << "ReadMemory at 0x" << std::hex << at << std::dec << " of "
                 << num_bytes << " bytes failed";
     return false;
   }
   return true;
 }
 
+WinVMSize ProcessReaderWin::ReadAvailableMemory(WinVMAddress at,
+                                                WinVMSize num_bytes,
+                                                void* into) const {
+  if (num_bytes == 0)
+    return 0;
+
+  auto ranges = process_info_.GetReadableRanges(
+      CheckedRange<WinVMAddress, WinVMSize>(at, num_bytes));
+
+  // We only read up until the first unavailable byte, so we only read from the
+  // first range. If we have no ranges, then no bytes were accessible anywhere
+  // in the range.
+  if (ranges.empty()) {
+    LOG(ERROR) << base::StringPrintf(
+        "range at 0x%llx, size 0x%llx completely inaccessible", at, num_bytes);
+    return 0;
+  }
+
+  // If the start address was adjusted, we couldn't read even the first
+  // requested byte.
+  if (ranges.front().base() != at) {
+    LOG(ERROR) << base::StringPrintf(
+        "start of range at 0x%llx, size 0x%llx inaccessible", at, num_bytes);
+    return 0;
+  }
+
+  DCHECK_LE(ranges.front().size(), num_bytes);
+
+  // If we fail on a normal read, then something went very wrong.
+  if (!ReadMemory(ranges.front().base(), ranges.front().size(), into))
+    return 0;
+
+  return ranges.front().size();
+}
+
 bool ProcessReaderWin::StartTime(timeval* start_time) const {
   FILETIME creation, exit, kernel, user;
   if (!GetProcessTimes(process_, &creation, &exit, &kernel, &user)) {
     PLOG(ERROR) << "GetProcessTimes";
     return false;
   }
   *start_time = FiletimeToTimevalEpoch(creation);
   return true;
 }
 
@@ skipping 121 matching lines @@
         thread.stack_region_size = 0;
       } else {
         thread.stack_region_size = base - limit;
       }
     }
     threads_.push_back(thread);
   }
 }
 
 }  // namespace crashpad