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 86 matching lines @@
     PLOG(ERROR) << "ReadProcessMemory " << __FUNCSIG__;
     return false;
   }
   if (bytes_read != sizeof(T)) {
     LOG(ERROR) << "ReadProcessMemory " << __FUNCSIG__ << " incorrect size";
     return false;
   }
   return true;
 }
 
+// Map from Traits to an MEMORY_BASIC_INFORMATIIONxx.
+template <class Traits>
+struct MemoryBasicInformationForTraits;
+
+template <>
+struct MemoryBasicInformationForTraits<process_types::internal::Traits32> {
+  using type = MEMORY_BASIC_INFORMATION32;
+};
+
+template <>
+struct MemoryBasicInformationForTraits<process_types::internal::Traits64> {
+  using type = MEMORY_BASIC_INFORMATION64;
+};
+
 }  // namespace
 
 template <class Traits>
 bool GetProcessBasicInformation(HANDLE process,
                                 bool is_wow64,
                                 ProcessInfo* process_info,
                                 WinVMAddress* peb_address,
                                 WinVMSize* peb_size) {
   ULONG bytes_returned;
   process_types::PROCESS_BASIC_INFORMATION<Traits> process_basic_information;
@@ skipping 129 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;
 }
 
+template <class Traits>
+bool ReadMemoryInfo(HANDLE process, ProcessInfo* process_info) {
+  DCHECK(process_info->memory_info_.empty());
+
+  SYSTEM_INFO system_info;
+  GetSystemInfo(&system_info);
+  uint64_t min_address =

[Mark Mentovai, 2015/09/26 02:02:14]

const WinVMAddress?

[scottmg, 2015/09/26 03:12:36]

Done.

+      reinterpret_cast<uint64_t>(system_info.lpMinimumApplicationAddress);
+  uint64_t max_address =
+      reinterpret_cast<uint64_t>(system_info.lpMaximumApplicationAddress);

[Mark Mentovai, 2015/09/26 02:02:14]

Is this correct for 64-reads-32-on-64?

[scottmg, 2015/09/26 03:12:36]

Hmm, good point, that's tricky. After playing around with it, the memory map
appears to always be returned for the bitness that you're asking from. So
removed some complexity and just use MEMORY_BASIC_INFORMATION directly when
reading without the templating. This seems directly contradictory to the
implication at the bottom of
https://msdn.microsoft.com/en-us/library/windows/desktop/aa366775(v=vs.85).aspx
but when I tried reading into a MEMORY_BASIC_INFORMATION32 for a 32-process from
an x64 handler it errors with an "incorrect size".

Added to the ProcessInfo.OtherProcess for this case.

+  uint64_t address = min_address;
+  while (address <= max_address) {

[Mark Mentovai, 2015/09/26 02:02:14]

for (WinVMAddress address = min_address; address <= max_address; address +=
memory_basic_information.RegionSize)

[scottmg, 2015/09/26 03:12:36]

Done.

+    MemoryBasicInformationForTraits<Traits>::type memory_basic_information;
+    size_t result = VirtualQueryEx(
+        process,
+        reinterpret_cast<void*>(address),
+        reinterpret_cast<MEMORY_BASIC_INFORMATION*>(&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));
+
+    address += memory_basic_information.RegionSize;

[Mark Mentovai, 2015/09/26 02:02:14]

DCHECK_GT(RegionSize, 0);

so that a very busted memory map on a very sick system won’t cause this to spin
forever.

[scottmg, 2015/09/26 03:12:36]

Done. (if with LOG rather than DCHECK)

+  }
+
+  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) {
+}
+
+template <class MBI>
+ProcessInfo::MemoryInfo::MemoryInfo(const MBI& mbi)
+    : base_address(mbi.BaseAddress),
+      region_size(mbi.RegionSize),
+      allocation_base(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;
   }
 
+  result =
+      is_64_bit_
+          ? ReadMemoryInfo<process_types::internal::Traits64>(process, this)
+          : ReadMemoryInfo<process_types::internal::Traits32>(process, this);
+  if (!result) {
+    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