GetMemoryRegions for the ProcessMinidump

[tatyana-krasnukha]

Summary

Moved from D55472

[clayborg]

Change looks good.

We need to add a test for this. You can use the minidump file from "lldb/unittests/Process/minidump/Inputs/regions-linux-map.dmp" and copy it over into "lldb/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new" and then add a test to "packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py" to ensure this doesn't regress.

[tatyana-krasnukha]

Add a test

[clayborg]

In D55841#1336515, @tatyana-krasnukha wrote:

Add a test

There was one added. See code

[clayborg]

In D55841#1336519, @clayborg wrote:

In D55841#1336515, @tatyana-krasnukha wrote:

Add a test

There was one added. See code

Never mind, I thought this was my patch! Ignore me...

[clayborg]

Just remove the "regions-linux-map.dmp" as I already checked one in with rLLDB349658 and this is good to go

packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

427

BTW: I added this file already with my last patch, so you can remove the "regions-linux-map.dmp" from the SVN commit. Just update your sources and make sure it matches and works.

[tatyana-krasnukha]

Removed dump file from the patch

[clayborg]

Looks good!

packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

def test_local_variables_in_minidump(self):
         # target create linux-x86_64_not_crashed -c linux-x86_64_not_crashed.dmp
         self.target = self.dbg.CreateTarget("linux-x86_64_not_crashed")
         self.process = self.target.LoadCore("linux-x86_64_not_crashed.dmp")
         self.check_state()
         thread = self.process.GetThreadAtIndex(0)
         frame = thread.GetFrameAtIndex(1)
         value = frame.EvaluateExpression('x')
         self.assertEqual(value.GetValueAsSigned(), 3)
+
+    def test_memory_regions_in_minidump(self):
+        """Test memory regions from a Minidump"""
+        # target create -c regions-linux-map.dmp
+        self.dbg.CreateTarget(None)
+        self.target = self.dbg.GetSelectedTarget()
+        self.process = self.target.LoadCore("regions-linux-map.dmp")
+        self.check_state()
+
+        regions_count = 19
+        region_info_list = self.process.GetMemoryRegions()
+        self.assertEqual(region_info_list.GetSize(), regions_count)
+
+        def check_region(index, start, end, read, write, execute, mapped, name):
+            region_info = lldb.SBMemoryRegionInfo()
+            self.assertTrue(
+                self.process.GetMemoryRegionInfo(start, region_info).Success())
+            self.assertEqual(start, region_info.GetRegionBase())
+            self.assertEqual(end, region_info.GetRegionEnd())
+            self.assertEqual(read, region_info.IsReadable())
+            self.assertEqual(write, region_info.IsWritable())
+            self.assertEqual(execute, region_info.IsExecutable())
+            self.assertEqual(mapped, region_info.IsMapped())
+            self.assertEqual(name, region_info.GetName())
+
+            # Ensure we have the same regions as SBMemoryRegionInfoList contains.
+            if index >= 0 and index < regions_count:
+                region_info_from_list = lldb.SBMemoryRegionInfo()
+                self.assertTrue(region_info_list.GetMemoryRegionAtIndex(
+                    index, region_info_from_list))
+                self.assertEqual(region_info_from_list, region_info)
+
+        a = "/system/bin/app_process"
+        b = "/system/bin/linker"
+        c = "/system/lib/liblog.so"
+        d = "/system/lib/libc.so"
+        n = None
+        max_int = 0xffffffffffffffff
+
+        # Test address before the first entry comes back with nothing mapped up
+        # to first valid region info
+        check_region(-1, 0x00000000, 0x400d9000, False, False, False, False, n)
+        check_region( 0, 0x400d9000, 0x400db000, True,  False, True,  True,  a)
+        check_region( 1, 0x400db000, 0x400dc000, True,  False, False, True,  a)
+        check_region( 2, 0x400dc000, 0x400dd000, True,  True,  False, True,  n)
+        check_region( 3, 0x400dd000, 0x400ec000, True,  False, True,  True,  b)
+        check_region( 4, 0x400ec000, 0x400ed000, True,  False, False, True,  n)
+        check_region( 5, 0x400ed000, 0x400ee000, True,  False, False, True,  b)
+        check_region( 6, 0x400ee000, 0x400ef000, True,  True,  False, True,  b)
+        check_region( 7, 0x400ef000, 0x400fb000, True,  True,  False, True,  n)
+        check_region( 8, 0x400fb000, 0x400fc000, True,  False, True,  True,  c)
+        check_region( 9, 0x400fc000, 0x400fd000, True,  True,  True,  True,  c)
+        check_region(10, 0x400fd000, 0x400ff000, True,  False, True,  True,  c)
+        check_region(11, 0x400ff000, 0x40100000, True,  False, False, True,  c)
+        check_region(12, 0x40100000, 0x40101000, True,  True,  False, True,  c)
+        check_region(13, 0x40101000, 0x40122000, True,  False, True,  True,  d)
+        check_region(14, 0x40122000, 0x40123000, True,  True,  True,  True,  d)
+        check_region(15, 0x40123000, 0x40167000, True,  False, True,  True,  d)
+        check_region(16, 0x40167000, 0x40169000, True,  False, False, True,  d)
+        check_region(17, 0x40169000, 0x4016b000, True,  True,  False, True,  d)
+        check_region(18, 0x4016b000, 0x40176000, True,  True,  False, True,  n)
+        check_region(-1, 0x40176000, max_int,    False, False, False, False, n)

