Implement GetMemoryRegions() for Windows Minidumps and live processes.

[hhellyer]

Summary

This patch fills in the implementation of GetMemoryRegions() on the Windows live process and minidump implementations of lldb_private::Process (ProcessWindowsLive::GetMemoryRegionInfo and ProcessWinMiniDump::Impl::GetMemoryRegionInfo.) The GetMemoryRegions API was added under: http://reviews.llvm.org/D20565

The existing Windows implementations didn’t fill in the start and end addresses within MemoryRegionInfo. This patch fixes that and adds support for the new mapped flag on MemoryRegionInfo that says whether a memory range is mapped into the process address space or not.

The behaviour of both live and core implementations should match the behaviour documented on Process::GetMemoryRegionInfo (in Process.h) which in turn should match the behaviour of the qMemoryRegionInfo query documented in lldb-gdb-remote.txt.

[hhellyer]

Arcanist won't upload the patch without the change to .arcconfig yet because of http://lists.llvm.org/pipermail/llvm-dev/2016-July/102305.html but I think this will be patched officially shortly! It should disappear if I update the revision for any reason once that's happened.

[amccarth]

source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

338

I'm not clear why you deleted the SetErrorString call.

[hhellyer]

.arcconfig has been updated.

[hhellyer]

source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

338

Asking for an address outside a known range is not actually an error, you just get back an unmapped range that specifies how far it is to the next mapped range.
The original discussion about that happened here: https://reviews.llvm.org/D21751 - GetMemoryRegionInfo should only need to return an error if it is unimplemented. (I should probably have referenced that in the summary.)

[amccarth]

source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

338

Got it. Thanks for the explanation!

Given that, should the condition on 284 ("the mini dump contains no memory range information") actually return an error or just an unmapped range?

[hhellyer]

source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

338

I thought the most likely cause of having no memory info would be not passing the MiniDumpWithFullMemoryInfo flag to MiniDumpWriteDump will create a dump without the MemoryInfoListStream present. Saying that memory range information from a dump like that is "unsupported" seemed like the right option. I think MiniDumpWithFullMemoryInfo is part of the default set of flags used when you create a dump through task manager so most dumps should have the stream.

I won't land the patch immediately, I'm happy to change it if you'd prefer it to return an unmapped range. I think it would have to be one unmapped range that ran from load_addr to LLDB_INVALID_ADDRESS to match the expected behaviour.

[amccarth]

LGTM. Thanks!

source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

338

Sounds like you've thought it through more thoroughly than I, and I agree with your conclusions, so I have no objections. Thanks for the explanations.

source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp

