win: fix VirtualQueryEx on < win10

util/win/process_info.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 "util/win/process_info.h"
 
 #include <winternl.h>
 
+#include <limits>
+
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "util/numeric/safe_assignment.h"
 #include "util/win/ntstatus_logging.h"
 #include "util/win/process_structs.h"
 
 namespace crashpad {
 
 namespace {
@@ skipping 217 matching lines @@
     module.size = ldr_data_table_entry.SizeOfImage;
     module.timestamp = ldr_data_table_entry.TimeDateStamp;
     process_info->modules_.push_back(module);
     if (cur == last)
       break;
   }
 
   return true;
 }
 
-bool ReadMemoryInfo(HANDLE process, ProcessInfo* process_info) {
+bool ReadMemoryInfo(HANDLE process, bool is_64_bit, ProcessInfo* process_info) {
   DCHECK(process_info->memory_info_.empty());
 
-  SYSTEM_INFO system_info;
-  GetSystemInfo(&system_info);
-  const WinVMAddress min_address =
-      reinterpret_cast<WinVMAddress>(system_info.lpMinimumApplicationAddress);
-  const WinVMAddress max_address =
-      reinterpret_cast<WinVMAddress>(system_info.lpMaximumApplicationAddress);
+  const WinVMAddress min_address = 0;
+  // We can't use GetSystemInfo() to get the address space range for another
+  // process. VirtualQueryEx() will fail with ERROR_INVALID_PARAMETER if the
+  // address is above the highest memory address accessible to the process, so
+  // we just probe the entire potential range (2^32 for x86, or 2^64 for x64).
+  const WinVMAddress max_address = is_64_bit
+                                       ? std::numeric_limits<uint64_t>::max()
+                                       : std::numeric_limits<uint32_t>::max();
   MEMORY_BASIC_INFORMATION memory_basic_information;
   for (WinVMAddress address = min_address; address <= max_address;
        address += memory_basic_information.RegionSize) {
     size_t result = VirtualQueryEx(process,
                                    reinterpret_cast<void*>(address),
                                    &memory_basic_information,
                                    sizeof(memory_basic_information));
     if (result == 0) {
+      if (GetLastError() == ERROR_INVALID_PARAMETER)
+        break;
       PLOG(ERROR) << "VirtualQueryEx";
       return false;
     }
 
     process_info->memory_info_.push_back(
         ProcessInfo::MemoryInfo(memory_basic_information));
 
     if (memory_basic_information.RegionSize == 0) {
       LOG(ERROR) << "RegionSize == 0";
       return false;
@@ skipping 77 matching lines @@
 
   result = is_64_bit_ ? ReadProcessData<process_types::internal::Traits64>(
                             process, peb_address_, this)
                       : ReadProcessData<process_types::internal::Traits32>(
                             process, peb_address_, this);
   if (!result) {
     LOG(ERROR) << "ReadProcessData failed";
     return false;
   }
 
-  if (!ReadMemoryInfo(process, this)) {
+  if (!ReadMemoryInfo(process, is_64_bit_, this)) {
     LOG(ERROR) << "ReadMemoryInfo failed";
     return false;
   }
 
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 
 bool ProcessInfo::Is64Bit() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
@@ skipping 31 matching lines @@
   *modules = modules_;
   return true;
 }
 
 const std::vector<ProcessInfo::MemoryInfo>& ProcessInfo::MemoryInformation()
     const {
   return memory_info_;
 }
 
 }  // namespace crashpad