scripts/interface/SBMemoryRegionInfo.i

public:
     bool
     IsWritable ();
 
     bool
     IsExecutable ();
 
     bool
     IsMapped ();
     
+    const char *
+    GetName ();
+
     bool
     operator == (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     operator != (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     GetDescription (lldb::SBStream &description);
 
 };
 
 } // namespace lldb

source/Plugins/Process/minidump/MinidumpParser.h

public:
   const MinidumpExceptionStream *GetExceptionStream();
 
   llvm::Optional<Range> FindMemoryRange(lldb::addr_t addr);
 
   llvm::ArrayRef<uint8_t> GetMemory(lldb::addr_t addr, size_t size);
 
   MemoryRegionInfo GetMemoryRegionInfo(lldb::addr_t load_addr);
 
+  const MemoryRegionInfos &GetMemoryRegions();
+
   // Perform consistency checks and initialize internal data structures
   Status Initialize();
 
 private:
   MinidumpParser(const lldb::DataBufferSP &data_buf_sp);
 
   MemoryRegionInfo FindMemoryRegion(lldb::addr_t load_addr) const;
 

source/Plugins/Process/minidump/MinidumpParser.cpp

MinidumpParser::FindMemoryRegion(lldb::addr_t load_addr) const {
   region.SetWritable(MemoryRegionInfo::eNo);
   region.SetExecutable(MemoryRegionInfo::eNo);
   region.SetMapped(MemoryRegionInfo::eNo);
   return region;
 }
 
 MemoryRegionInfo
 MinidumpParser::GetMemoryRegionInfo(lldb::addr_t load_addr) {
+  if (!m_parsed_regions)
+    GetMemoryRegions();
+  return FindMemoryRegion(load_addr);
+}
+
+const MemoryRegionInfos &MinidumpParser::GetMemoryRegions() {
   if (!m_parsed_regions) {
     m_parsed_regions = true;
     // We haven't cached our memory regions yet we will create the region cache
     // once. We create the region cache using the best source. We start with
     // the linux maps since they are the most complete and have names for the
     // regions. Next we try the MemoryInfoList since it has
     // read/write/execute/map data, and then fall back to the MemoryList and
     // Memory64List to just get a list of the memory that is mapped in this
     // core file
     if (!CreateRegionsCacheFromLinuxMaps(*this, m_regions))
       if (!CreateRegionsCacheFromMemoryInfoList(*this, m_regions))
         if (!CreateRegionsCacheFromMemoryList(*this, m_regions))
           CreateRegionsCacheFromMemory64List(*this, m_regions);
     std::sort(m_regions.begin(), m_regions.end());
   }
-  return FindMemoryRegion(load_addr);
+  return m_regions;
 }
 
 Status MinidumpParser::Initialize() {
   Status error;
 
   lldbassert(m_directory_map.empty());
 
   llvm::ArrayRef<uint8_t> header_data(m_data_sp->GetBytes(),

source/Plugins/Process/minidump/MinidumpTypes.cpp

MinidumpMemoryInfo::ParseMemoryInfoList(llvm::ArrayRef<uint8_t> &data) {
 
   data = data.drop_front(header->size_of_header -
                          sizeof(MinidumpMemoryInfoListHeader));
 
   if (header->size_of_entry * header->num_of_entries > data.size())
     return {};
 
   std::vector<const MinidumpMemoryInfo *> result;
+  result.reserve(header->num_of_entries);
+
   for (uint64_t i = 0; i < header->num_of_entries; ++i) {
     result.push_back(reinterpret_cast<const MinidumpMemoryInfo *>(
         data.data() + i * header->size_of_entry));
   }
 
   return result;
 }

source/Plugins/Process/minidump/ProcessMinidump.h

public:
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       Status &error) override;
 
   ArchSpec GetArchitecture();
 
   Status GetMemoryRegionInfo(lldb::addr_t load_addr,
                              MemoryRegionInfo &range_info) override;
 
+  Status GetMemoryRegions(
+      lldb_private::MemoryRegionInfos &region_list) override;
+
   bool GetProcessInfo(ProcessInstanceInfo &info) override;
 
   Status WillResume() override {
     Status error;
     error.SetErrorStringWithFormat(
         "error: %s does not support resuming processes",
         GetPluginName().GetCString());
     return error;

source/Plugins/Process/minidump/ProcessMinidump.cpp

 }
 
 Status ProcessMinidump::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                             MemoryRegionInfo &range_info) {
   range_info = m_minidump_parser.GetMemoryRegionInfo(load_addr);
   return Status();
 }
 
+Status ProcessMinidump::GetMemoryRegions(
+    lldb_private::MemoryRegionInfos &region_list) {
+  region_list = m_minidump_parser.GetMemoryRegions();
+  return Status();
+}
+
 void ProcessMinidump::Clear() { Process::m_thread_list.Clear(); }
 
 bool ProcessMinidump::UpdateThreadList(ThreadList &old_thread_list,
                                        ThreadList &new_thread_list) {
   uint32_t num_threads = 0;
   if (m_thread_list.size() > 0)
     num_threads = m_thread_list.size();