ProcessWindowsLive::DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, Error &error)
     return bytes_written;
 }
 
 Error
 ProcessWindowsLive::GetMemoryRegionInfo(lldb::addr_t vm_addr, MemoryRegionInfo &info)
 {
     Error error;
     llvm::sys::ScopedLock lock(m_mutex);
+    info.Clear();
 
     if (!m_session_data)
     {
         error.SetErrorString("GetMemoryRegionInfo called with no debugging session.");
         WINERR_IFALL(WINDOWS_LOG_MEMORY, error.AsCString());
         return error;
     }
-
     HostProcess process = m_session_data->m_debugger->GetProcess();
     lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
     if (handle == nullptr || handle == LLDB_INVALID_PROCESS)
     {
         error.SetErrorString("GetMemoryRegionInfo called with an invalid target process.");
         WINERR_IFALL(WINDOWS_LOG_MEMORY, error.AsCString());
         return error;
     }
 
     WINLOG_IFALL(WINDOWS_LOG_MEMORY, "GetMemoryRegionInfo getting info for address 0x%I64x", vm_addr);
 
     void *addr = reinterpret_cast<void *>(vm_addr);
     MEMORY_BASIC_INFORMATION mem_info = {0};
     SIZE_T result = ::VirtualQueryEx(handle, addr, &mem_info, sizeof(mem_info));
     if (result == 0)
     {
+        if (::GetLastError() == ERROR_INVALID_PARAMETER)
+        {
+            // ERROR_INVALID_PARAMETER is returned if VirtualQueryEx is called with an address
+            // past the highest accessible address. We should return a range from the vm_addr
+            // to LLDB_INVALID_ADDRESS
+            info.GetRange().SetRangeBase(vm_addr);
+            info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
+            info.SetReadable(MemoryRegionInfo::eNo);
+            info.SetExecutable(MemoryRegionInfo::eNo);
+            info.SetWritable(MemoryRegionInfo::eNo);
+            info.SetMapped(MemoryRegionInfo::eNo);
+            return error;
+        }
+        else
+        {
             error.SetError(::GetLastError(), eErrorTypeWin32);
             WINERR_IFALL(WINDOWS_LOG_MEMORY,
-                     "VirtualQueryEx returned error %u while getting memory region info for address 0x%I64x",
-                     error.GetError(), vm_addr);
             return error;
         }
+    }
+
+    // Protect bits are only valid for MEM_COMMIT regions.
+    if (mem_info.State == MEM_COMMIT) {
         const bool readable = IsPageReadable(mem_info.Protect);
         const bool executable = IsPageExecutable(mem_info.Protect);
         const bool writable = IsPageWritable(mem_info.Protect);
         info.SetReadable(readable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
         info.SetExecutable(executable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
         info.SetWritable(writable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+    }
+    else
+    {
+        info.SetReadable(MemoryRegionInfo::eNo);
+        info.SetExecutable(MemoryRegionInfo::eNo);
+        info.SetWritable(MemoryRegionInfo::eNo);
+    }
+
+    // AllocationBase is defined for MEM_COMMIT and MEM_RESERVE but not MEM_FREE.
+    if (mem_info.State != MEM_FREE) {
+        info.GetRange().SetRangeBase(reinterpret_cast<addr_t>(mem_info.AllocationBase));
+        info.GetRange().SetRangeEnd(reinterpret_cast<addr_t>(mem_info.BaseAddress) + mem_info.RegionSize);
+        info.SetMapped(MemoryRegionInfo::eYes);
+    }
+    else
+    {
+        // In the unmapped case we need to return the distance to the next block of memory.
+        // VirtualQueryEx nearly does that except that it gives the distance from the start
+        // of the page containing vm_addr.
+        SYSTEM_INFO data;
+        GetSystemInfo(&data);
+        DWORD page_offset = vm_addr % data.dwPageSize;
+        info.GetRange().SetRangeBase(vm_addr);
+        info.GetRange().SetByteSize(mem_info.RegionSize - page_offset);
+        info.SetMapped(MemoryRegionInfo::eNo);
+    }
 
     error.SetError(::GetLastError(), eErrorTypeWin32);
     WINLOGV_IFALL(WINDOWS_LOG_MEMORY, "Memory region info for address 0x%I64u: readable=%s, executable=%s, writable=%s",
-                  BOOL_STR(readable), BOOL_STR(executable), BOOL_STR(writable));
+                  BOOL_STR(info.GetReadable()), BOOL_STR(info.GetExecutable()), BOOL_STR(info.GetWritable()));
     return error;
 }
 
 bool
 ProcessWindowsLive::CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name)
 {
     if (plugin_specified_by_name)
         return true;

source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

ProcessWinMiniDump::Impl::DoReadMemory(lldb::addr_t addr, void *buf, size_t size, Error &error)
     return overlap;
 }
 
 Error
 ProcessWinMiniDump::Impl::GetMemoryRegionInfo(lldb::addr_t load_addr, lldb_private::MemoryRegionInfo &info)
 {
     Error error;
     size_t size;
+    info.Clear();
     const auto list = reinterpret_cast<const MINIDUMP_MEMORY_INFO_LIST *>(FindDumpStream(MemoryInfoListStream, &size));
     if (list == nullptr || size < sizeof(MINIDUMP_MEMORY_INFO_LIST))
     {
         error.SetErrorString("the mini dump contains no memory range information");
         return error;
     }
 
     if (list->SizeOfEntry < sizeof(MINIDUMP_MEMORY_INFO))
     {
         error.SetErrorString("the entries in the mini dump memory info list are smaller than expected");
         return error;
     }
 
     if (size < list->SizeOfHeader + list->SizeOfEntry * list->NumberOfEntries)
     {
         error.SetErrorString("the mini dump memory info list is incomplete");
         return error;
     }
 
+    const MINIDUMP_MEMORY_INFO *next_entry = nullptr;
+
     for (int i = 0; i < list->NumberOfEntries; ++i)
     {
         const auto entry = reinterpret_cast<const MINIDUMP_MEMORY_INFO *>(reinterpret_cast<const char *>(list) +
                                                                           list->SizeOfHeader + i * list->SizeOfEntry);
         const auto head = entry->BaseAddress;
         const auto tail = head + entry->RegionSize;
         if (head <= load_addr && load_addr < tail)
         {
+            info.GetRange().SetRangeBase((entry->State != MEM_FREE) ? head : load_addr);
+            info.GetRange().SetRangeEnd(tail);
             info.SetReadable(IsPageReadable(entry->Protect) ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
             info.SetWritable(IsPageWritable(entry->Protect) ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
             info.SetExecutable(IsPageExecutable(entry->Protect) ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+            info.SetMapped((entry->State != MEM_FREE) ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
             return error;
         }
+        else if (head > load_addr && (next_entry == nullptr || head < next_entry->BaseAddress) )
+        {
+            // In case there is no region containing load_addr keep track of the nearest region
+            // after load_addr so we can return the distance to it.
+            next_entry = entry;
+        }
     }
+
+    // No containing region found. Create an unmapped region that extends to the next region
+    // or LLDB_INVALID_ADDRESS
+    info.GetRange().SetRangeBase(load_addr);
+    info.GetRange().SetRangeEnd((next_entry != nullptr)?next_entry->BaseAddress:LLDB_INVALID_ADDRESS);
+    info.SetReadable(MemoryRegionInfo::eNo);
+    info.SetWritable(MemoryRegionInfo::eNo);
+    info.SetExecutable(MemoryRegionInfo::eNo);
+    info.SetMapped(MemoryRegionInfo::eNo);
+
     // Note that the memory info list doesn't seem to contain ranges in kernel space,
     // so if you're walking a stack that has kernel frames, the stack may appear
     // truncated.
-    error.SetErrorString("address is not in a known range");
     return error;
 }
 
 bool
 ProcessWinMiniDump::Impl::FindMemoryRange(lldb::addr_t addr, Range *range_out) const
 {
     size_t stream_size = 0;
     auto mem_list_stream = static_cast<const MINIDUMP_MEMORY_LIST *>(FindDumpStream(MemoryListStream, &stream_size));
     if (mem_list_stream)