win: Gather memory information

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,
@@ skipping 235 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) {
+  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);
+  MEMORY_BASIC_INFORMATION memory_basic_information;
+  for (WinVMAddress address = min_address; address <= max_address;
+       address += memory_basic_information.RegionSize) {
+    size_t result = VirtualQueryEx(process,

[Mark Mentovai, 2015/09/26 03:36:36]

So if you ask about a 32-bit process from a 64-bit process, you’ll get back a
big free region if you ask about what’s at, say, 0x100000000?

Do we really want that nonsense to show up in the minidump?

[scottmg, 2015/09/26 04:08:53]

Yeah, there's one very big region at:

		base_address	0x000000007fff0000	unsigned __int64
		region_size	0x00007ffe92850000	unsigned __int64

in running ProcessInfo.OtherProcessWOW64 on my machine. There's 96 regions. The
majority (88) are < 0x7fff`0000, and then there's a handful at the top of the
x64 address space. I guess those are the WOW64 code and its stack. I think as
far as making !vprot work in windbg it should be sufficient, but I won't know
for sure until they're actually plumbed all the way through to the minidump.

+                                   reinterpret_cast<void*>(address),
+                                   &memory_basic_information,
+                                   sizeof(memory_basic_information));
+    if (result == 0) {
+      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;
+    }
+  }
+
+  return true;
+}
+
 ProcessInfo::Module::Module() : name(), dll_base(0), size(0), timestamp() {
 }
 
 ProcessInfo::Module::~Module() {
 }
 
+ProcessInfo::MemoryInfo::MemoryInfo()
+    : base_address(0),
+      region_size(0),
+      allocation_base(0),
+      state(0),
+      allocation_protect(0),
+      protect(0),
+      type(0) {
+}
+
+ProcessInfo::MemoryInfo::MemoryInfo(const MEMORY_BASIC_INFORMATION& mbi)
+    : base_address(reinterpret_cast<WinVMAddress>(mbi.BaseAddress)),
+      region_size(mbi.RegionSize),

[Mark Mentovai, 2015/09/26 03:36:36]

You need casts for the address fields but not the size ones?

[scottmg, 2015/09/26 04:08:53]

Yeah, the size is a SIZE_T, but the addresses are void*.

+      allocation_base(reinterpret_cast<WinVMAddress>(mbi.AllocationBase)),
+      state(mbi.State),
+      allocation_protect(mbi.AllocationProtect),
+      protect(mbi.Protect),
+      type(mbi.Type) {
+}
+
+ProcessInfo::MemoryInfo::~MemoryInfo() {
+}
+
 ProcessInfo::ProcessInfo()
     : process_id_(),
       inherited_from_process_id_(),
       command_line_(),
       peb_address_(0),
       peb_size_(0),
       modules_(),
+      memory_info_(),
       is_64_bit_(false),
       is_wow64_(false),
       initialized_() {
 }
 
 ProcessInfo::~ProcessInfo() {
 }
 
 bool ProcessInfo::Initialize(HANDLE process) {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
@@ skipping 34 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)) {
+    LOG(ERROR) << "ReadMemoryInfo failed";
+    return false;
+  }
+
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 
 bool ProcessInfo::Is64Bit() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return is_64_bit_;
 }
 
 bool ProcessInfo::IsWow64() const {
@@ skipping 21 matching lines @@
   *peb_address = peb_address_;
   *peb_size = peb_size_;
 }
 
 bool ProcessInfo::Modules(std::vector<Module>* modules) const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   *modules = modules_;
   return true;
 }
 
+const std::vector<ProcessInfo::MemoryInfo>& ProcessInfo::MemoryInformation()
+    const {
+  return memory_info_;
+}
+
 }  // namespace crashpad